Pub

mardi 16 mars 2021

myTinyPLC : nouvelle version 1.3

 Voici la nouvelle version 1.3 de myTinyPLC avec désormais la possibilité de rentrer les instructions de programmation à partir du moniteur série.
Cela permet de programmer ou de reprogrammer myTinyPLC sans devoir modifier le programme dans l'IDE Arduino ni le recompiler !

Il y a maintenant deux modes de fonctionnement : le mode RUN où le programme s'exécute normalement et le mode EDIT où l'exécution est arrêtée et où l'on a alors la possibilité de rentrer les instructions du programme IL via le moniteur série. Compte tenu de la mémoire réduite de l'Arduino Uno, le mode EDIT est assez rudimentaire, j'en conviens.

Le mode EDIT permet néanmoins les actions suivantes :
- Lister le programme avec les numéros des pas, les codes instructions et leurs mnémoniques respectives.
- Saisir le programme en rentrant pour chaque pas de programme, son code instruction.
- Insérer un pas de programme si besoin, et décaler les suivants.
- Si besoin, on peut désactiver un pas de programme en rentrant l'instruction 80 (NOP : no operation) car il n'y a pas de suppression de pas de programme.


Mode opératoire :

myTinyPLC démarre automatiquement en mode RUN. Si des instructions sont déjà pré renseignées dans le programme C++ dans le tableau d'instructions stp[n], myTinyPLC va les exécuter.

Pour modifier ou saisir de nouvelles instructions, on passe en mode EDIT en tapant 0 puis Entrée (zéro et on valide) 
avec le clavier du pc en utilisant le moniteur série de l'IDE. Puis on se laisse guider par l'affichage du moniteur série sur le pc.


Voici un petit schéma de principe de l'arborescence du mode EDIT :


[RUN mode] (RUN is the default mode at start-up)
 |
 |
 +---> 0 <Enter> --->[EDIT mode]
     (zero)            |
                       +-
--> 0 <Enter> -+-> 0 <Enter> Exit EDIT mode ---->[RUN mode]
                       |                |
                       |                +-> 1 <Enter> [List the instructions]
                       |                                     |
                       |                                     +--> 0 <Enter>
                       |                                     |        |     End list
                       |                                     |        +-->[EDIT mode]
                       |                                     |    
                       |                                     +--> 1 <Enter
                       |                                              |     Continue
                       |                                              +-->[List inst]
                       |
                       |
                       +---> n <Enter> --[edit step n]--> op <Enter> ---->[EDIT mode]
                             :                             : 
                         step number                  instruction code
                        n from 1 to 99                 op from 0 to 99
                                                   if 88 then insert a step


Le code de myTinyPLC en version 1.3.0 du 16/03/2021 :

