Migration du programme Remoter dans LogicLab

Les produits SlimLine e Netsyst III sont les successeurs d'anciens produits d'automates programmables développés par Elsist, le Picosyst et ses familles Netsyst I-II. Des produits qui ont été programmés avec Remoter, un outil de développement entièrement conçu par nos soins qui vous a permis d'écrire des programmes en ladder, liste d'instructions et langage C standard. Sur le marché, il existe des dizaines de milliers de produits qui exécutent des applications développées dans Remoter, et au fil des ans, le produit est sur le marché depuis 1991, beaucoup décident de remplacer les anciens produits par de nouveaux et se retrouvent dans le besoin de réécrire les anciens programmes avec LogicLab. Voici un programme de liste d'instructions classique écrit avec Remoter.

ORGR
LODT  I 0000            ; Pulsante start
ORLT  O 0000            ; Comando pompa
ANDT  I 0001            ; Pulsante stop
OUTT  O 0000            ; Comando pompa
OUTM  T 0000  K 0050    ; Pausa comando Ev

ORGR
LODF  T 0000            ; Pausa comando Ev
UTCH  O 0001            ; Ev acqua

ORGR
LODT  T 0000            ; Pausa comando Ev
LTCH  O 0001            ; Ev acqua

Si pour le langage à contacts, il est intuitif de passer du programme Remoter au programme LogicLab, vous pouvez vous reporter au langage de liste d'instructions. Manuel éloigné pour comprendre comment fonctionnent les instructions. Mais pour réécrire un programme, mon conseil est d'utiliser les noms de variable Remoter également dans LogicLab. Il est donc facile de vérifier les deux programmes. Voici donc la capture d'écran avec le programme converti (Télécharger le programme).

Comme vous pouvez le constater, j’ai déclaré toutes les variables en tant que variables globales, en supposant que le même identificateur était utilisé dans Remoter comme nom. I 0000 devient I_0000, F 0000 devient F_0000 et ainsi de suite. Tandis que si le programme est intuitif pour le ladder, voyons comment il a été converti en une liste d'instructions.

  LD    I_0000    (* Pulsante start *)
  OR    O_0000    (* Comando pompa *)
  ANDN  I_0001    (* Pulsante stop *)
  ST    O_0000    (* Comando pompa *)
  ST    T_0000.IN (* Pausa comando Ev *)

  LD    500       (* 500 mS *)
  ST    T_0000.PT
  CAL   T_0000    (* Pausa comando Ev *)

  LDN   O_0000    (* Comando pompa *)
  R     O_0001    (* Ev acqua *)

  LD   T_0000.Q   (* Pausa comando Ev *)
  S    O_0001     (* Ev acqua *)

Voici la description des instructions IL.

+-------+-----------------+----------------------------------------------------------------------------------+
| Istr. | Operandi        | Descrizione                                                                      |
+-------+-----------------+----------------------------------------------------------------------------------+
| LD    | Tutti           | Carica il valore operando nell'accumulatore                                      |
| LDN   | Tutti           | Carica il valore negato operando nell'accumulatore                               |
| ST    | Tutti           | Trasferisce il valore dell'accumulatore nell'operando                            |
| STN   | Tutti           | Trasferisce il valore negato dell'accumulatore nell'operando                     |
| S     | BOOL            | Setta l'operando (Accetta solo BOOL) se l'accumulatore è TRUE                    |
| R     | BOOL            | Resetta l'operando (Accetta solo BOOL) se l'accumulatore è TRUE                  |
| AND   | Tutti meno REAL | AND a bit tra accumulatore e valore operando, risultato in accumulatore          |
| ANDN  | Tutti meno REAL | AND a bit tra accumulatore e valore negato operando, risultato in accumulatore   |
| OR    | Tutti meno REAL | OR a bit tra accumulatore e valore operando, risultato in accumulatore           |
| ORN   | Tutti meno REAL | OR a bit tra accumulatore e valore negato operando, risultato in accumulatore    |
| XOR   | Tutti meno REAL | XOR a bit tra accumulatore e valore operando, risultato in accumulatore          |
| XORN  | Tutti meno REAL | XOR a bit tra accumulatore e valore negato operando, risultato in accumulatore   |
| NOT   |                 | Esegue l'inversione a bit del valore in accumulatore                             |
| ADD   | Tutti meno BOOL | Somma tra accumulatore e valore operando, risultato in accumulatore              |
| SUB   | Tutti meno BOOL | Sottrazione tra accumulatore e valore operando, risultato in accumulatore        |
| MUL   | Tutti meno BOOL | Moltiplicazione tra accumulatore e valore operando, risultato in accumulatore    |
| DIV   | Tutti meno BOOL | Divisione tra accumulatore e valore operando, risultato in accumulatore          |
| MOD   | Tutti meno BOOL | Ritorna il modulo della divisione nell'accumulatore                              |
| GT    | Tutti meno BOOL | Controlla se accumulatore > operando, risultato (BOOL) in accumulatore           |
| GE    | Tutti meno BOOL | Controlla se accumulatore >= operando, risultato (BOOL) in accumulatore          |
| EQ    | Tutti meno BOOL | Controlla se accumulatore = operando, risultato (BOOL) in accumulatore           |
| NE    | Tutti meno BOOL | Controlla se accumulatore <> operando, risultato (BOOL) in accumulatore          |
| LE    | Tutti meno BOOL | Controlla se accumulatore <= operando, risultato (BOOL) in accumulatore          |
| LT    | Tutti meno BOOL | Controlla se accumulatore < operando, risultato (BOOL) in accumulatore           |
| JMP   | Etichetta       | Salta incondizionatamente su etichetta                                           |
| JMPC  | Etichetta       | Salta su etichetta se accumulatore diverso da zero                               |
| JMPCN | Etichetta       | Salta su etichetta se accumulatore uguale a zero                                 |
| CAL   | FB              | Esegue incondizionatamente il blocco funzione                                    |
| CALC  | FB              | Esegue blocco funzione se accumulatore diverso da zero                           |
| CALCN | FB              | Esegue blocco funzione se accumulatore uguale a zero                             |
| RET   |                 | Ritorna incondizionatamente al programma che ha eseguito CALL                    |
| RETC  |                 | Ritorna al programma che ha eseguito CALL se accumulatore diverso da zero        |
+-------+-----------------+----------------------------------------------------------------------------------+

Plus éloigné autorisait également la programmation en langage C standard, dans ce cas, il est possible de convertir des programmes à l'aide du langage ST (Textured Text) dont les constructions sont très proches de celles du langage C. La conversion d'un programme est une opération cache beaucoup de points complexes à contourner, s'il y a des questions spécifiques, je vous conseille de poster la question sur le forum afin d'être visible et donc d'aider les autres.

Cet article a-t-il été utile?