/* Program name: mytinyPLC-1-3-0.ino
   Author: Guy Vanoverbeke @GuyVano
   Program last update (dd/mm/yyyy) : 16/03/2021 - V.1 R.3 C.0
   - Release name "Dare Dary"
   Arduino IDE V1.8.13
   Board: Arduino UNO R3
   Function: PLC simulator with its own IL language.
    Simulateur d'automate programmable doté de son propre langage IL.
   -----------
   Disclaimer:
   This program (in other words: this code, this software or this application) is
   a personal creation made as part of a hobby and it is given without guarantee
   of any kind and no support is provided. It is free of rights and can be reused
   freely as you wish.
*/
#include <LiquidCrystal.h>
LiquidCrystal lcd(7, 6, 5, 4, 3, 2);
//
boolean i1 = 0; // used to store input 1 value
boolean i2 = 0; // used to store input 2 value
boolean i3 = 0; // used to store input 3 value
boolean i4 = 0; // used to store input 4 value
//
boolean p[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // potentiometer indexed position 0 to 9
//
boolean m1 = 0; // used to store memory 1 value
boolean m2 = 0; // used to store memory 2 value
boolean m3 = 0; // used to store memory 3 value
boolean m4 = 0; // used to store memory 4 value
boolean m5 = 0; // used to store memory 5 value
boolean m6 = 0; // memory 6 is tm6 starter
boolean m7 = 0; // memory 7 is tm7 starter
boolean m8 = 0; // memory 8 is tm8 starter
boolean m9 = 0; // memory 9 is tm9 starter
//
boolean pm6 = 0; // previous state of memory 6
boolean pm7 = 0; // previous state of memory 7
boolean pm8 = 0; // previous state of memory 8
boolean pm9 = 0; // previous state of memory 9
//
boolean tm6 = 0; // timer 6
boolean tm7 = 0; // timer 7
boolean tm8 = 0; // timer 8
boolean tm9 = 0; // timer 9
//
boolean mx = 0; // temporary memory used for Swap operation
//
boolean o1 = 0; // used to store output 1 value
boolean o2 = 0; // used to store output 2 value
boolean o3 = 0; // used to store output 3 value
boolean o4 = 0; // used to store output 4 value
boolean stack[8] = {0, 0, 0, 0, 0, 0, 0, 0}; // bit Stack array
boolean edtmode = false; // true when edit mode
//
unsigned int ai1 = 0; // analog input 1 value calculated
int j = 0; // loop control
int k = 0; // loop control and temporary variable
long r = 0; // temporary variable
long s = 0; // temporary variable
long t = 0; // temporary variable
int istack0 = 0; //
//
const int nbstp = 99; //number of maximum IL program steps starting from 1
int stp[(nbstp + 1)] = {}; // IL program steps array dim = nbstp + 1
int stc = 0; // step counter
//
long ctrtm6 = 0; // current millis counter when timer 6 rised to High
long ctrtm7 = 0; // current millis counter when timer 7 rised to High
long ctrtm8 = 0; // current millis counter when timer 8 rised to High
long ctrtm9 = 0; // current millis counter when timer 9 rised to High
//
long dtm6 = 8000; // set default delay value for timer 6 in ms
long dtm7 = 2000; // set default delay value for timer 7 in ms
long dtm8 = 6000; // set default delay value for timer 8 in ms
long dtm9 = 4000; // set default delay value for timer 9 in ms
//
String ope = "ab";
//

void setup()
{
  //
  Serial.begin(9600); // open the serial port at 9600 bps:
  //
  pinMode(A1, INPUT); // buton 1 as input 1
  pinMode(A2, INPUT); // buton 2 as input 2
  pinMode(A3, INPUT); // buton 3 as input 3
  pinMode(8, INPUT);  // buton 4 as input 4
  //
  pinMode(10, OUTPUT); // LED 1 (red) as output 1
  pinMode(11, OUTPUT); // LED 2 (yellow) as ouput 2
  pinMode(12, OUTPUT); // LED 3 (green) as output 3
  pinMode(13, OUTPUT); // LED 4 (blue) as output 4
  //
  j = 0;
  do {
    j++;
    stp[j] = 80; // write NOP in all steps
  } while (j <= (nbstp));
  //
  //
  lcd.begin(16, 2);
  lcd.print("mytinyPLC v1-3-0");
  lcd.setCursor(0, 1);
  lcd.print("project @guyvano");
  delay(1000);
  lcd.clear();
  //
  // v---- your IL program steps here / Votre programme IL ici
  //
  //
  // Light on the LEDs following the potentiometer position
  // IL program for myTinyPLC v.1.2 and over.
  //
  stp[1] = 71; // Read p(1)
  stp[2] = 41; // Write output 1
  stp[3] = 72; // Read p(2)
  stp[4] = 42; // Write output 2
  stp[5] = 73; // Read p(3)
  stp[6] = 43; // Write output 3
  stp[7] = 74; // Read p(4)
  stp[8] = 44; // Write output 4
  stp[9] = 99; // END
  //
  //
  // ^---- end of your IL program / fin de votre programme
  //
  // it is a good idea to comment each line with the mnemonic of
  // the instruction, for a better IL program reading and understanding
  //
  //
  Serial.println(' ');
  Serial.println("in Run mode, type 0 <Enter> to enter Edit mode");
  Serial.println(' ');
}

void loop()
{

  //
  // If 0 <Enter> typed from the serial monitor is zero, run the edit module
  //
  if (Serial.available() > 0) {
    r = Serial.read();
    if (r == '0') {
      edtmode = true;
      edit();
    }
  }
  //
  // update IL program instruction counter
  // (one IL step evaluated per loop)
  //
  stc = (stc % nbstp) + 1;
  //
  // digital input acquisition
  // at least for displaying them later
  // even if they are note read by the IL program
  //
  i1 = digitalRead(A1);
  i2 = digitalRead(A2);
  i3 = digitalRead(A3);
  i4 = digitalRead(8);
  //
  // analog input acquisition
  //
  ai1 = analogRead(A0) / 113;      // value 0..9
  //
  // set corresponding p[] array element
  //
  j = 0;
  do {
    // set all to 0
    p[j] = 0;
    j++;
  } while (j <= 9);
  p[ai1] = 1; // set to 1 the corresponding p[] array element
  //
  //
  // Start IL instruction scrutation (one IL step per loop)
  //
  //
  // check if instruction code is a one figure number and
  // if it is, consider it is a number and stack it in the integer stack
  //
  switch (stp[stc]) {
    //
    case 0:
      //
      istack0 = 0;
      break;
    //
    case 1:
      //
      istack0 = 1;
      break;
    //
    case 2:
      //
      istack0 = 2;
      break;
    //
    case 3:
      //
      istack0 = 3;
      break;
    //
    case 4:
      //
      istack0 = 4;
      break;
    //
    case 5:
      //
      istack0 = 5;
      break;
    //
    case 6:
      //
      istack0 = 6;
      break;
    //
    case 7:
      //
      istack0 = 7;
      break;
    //
    case 8:
      //
      istack0 = 8;
      break;
    //
    case 9:
      //
      istack0 = 9;
      break;
    //
    default:
      // no instruction match
      break;
  }
  //
  //
  // check if operation code is Read an input (instruction codes 10 to 14)
  //
  switch (stp[stc]) {
    //
    case 10:
      // read analog input 1
      istack0 = ai1;
      break;
    //
    case 11:
      // read digital input 1
      dwnstack();
      stack[0] = i1;
      break;
    //
    case 12:
      // read digital input 2
      dwnstack();
      stack[0] = i2;
      break;
    //
    case 13:
      // read digital input 3
      dwnstack();
      stack[0] = i3;
      break;
    //
    case 14:
      // read digital input 4
      dwnstack();
      stack[0] = i4;
      break;
    //
    default:
      // no instruction match
      break;
  }
  //
  // check if instruction code is Read a digital memory (instruction codes 21 to 29)
  //
  switch (stp[stc]) {
    //
    case 21:
      // read digital memory 1
      dwnstack();
      stack[0] = m1;
      break;
    //
    case 22:
      // read digital memory 2
      dwnstack();
      stack[0] = m2;
      break;
    //
    case 23:
      // read digital memory 3
      dwnstack();
      stack[0] = m3;
      break;
    //
    case 24:
      // read digital memory 4
      dwnstack();
      stack[0] = m4;
      break;
    //
    case 25:
      // read digital memory 5
      dwnstack();
      stack[0] = m5;
      break;
    //
    case 26:
      // read timer 6 (bit)
      dwnstack();
      stack[0] = tm6;
      break;
    //
    //
    case 27:
      // read timer 7 (bit)
      dwnstack();
      stack[0] = tm7;
      break;
    //
    //
    case 28:
      // read timer 8 (bit)
      dwnstack();
      stack[0] = tm8;
      break;
    //
    case 29:
      // read timer 9 (bit)
      dwnstack();
      stack[0] = tm9;
      break;
    //
    default:
      // no operation match
      break;
  }
  //
  // check if instruction is Read an output (instruction codes 31 to 34)
  //
  switch (stp[stc]) {
    //
    case 31:
      // read digital output 1
      o1 = digitalRead(10);
      dwnstack();
      stack[0] = o1;
      break;
    //
    case 32:
      // read digital output 2
      o2 = digitalRead(11);
      dwnstack();
      stack[0] = o2;
      break;
    //
    case 33:
      // read digital output 3
      o3 = digitalRead(12);
      dwnstack();
      stack[0] = o3;
      break;
    //
    case 34:
      // read digital output 4
      o4 = digitalRead(13);
      dwnstack();
      stack[0] = o4;
      break;
    //
    default:
      // no instruction match
      break;
  }
  //
  // check if instruction is Write a digital output (instruction codes 41 to 44)
  //
  switch (stp[stc]) {
    //
    case 41:
      // write digital output 1
      o1 = stack[0];
      // digitalWrite(10, o1);
      break;
    //
    case 42:
      // write digital output 2
      o2 = stack[0];
      // digitalWrite(11, o2);
      break;
    //
    case 43:
      // write digital output 3
      o3 = stack[0];
      // digitalWrite(12, o3);
      break;
    //
    case 44:
      // write digital output 4
      o4 = stack[0];
      // digitalWrite(13, o4);
      break;
    //
    default:
      // no instruction match
      break;
  }
  //
  // check if instruction is Write a memory (instruction codes 51 to 59)
  //
  switch (stp[stc]) {
    //
    case 51:
      // write digital memory 1
      m1 = stack[0];
      break;
    //
    case 52:
      // write digital memory 2
      m2 = stack[0];
      break;
    //
    case 53:
      // write digital memory 3
      m3 = stack[0];
      break;
    //
    case 54:
      // write digital memory 4
      m4 = stack[0];
      break;
    //
    case 55:
      // write digital memory 5
      m5 = stack[0];
      break;
    //
    case 56:
      // write memory 6
      m6 = stack[0];
      break;
    //
    case 57:
      // write memory 7
      m7 = stack[0];
      break;
    //
    case 58:
      // write memory 8
      m8 = stack[0];
      break;
    case 59:
      // Start timer 9
      m9 = stack[0];
      break;
    //
    default:
      // no instruction match
      break;
  }
  //
  // check if instruction is to Write bit 0 or 1 (instruction codes 60 to 61)
  //
  switch (stp[stc]) {
    //
    case 60:
      // write 0
      dwnstack();
      stack[0] = 0;
      break;
    //
    case 61:
      // write 1
      dwnstack();
      stack[0] = 1;
      break;
    //
    default:
      // no instruction match
      break;
  }
  //
  // check if instruction is Set Timer Delay (instruction codes 66 to 69)
  // value in istack0 must be the delay in seconds.
  //
  switch (stp[stc]) {
    //
    case 66:
      // write timer 6 delay
      dtm6 = 1000 * istack0;
      break;
    //
    case 67:
      // write timer 7 delay
      dtm7 =  1000 * istack0;
      break;
    //
    case 68:
      // write timer 8 delay
      dtm8 =  1000 * istack0;
      break;
    //
    case 69:
      // write timer 9 delay
      dtm9 = 1000 * istack0;
      break;
    //
    default:
      // no instruction match
      break;
  }
  //
  // check if instruction is Read analog index potentiometer position
  //
  switch (stp[stc]) {
    case 70:
      // read p[0]
      dwnstack();
      stack[0] = p[0];
      break;
    //
    case 71:
      // read p[1]
      dwnstack();
      stack[0] = p[1];
      break;
    //
    case 72:
      // read p[2]
      dwnstack();
      stack[0] = p[2];
      break;
    //
    case 73:
      // read p[3]
      dwnstack();
      stack[0] = p[3];
      break;
    //
    case 74:
      // read p[4]
      dwnstack();
      stack[0] = p[4];
      break;
    //
    case 75:
      // read p[5]
      dwnstack();
      stack[0] = p[5];
      break;
    //
    //
    case 76:
      // read p[6]
      dwnstack();
      stack[0] = p[6];
      break;
    //
    case 77:
      // read p[7]
      dwnstack();
      stack[0] = p[7];
      break;
    //
    case 78:
      // read p[8]
      dwnstack();
      stack[0] = p[8];
      break;
    //
    case 79:
      // read p[9]
      dwnstack();
      stack[0] = p[9];
      break;
    //
    default:
      // no instruction match
      break;
  }
  //
  // check if instruction is a boolean operation (instruction codes 81 to 84)
  //
  switch (stp[stc]) {
    //
    case 81:
      // AND
      stack[1] = stack[0] & stack[1];
      upstack();
      break;
    //
    case 82:
      // OR
      stack[1] = stack[0] | stack[1];
      upstack();
      break;
    //
    case 83:
      // NOT
      if (stack[0] == 0) {
        stack[0] = 1;
      }
      else {
        stack[0] = 0;
      }
      break;
    //
    case 84:
      // XOR
      stack[1] = stack[0] ^ stack[1];
      upstack();
      break;
    //
    default:
      // no instruction match
      break;
  }
  //
  // check if instruction is a stack operation
  //
  switch (stp[stc]) {
    //
    case 91:
      // DUP
      dwnstack();
      stack[0] = stack[1];
      break;
    //
    case 92:
      // SWAP
      mx = stack[0];
      stack[0] = stack[1];
      stack[1] = mx;
      break;
    //
    case 93:
      // DROP
      upstack();
      break;
    //
    default:
      // no instruction match
      break;
  }
  //
  // scrutation end of IL program array
  // ----------------------------------
  //
  //
  //     timer 6 evaluation
  //
  //
  if ((m6 == 1) & (pm6 == 0)) {
    if  (tm6 == 0) {
      // tm6 start
      ctrtm6 = millis();
      tm6 = 1;
      pm6 = 1;
    } else {
      // tm6 already started
      pm6 = 1;
    }
  }
  //
  if ((m6 == 0) & (pm6 == 1)) {
    // m6 has just felt to Low
    pm6 = 0;
  }
  if ((tm6 == 1) & ((ctrtm6 + dtm6) <= millis())) {
    // delay over switch off tm6
    tm6 = 0;
  }
  //
  //     timer 7 evaluation
  //
  if ((m7 == 1) & (pm7 == 0)) {
    if  (tm7 == 0) {
      // tm7 start
      ctrtm7 = millis();
      tm7 = 1;
      pm7 = 1;
    } else {
      // tm7 already started
      pm7 = 1;
    }
  }
  //
  if ((m7 == 0) & (pm7 == 1)) {
    // m7 has just felt to Low
    pm7 = 0;
  }
  if ((tm7 == 1) & ((ctrtm7 + dtm7) <= millis())) {
    // delay over switch off tm7
    tm7 = 0;
  }
  //
  //     timer 8 evaluation
  //
  if ((m8 == 1) & (pm8 == 0)) {
    if  (tm8 == 0) {
      // tm8 start
      ctrtm8 = millis();
      tm8 = 1;
      pm8 = 1;
    } else {
      // tm8 already started
      pm8 = 1;
    }
  }
  //
  if ((m8 == 0) & (pm8 == 1)) {
    // m8 has just felt to Low
    pm8 = 0;
  }
  if ((tm8 == 1) & ((ctrtm8 + dtm8) < millis())) {
    // delay over switch off tm8
    tm8 = 0;
  }
  //
  //     timer 9 evaluation
  //
  if ((m9 == 1) & (pm9 == 0)) {
    if  (tm9 == 0) {
      // tm9 start
      ctrtm9 = millis();
      tm9 = 1;
      pm9 = 1;
    } else {
      // tm9 already started
      pm9 = 1;
    }
  }
  //
  if ((m9 == 0) & (pm9 == 1)) {
    // m9 has just felt to Low
    pm9 = 0;
  }
  if ((tm9 == 1) & ((ctrtm9 + dtm9) < millis())) {
    // delay over switch off tm9
    tm9 = 0;
  }
  //
  //   write digital outputs value
  //
  digitalWrite(10, o1);
  digitalWrite(11, o2);
  digitalWrite(12, o3);
  digitalWrite(13, o4);
  //
  // display inputs on LCD line 1
  //
  lcd.setCursor(0, 0);
  lcd.print("i");
  lcd.print(i1);
  lcd.print(i2);
  lcd.print(i3);
  lcd.print(i4);
  //
  lcd.setCursor(5, 0);
  lcd.print("(");
  lcd.print(ai1);
  lcd.print(")");
  //
  //
  lcd.setCursor(12, 0);
  lcd.print("RUN ");

  //
  // display outputs and memories on LCD line 2
  //
  lcd.setCursor(0, 1);
  lcd.print("o");
  lcd.print(o1);
  lcd.print(o2);
  lcd.print(o3);
  lcd.print(o4);
  lcd.print(" m");
  lcd.print(m1);
  lcd.print(m2);
  lcd.print(m3);
  lcd.print(m4);
  lcd.print(m5);
  lcd.print(tm6);
  lcd.print(tm7);
  lcd.print(tm8);
  lcd.print(tm9);
  //
  // Check if End of program
  //
  if (stp[stc] == 99) {
    stc = 0;
  }
}
void dwnstack()
{
  //
  // shift the stack elements down
  //
  stack[9] = stack[8]; // note : previous stack[9] is lost
  stack[8] = stack[7];
  stack[7] = stack[6];
  stack[6] = stack[5];
  stack[5] = stack[4];
  stack[4] = stack[3];
  stack[3] = stack[2];
  stack[2] = stack[1];
  stack[1] = stack[0];
  stack[0] = 0;
}

void upstack()
{
  //
  // shift the stack elements up
  //
  stack[0] = stack[1];
  stack[1] = stack[2];
  stack[2] = stack[3];
  stack[3] = stack[4];
  stack[4] = stack[5];
  stack[5] = stack[6];
  stack[6] = stack[7];
  stack[7] = stack[8];
  stack[8] = stack[9];
  stack[9] = 0;
}

void edit()
{
  Serial.setTimeout(90000);
  do {
    //
    lcd.setCursor(12, 0);
    lcd.print("EDIT");
    //
    Serial.println("  ");
    Serial.println("Edit mode");
    Serial.println("=========");
    Serial.println("  ");
    Serial.println("Type 0 <Enter> to exit Edit mode or to list the IL program.");
    Serial.println("Type a line number <Enter> to modify the program step.");
    Serial.println(' ');
    Serial.println("Command (0/n)?");
    r = Serial.parseInt();
    Serial.print(">");
    Serial.println(r);
    if (r != 0) {
      Serial.println("  ");
      Serial.print("The actual program step ");
      Serial.print(r);
      Serial.println(" is:");
      Serial.print(r);
      Serial.print(':');
      Serial.println(stp[r]);
      Serial.println("  ");
      Serial.println("Please, complete the step with the new instruction code or 88 to insert.");
      Serial.print(r);
      Serial.print(": ?");
      s = Serial.parseInt();
      Serial.print(">");
      Serial.println(s);
      if (s == 88) {
        // shift the next steps
        Serial.println("  ");
        Serial.print("inserting a new step and shifting the following steps...");
        j = nbstp + 2;
        do {
          j--;
          stp[j] = stp[(j - 1)];
        } while (r < j);
        stp[r] = 80; // NOP
        Serial.println("  ");
        Serial.print("The new step ");
        Serial.print(r);
        Serial.println(" has been inserted.");
        Serial.print(r);
        Serial.print(':');
        Serial.println(stp[r]);
      } else {
        stp[r] = s;
        Serial.println("  ");
        Serial.println("The new step is:");
        Serial.print(r);
        Serial.print(':');
        Serial.println(stp[r]);
      }
    } else {
      Serial.println("  ");
      Serial.println("Command (0/1)? 0 <Enter>:Exit / 1 <Enter>:Program list");
      s = Serial.parseInt();
      Serial.print(">");
      Serial.println(s);
      switch (s) {
        case 0:
          edtmode = false;
          //
          break;
        //
        case 1:
          //
          j = 0;
          Serial.println("  ");
          Serial.println("  ");
          Serial.println("Program list:");
          Serial.println("  ");
          do {
            j++;
            Serial.print(j);
            Serial.print(':');
            Serial.print(stp[j]);
            Serial.print("\t");
            switch (stp[j])  {
              case 0:
                ope = "dec nbr 0";
                break;
              case 1:
                ope = "dec nbr 1";
                break;
              case 2:
                ope = "dec nbr 2";
                break;
              case 3:
                ope = "dec nbr 3";
                break;
              case 4:
                ope = "dec nbr 4";
                break;
              case 5:
                ope = "dec nbr 5";
                break;
              case 6:
                ope = "dec nbr 6";
                break;
              case 7:
                ope = "dec nbr 7";
                break;
              case 8:
                ope = "dec nbr 8";
                break;
              case 9:
                ope = "dec nbr 9";
                break;
              case 10:
                ope = "R analog inp.1";
                break;
              case 11:
                ope = "R inp.1";
                break;
              case 12:
                ope = "R inp.2";
                break;
              case 13:
                ope = "R inp.3";
                break;
              case 14:
                ope = "R inp.4";
                break;
              case 21:
                ope = "R mem.1";
                break;
              case 22:
                ope = "R mem.2";
                break;
              case 23:
                ope = "R mem.3";
                break;
              case 24:
                ope = "R mem.4";
                break;
              case 25:
                ope = "R mem.5";
                break;
              case 26:
                ope = "R tmr 6";
                break;
              case 27:
                ope = "R tmr 7";
                break;
              case 28:
                ope = "R tmr 8";
                break;
              case 29:
                ope = "R tmr 9";
                break;
              case 31:
                ope = "R outp.1";
                break;
              case 32:
                ope = "R outp.2";
                break;
              case 33:
                ope = "R outp.3";
                break;
              case 34:
                ope = "R outp.4";
                break;
              case 41:
                ope = "W outp.1";
                break;
              case 42:
                ope = "W outp.2";
                break;
              case 43:
                ope = "W outp.3";
                break;
              case 44:
                ope = "W outp.4";
                break;
              case 51:
                ope = "W mem.1";
                break;
              case 52:
                ope = "W mem.2";
                break;
              case 53:
                ope = "W mem.3";
                break;
              case 54:
                ope = "W mem.4";
                break;
              case 55:
                ope = "W mem.5";
                break;
              case 56:
                ope = "W tmr 6";
                break;
              case 57:
                ope = "W tmr 7";
                break;
              case 58:
                ope = "W tmr 8";
                break;
              case 59:
                ope = "W tmr 9";
                break;
              case 60:
                ope = "bit 0";
                break;
              case 61:
                ope = "bit 1";
                break;
              case 66:
                ope = "tmr 6 delay";
                break;
              case 67:
                ope = "tmr 7 delay";
                break;
              case 68:
                ope = "tmr 8 delay";
                break;
              case 69:
                ope = "tmr 9 delay";
                break;
              case 70:
                ope = "R p(0)";
                break;
              case 71:
                ope = "R p(1)";
                break;
              case 72:
                ope = "R p(2)";
                break;
              case 73:
                ope = "R p(3)";
                break;
              case 74:
                ope = "R p(4)";
                break;
              case 75:
                ope = "R p(5)";
                break;
              case 76:
                ope = "R p(6)";
                break;
              case 77:
                ope = "R p(7)";
                break;
              case 78:
                ope = "R p(8)";
                break;
              case 79:
                ope = "R p(9)";
                break;
              case 80:
                ope = "NOP";
                break;
              case 81:
                ope = "AND";
                break;
              case 82:
                ope = "OR";
                break;
              case 83:
                ope = "NOT";
                break;
              case 84:
                ope = "XOR";
                break;
              case 91:
                ope = "DUP";
                break;
              case 92:
                ope = "SWAP";
                break;
              case 93:
                ope = "DROP";
                break;
              case 99:
                ope = "END";
                break;
              //
              default:
                ope = "(unassigned)";
                break;
            }
            Serial.println(ope);
            if (j % (10) == 0) {
              Serial.println("  ");
              Serial.println("  ");
              Serial.println("Command (0/1)? 0 <Enter> Quit list / 1 <Enter> Continue list");
              t = Serial.parseInt();
              Serial.print(">");
              Serial.println(t);
              if (t == 0) {
                j = nbstp;
              }
            }

          } while ((stp[j] != 99) & ( j < nbstp));
          Serial.println("  ");
          Serial.println("End list.");
      }
    }
  } while (edtmode == true);
  Serial.setTimeout(1000);
  Serial.println("  ");
  Serial.println("End Edit mode, back to normal RUN mode.");
  Serial.println("Type 0 <Enter> for Edit mode.");
  //
  lcd.setCursor(12, 0);
  lcd.print("RUN ");
  //
  loop();
}
// End of myTinyPLC (version 1.3.0 "Dare Dary") - Thanks for watching !


Remarques :

La mémoire interne de l'Arduino Uno commence à être bien remplie ! En l'état de cette version, le compilateur affiche un message d'avertissement : La mémoire disponible faible, des problèmes de stabilité pourraient survenir.

Je souhaitais au départ pouvoir rajouter des servo-moteurs sur myTinyPLC mais j'abandonne cette idée car il faudrait développer la logique pour les calculs et il n'y a clairement plus de place pour cela. Je garde donc le projet myTinyPLC en l'état actuel de sa version 1.3 présentée ci-dessus.

En résumé : myTinyPLC est un simulateur d'automate programmable réalisé avec un Arduino Uno R3 et quelques composants courants d'un starter kit.
 
Il est possède :
 - 
son propre langage de programmation, de type Instruction List, et pouvant se programmer sans recourir à une recompilation dans l'IDE Arduino.
 - une entrée analogique : un potentiomètre, dont on peut connaître la position de 0 à 9 (0 = valeur minimale, en position tournée complètement vers la gauche, et 9  = 
valeur maximale, en position tournée complètement vers la droite). Avec les codes d'instructions de lecture du potentiomètre 70 à 79, il fait fonction de commutateur.
 - 4 entrées binaires (boutons poussoirs).
 - 4 sorties binaires (LEDs).
 - 5 mémoires binaires 0/1 internes (m1 à m5)
 - 4 temporisations réglables de 1 à 9 secondes (tmr6 à tmr9).
 - 2 modes de fonctionnement : un mode Exécution (RUN) et un mode Programmation (EDIT) pour entrer les instructions du programme IL avec le moniteur série.
 - Un afficheur LCD1602 ( 2 lignes de 16 caractères) permet de visualiser l'état des entrées binaires et du potentiomètre, ainsi que l'état des sorties et des mémoires, sans oublier le mode fonctionnement RUN ou EDIT.








Composants et câblage :


Composants :

1 Arduino Uno R3.
1 planche à contacts pour prototypage (breadboard 163 x 54 mm).
1 écran LCD1602.
4 boutons poussoirs.
2 potentiomètres 10 k ohms.
5 résistances 330 ohms 1/8W.
4 résistances 10 k ohms 1/8W.
1 LED rouge.
1 LED jaune.
1 LED verte.
1 LED bleue.
et un certain nombre de fils de câblage.


**** Guy F8ABX - 16/03/2021 ****


Aucun commentaire:

Enregistrer un commentaire