AndyWhittaker
/
OpenPLC-Ladder-Editor
mirror of https://github.com/AndyWhittaker/OpenPLC-Ladder-Editor.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
OpenPLC-Ladder-Editor/ldmicro-rel2.2/ldmicro/manual-fr.txt

1018 lines
48 KiB
Plaintext
Raw Normal View History

First version of the OpenPLC Ladder Editor Code based on LDMicro 2.2
2014-07-22 16:08:56 -07:00
INTRODUCTION
============
LDmicro g<>n<EFBFBD>re du code natif pour certains microcontroleurs Microchip
PIC16F et Atmel AVR. Usuellement les programmes de developpement pour ces
microcontrolleurs sont <20>crits dans des langages comme l'assembleur , le
C ou le Basic. Un programme qui utilise un de ces langages est une suite
de commandes. Ces programmes sont puissants et adapt<70>s <20> l'architecture
des processeurs, qui de fa<66>on interne ex<65>cutent une liste d'instructions.
Les API (Automates Programmables Industriels, PLC en anglais, SPS en
allemand) utilisent une autre voie et sont programm<6D>s en Langage <20>
Contacts (ou LADDER). Un programme simple est repr<70>sent<6E> comme ceci :
|| ||
|| Xbutton1 Tdon Rchatter Yred ||
1 ||-------]/[---------[TON 1.000 s]-+-------]/[--------------( )-------||
|| | ||
|| Xbutton2 Tdof | ||
||-------]/[---------[TOF 2.000 s]-+ ||
|| ||
|| ||
|| ||
|| Rchatter Ton Tnew Rchatter ||
2 ||-------]/[---------[TON 1.000 s]----[TOF 1.000 s]---------( )-------||
|| ||
|| ||
|| ||
||------[END]---------------------------------------------------------||
|| ||
|| ||
(TON est une tempo travail; TOF est une tempo repos. les commandes --] [--
repr<EFBFBD>sentent des Entr<74>es, qui peuvent <20>tre des contacts de relais. Les
commandes --( )-- sont des Sorties, qui peuvent repr<70>senter des bobines de
relais. Beaucoup de r<>f<EFBFBD>rences de programmes de langage <20> contacts (LADDER)
existent sur Internet et sont <20> quelques d<>tails pr<70>s, identiques <20>
l'impl<70>mentation repr<70>sent<6E>e ci-dessus.
Un certain nombre de diff<66>rences apparaissent entre les programmes en
langage <20>volu<6C>s ( C, Basic, Etc..) et les programmes pour API:
* Le programme est repr<70>sent<6E> dans un format graphique, et non
comme une liste de commandes en format texte. Beaucoup de personnes
trouve cela plus facile <20> comprendre.
* Au niveau de base, le programme apparait comme un diagramme
de circuit avec des contacts de relais (Entr<74>es) et des bobines
(Sorties). Ceci est intuitif pour les programmeurs qui connaissent
la th<74>orie des circuits <20>lectriques.
* Le compilateur de langage <20> contacts v<>rifie tout ceci lors
de la compilation. Vous n'avez pas <20> <20>crire de code quand une
Sortie est remplac<61>e et est remise en Entr<74>e ou si une temporisation
est modifi<66>e, vous n'avez pas non plus <20> sp<73>cifier l'ordre o<> les
calculs doivent <20>tre effectu<74>s. L'outil API (PLC) s'occupe de cela
pour vous.
LDmicro compile le langage <20> contact (ladder) en code pour PIC16F ou
AVR. Les processeurs suivants sont support<72>s:
* PIC16F877
* PIC16F628
* PIC16F876 (non test<73>)
* PIC16F88 (non test<73>)
* PIC16F819 (non test<73>)
* PIC16F887 (non test<73>)
* PIC16F886 (non test<73>)
* ATmega128
* ATmega64
* ATmega162 (non test<73>)
* ATmega32 (non test<73>)
* ATmega16 (non test<73>)
* ATmega8 (non test<73>)
Il doit <20>tre facile de supporter d'autres PIC ou AVR, mais je n'est
aucun moyen pour les tester. Si vous en voulez un en particulier faites
moi parvenir votre demande et je verrai ce que je peux faire.
En utilisant LDmicro, vous dessinez un diagramme <20> contacts pour votre
programme. Vous pouvez simuler le fonctionnement logique en temps r<>el sur
votre PC. Quand vous <20>tes convaincu que le fonctionnement est correct,
vous pouvez affecter les broches du microcontroleur pour les Entr<74>es et
Sorties, ensuite vous compilez votre programmeen code AVR ou PIC. Le
fichier de sortie du compilateur est un fichier .HEX que vous devrez
mettre dans le microcontroleur en utilisant un programmateur pour PIC
ou AVR.
LDmicro est con<6F>u pour <20>tre similaire <20> la majorit<69> des API commerciaux.
Il y a quelques exceptions, et une partie des possibilit<69>s n'est
pas standard avec le mat<61>riel industriel. Lire attentivement la
description de chaque instruction m<>me si elle parait famili<6C>re. Ce
document consid<69>re que vous avez une connaisance de base du langage <20>
contact et de la structure des logiciels pour automates programmables.
Cycle d'ex<65>cution : Lecture des Entr<74>es -> Calculs -> Ecriture des Sorties
CIBLES ADDITIONNELLES
=====================
Il est aussi possible de g<>n<EFBFBD>rer du code ANSI C . Vous pouvez utiliser
ceci pour n'importe quel processeur dont vous avez un compilateur C,
mais le runtime est de votre responsabilit<69>. LDmicro g<>r<EFBFBD>re uniquement
le source pour le cycle de l'API. Vous <20>tes responsable de l'appel de
chaque s<>quence du cycle et de l'impl<70>mentation de toutes les Entr<74>es
/ Sorties (Lecture/Ecriture des Entr<74>es digitales, etc ...). Voir les
commentaires dans le code source pour plus de d<>tails.
Finalement, LDmicro peut g<>n<EFBFBD>rer un code byte ind<6E>pendant du processeur
pour une machine virtuelle pr<70>vue pour faire fonctionner ce type de code.
J'ai pr<70>vu un exemple simple d'impl<70>mentation d'un interpr<70>teur /VM
<EFBFBD>crit en code C le plus portable possible. La cible fonctionne juste sur
quelques plateformes ou vous pouvez pr<70>voir votre VM. Ceci peut <20>tre utile
pour des applications ou vous pouvez utiliser le languages <20> contacts
comme du langage script pour customiser un programme important. Voir
les commentaires dans l'exemple pour les d<>tails.
OPTIONS LIGNE DE COMMANDE
=========================
LDmicro.exe fonctionne normallement sans options de ligne de commande.
Vous pouvez faire un raccourci vers le programme et le sauvegarder sur
l'<27>cran , il suffit alors de faire un double clic pour le faire d<>marrer
et vous vous retrouvez ainsi dans l'interface utilisateur.
Si un nom de fichier est pass<73> en ligne de de commande de LDmicro, (ex:
`ldmicro.exe asd.ld'), alors LDmicro va essayer d'ouvrir `asd.ld', si
il existe. Une erreur se produira si `asd.ld' n'existe pas. Vous avez
la possibilit<69> d'associer LDmicro avec les fichiers d'extention .ld.
Ceci permet <20> LDmicro de d<>marrer automatiquement lors d'un double clic
sur un fichier xxx.ld.
Si les arguments de la ligne de commande sont pass<73>s sous la forme:
`ldmicro.exe /c src.ld dest.hex', LDmicro compilera le programme`src.ld',
et sauvegardera le fichier compil<69> sous`dest.hex'. Apr<70>s compilation
LDmicro se termine, que la compilation soit correcte ou pas. Aucun
message n'est affich<63> sur la console. Ce mode est pratique uniquement
lorsque vous ex<65>cutez LDmicro en ligne de commande.
BASES
=====
Si vous ex<65>cutez LDmicro sans arguments de ligne de commande, il d<>marre
avec un programme vide. Si vous d<>marrer avec le nom d'un programme
langage <20> contacts (xxx.ld) en ligne de commande, il va essayer de
charger le programme au d<>marrage. LDmicro utilise son format interne
pour le programme , il ne peut pas importer de programmes <20>dit<69>s par
d'autres outils.
Si vous ne chargez pas un programme existant, LDmicro d<>marre en ins<6E>rant
une ligne vide. Vous pouvez ajouter les instructions pour votre programme:
par exemple ajouter un jeu de contacts (Instruction -> Ins<6E>rer Contact)
qui sera nomm<6D> `Xnew'. `X' d<>signe un contact qui peut <20>tre li<6C> <20> une
broche d'entr<74>e du microcontroleur, vous pouvez affecter la broche pour
ce contact plus tard apr<70>s avoir choisi le microcontroleur et renomm<6D>
les contacts. La premi<6D>re lettre indique de quel type de composants il
s'agit par exemple :
* Xnom -- Reli<6C> <20> une broche d'entr<74>e du microcontroleur
* Ynom -- Reli<6C> <20> une broche de sortie du microcontroleur
* Rnom -- `Relais interne': un bit en m<>moire
* Tnom -- Temporisation; Tempo travail, tempo repos, ou totalisatrice
* Cnom -- Compteur, Compteur ou d<>compteur
* Anom -- Un entier lu sur un comvertisseur A/D
* nom -- Variable g<>n<EFBFBD>rique (Entier : Integer)
Choisir le reste du nom pour d<>crire l'utilisation de ce que fait cet
objet et qui doit <20>tre unique dans tout le programme. Un m<>me nom doit
toujours se r<>f<EFBFBD>rer au m<>me objet dans le programme en entier.Par
exemple , vous aurez une erreur si vous utilisez une tempo travail
(TON) appell<6C>e TDelai et une tempo repos (TOF) appell<6C>e aussi TDelai
dans le m<>me programme, le comptage effectu<74> par ces tempo utilisera le
m<EFBFBD>me emplacement en m<>moire, mais il est acceptable d'avoir une tempo
sauvegard<EFBFBD>e (RTO) Tdelai m<>me nom avec une instruction de RES, dans ce
cas l'instruction fonctionne avec le m<>me timer.
Les noms de variables peuvent <20>tre des lettres, chiffres ou le
caract<EFBFBD>re _. Un nom de variable ne doit pas commencer par un chiffre.
Les noms de variables sont sensibles <20> la casse (majuscule/minuscules).
Les instructions de manipulation de variables (MOV, ADD, EQU,
etc.) peuvent travailler avec des variables de n'importe quel nom. Elles
peuvent avoir acc<63>s aux accumulateurs des temporisations ou des
compteurs. Cela peut quelquefois <20>tre tr<74>s utile, par exemple si vous
voulez contr<74>ler la valeur d'un compteur ou d'une temporisation dans
une ligne particuli<6C>re.
Les variables sont toujours des entiers 16 bits. Leur valeur peut
donc <20>tre comprise entre -32768 et 32767 inclus. Les variables sont
toujours sign<67>es. Vous pouvez les sp<73>cifier de fa<66>on litt<74>rale comme
des nombres d<>cimaux normaux (0, 1234, -56), vous pouvez aussi les
sp<EFBFBD>cifier en caract<63>res ASCII ('A', 'z') en mettant le caract<63>re entre
des guillemets simples. Vous pouvez utiliser un caract<63>re ASCII dans la
majorit<EFBFBD> des endroits o<> vous pouvez utiliser les nombres d<>cimaux.
En bas de l'<27>cran, vous pouvez voir la liste de tous les objets
utilis<EFBFBD>s dans votre programme. La liste est automatiquement g<>n<EFBFBD>r<EFBFBD>e
<EFBFBD> partir du programme. La majorit<69> des objets ne necessitent aucune
configuration. Seuls : les objets `Xnom', `Ynom', and `Anom' doivent <20>tre
affect<EFBFBD>s <20> une broche du micro La premi<6D>re chose <20> faire est de choisir
la microcontroleur utilis<69> : Param<61>res -> Microcontroleur ensuite vous
affectez les broches en faisant un double clic dans la liste.
Vous pouvez modifier le programme en ins<6E>rant ou supprimant des
instructions. Le curseur clignote dans la programme pour indiquer
l'instruction courante s<>lectionn<6E>e et le point d'insertion. S'il ne
clignote pas pressez <Tab> ou cliquer sur une instruction, ou vous
pouvez ins<6E>rer une nouvelle instruction <20> la droite ou <20> la gauche
(en s<>rie avec), ou au dessous ou au dessus (en parall<6C>le avec) de
l'instruction s<>lectionn<6E>e. Quelques op<6F>rations ne sont pas permises ,
par exemple aucune instruction permise <20> droite de la bobine.
Le programme d<>marre avec uniquement une ligne. Vous pouvez ajouter
plusieurs lignes en s<>lectionnant Insertion -> Ligne avant ou apr<70>s
dans le menu. Vous pouvez faire un circuit complexe en pla<6C>ant plusieurs
branches en parall<6C>le ou en s<>rie avec une ligne, mais il est plus clair
de faire plusieurs lignes.
Une fois votre programme <20>crit, vous pouvez le tester par simulation,
et le compiler dans un fichier HEX pour le microcontroleur de destination.
SIMULATION
==========
Pour entrer dans la mode simulation choisir Simulation -> Simuler
ou presser <Ctrl+M> le programme est affich<63> diff<66>remment en mode
simulation. Les instructions activ<69>es sont affich<63>es en rouge vif, les
instructions qui ne le sont pas sont affich<63>es en gris<69>. Appuyer sur la
barre d'espace pour d<>marrer l'API pour 1 cycle. Pour faire fonctionner
continuellement en temps r<>el choisir Simulation ->D<>marrer la simulation
en temps r<>el ou presser <Ctrl+R> L'affichage du programme est mise <20>
jour en temps r<>el en fonction des changements d'<27>tat des entr<74>es.
Vous pouvez valider l'<27>tat des entr<74>es du programme en faisant un
double clic sur l'entr<74>e dans la liste au bas de l'<27>cran, ou sur le
contact `Xnom' de l'instruction dans le programme, pour avoir le reflet
automatiquement de la validation d'une entr<74>e dans le programme, il
faut que le programme soit en cycle.(le d<>marrer par <Ctrl+R> ou barre
d'espace pour un seul cycle).
COMPILER EN CODE NATIF
======================
Le point final est de g<>n<EFBFBD>rer un fichier .HEX qui sera programm<6D> dans le
microcontroleur que vous avez choisi par Param<61>tres -> Microcontroleur
Vous devez affecter les broches d'entr<74>es sorties pour chaque 'Xnom'
et 'Ynom'. Vous pouvez faire cela en faisant un double clic sur la nom
de l'objet dans la liste au bas de l'<27>cran. Une boite de dialogue vous
demande de choisir une des broches non affect<63>es dans la liste.
Vous devez aussi choisir la temps de cycle que voulez utiliser pour
votre application, vous devez aussi choisir la fr<66>quence d'horloge du
processeur. Faire Param<61>tres -> Param<61>tres MCU dans le menu. En g<>n<EFBFBD>ral,
le temps de cycle peut <20>tre laiss<73> <20> la valeur par d<>faut (10 ms) qui est
une bonne valeur pour la majorit<69> des applications. Indiquer la fr<66>quence
du quartz utilis<69> (ou du r<>sonateur c<>ramique ou autres..) et cliquer OK.
Maintenant vous pouvez cr<63>er le fichier pour int<6E>grer dans le
microcontroleur. Choisir Compilation -> Compiler, ou compiler sous...
Si vous avez pr<70>c<EFBFBD>demment compil<69> votre programme, vous pouvez sp<73>cifier
un nom diff<66>rent de fichier de sortie. Si votre programme ne comporte
pas d'erreur (li<6C> <20> la structure du programme), LDmicro g<>n<EFBFBD>re un fichier
IHEX pr<70>t <20> <20>tre programm<6D> dans le chip.
Utilisez votre logiciel et mat<61>riel de programmation habituel pour
charger le fichier HEX dans la microcontroleur. V<>rifiez et validez
les bits de configuration (fuses), pour les processeurs PIC16Fxxx ces
bits sont inclus dans le fichier HEX, et la majorit<69> des logiciels de
programmation les valident automatiquement, pour les processeurs AVR ,
vous devez le faire manuellement.
REFERENCE DES INSTRUCTIONS
==========================
> CONTACT, NORMALLEMENT OUVERT Xnom Rnom Ynom
----] [---- ----] [---- ----] [----
Si le signal arrivant <20> cette instruction est FAUX (0) le signal
de sortie est aussi faux (0), s'il est vrai , il sera aussi vrai
en sortie si et uniquement si la broche d'Entr<74>e ou de Sortie
ou de Relais interne est vraie, sinon l'instruction sera fausse.
Cette instruction peut v<>rifier l'<27>tat d'une broche d'entr<74>e, d'une
broche de sortie ou d'un relais interne
> CONTACT, NORMALLEMENT FERME Xnom Rnom Ynom
----]/[---- ----]/[---- ----]/[----
Si le signal arrivant <20> cette instruction est FAUX (0) le signal
de sortie est vrai (1), s'il est vrai , il sera faux en sortie .
Cette instruction peut v<>rifier l'<27>tat d'une broche d'entr<74>e, d'une
broche de sortie ou d'un relais interne. Fonctionne en opposition
par rapport au contact normallement ouvert.
> BOBINE, NORMALE Rnom Ynom
----( )---- ----( )----
Si le signal arrivant <20> cette instruction est faux, alors le relais
interne ou la broche de sortie est faux (mise <20> z<>ro). Si le signal
arrivant <20> cette instruction est vrai(1), alors le relais interne ou
la broche de sortie est valid<69>e (mise <20> 1). Il n'est pas important
d'affecter une variable <20> une bobine.
Cette instruction est plac<61>e le plus <20> droite dans une s<>quence.
> BOBINE, INVERSE Rnom Ynom
----(/)---- ----(/)----
Si le signal arrivant <20> cette instruction est vrai, alors le relais
interne ou la broche de sortie est faux (mise <20> z<>ro). Si le signal
arrivant <20> cette instruction est faux(0), alors le relais interne ou
la broche de sortie est valid<69>e (mise <20> 1). Il n'est pas important
d'affecter une variable <20> une bobine.
Cette instruction est plac<61>e le plus <20> droite dans une s<>quence.
> BOBINE, ACCROCHAGE Rnom Ynom
----(S)---- ----(S)----
Si le signal arrivant <20> cette instruction est vrai, alors le
relais interne ou la broche de sortie est valid<69>e (mise <20> 1). Cette
instruction permet de changer l'<27>tat d'un relais ou d'une sortie :
uniquement passe <20> vrai, ou reste vrai si elle <20>tait d<>j<EFBFBD> <20> 1,
elle est typiquement utilis<69>e en combinaison avec une Bobine REMISE
A ZERO.
Cette instruction est plac<61>e le plus <20> droite dans une s<>quence.
> BOBINE, REMISE A ZERO Rnom Ynom
----(R)---- ----(R)----
Si le signal arrivant <20> cette instruction est vrai, alors le relais
interne ou la sortie est mise <20> z<>ro (0), si elle <20>tait d<>j<EFBFBD> <20> 0,
il n'y a aucun changement, cette instruction change l'<27>tat d'une
sortie uniquement si elle <20>tait <20> 1, cette instruction fonctionne en
combinaison avec l'instruction ci-dessus Bobine <20> ACCROCHAGE.
Cette instruction est plac<61>e le plus <20> droite dans une s<>quence.
> TEMPORISATION TRAVAIL Tdon
-[TON 1.000 s]-
Quand la signal arrivant <20> cette instruction passe de faux <20> vrai
(0 <20> 1), le signal de sortie attend 1.000 seconde avant de passer
<20> 1. Quand le signal de commande de cette instruction passe ZERO,
le signal de sortie passe imm<6D>diatement <20> z<>ro. La tempo est remise
<20> z<>ro <20> chaque fois que l'entr<74>e repasse <20> z<>ro. L'entr<74>e doit <20>tre
maintenue vraie <20> 1 pendant au moins 1000 millisecondes cons<6E>cutives
avant que la sortie ne devienne vraie. le d<>lai est configurable.
La variable `Tnom' compte depuis z<>ro en unit<69>s de temps de scan.
L'instruction Ton devient vraie en sortie quand la variable du
compteur est plus grande ou <20>gale au delai fix<69>. Il est possible
de manipuler la variable du compteur en dehors, par exemple par une
instruction MOVE.
> TEMPORISATION REPOS Tdoff
-[TOF 1.000 s]-
Quand le signal qui arrive <20> l'instruction passe de l'<27>tat vrai
(1) <20> l'<27>tat faux (0), la sortie attend 1.000 s avant de d<>venir
faux (0) Quand le signal arrivant <20> l'instruction passe de l'<27>tat
faux <20> l'<27>tat vrai, le signal passe <20> vrai imm<6D>diatement. La
temporisation est remise <20> z<>ro <20> chaque fois que l'entr<74>e devient
fausse. L'entr<74>e doit <20>tre maintenue <20> l'<27>tat faux pendant au moins
1000 ms cons<6E>cutives avant que la sortie ne passe <20> l'<27>tat faux. La
temporisation est configurable.
La variable `Tname' compte depuis z<>ro en unit<69>s de temps de scan.
L'instruction Ton devient vraie en sortie quand la variable du
compteur est plus grande ou <20>gale au delai fix<69>. Il est possible
de manipuler la variable du compteur en dehors, par exemple par une
instruction MOVE.
> TEMPORISATION TOTALISATRICE Trto
-[RTO 1.000 s]-
Cette instruction prend en compte le temps que l'entr<74>e a <20>t<EFBFBD> <20> l'<27>tat
vrai (1). Si l'entr<74>e a <20>t<EFBFBD> vraie pendant au moins 1.000s la sortie
devient vraie (1).L'entr<74>e n'a pas besoin d'<27>tre vraie pendant 1000 ms
cons<6E>cutives. Si l'entr<74>e est vraie pendant 0.6 seconde puis fausse
pendant 2.0 secondes et ensuite vraie pendant 0.4 seconde, la sortie
va devenir vraie. Apr<70>s <20>tre pass<73> <20> l'<27>tat vrai, la sortie reste
vraie quelque soit la commande de l'instruction. La temporisation
doit <20>tre remise <20> z<>ro par une instruction de RES (reset).
La variable `Tnom' compte depuis z<>ro en unit<69>s de temps de scan.
L'instruction Ton devient vraie en sortie quand la variable du
compteur est plus grande ou <20>gale au delai fix<69>. Il est possible
de manipuler la variable du compteur en dehors, par exemple par une
instruction MOVE.
> RES Remise <20> Z<>ro Trto Citems
----{RES}---- ----{RES}----
Cette instruction fait un remise <20> z<>ro d'une temporisation ou d'un
compteur. Les tempos TON et TOF sont automatiquement remisent <20> z<>ro
lorsque leurs entr<74>es deviennent respectivement fausses ou vraies,
RES n'est pas donc pas n<>cessaire pour ces tempos. Les tempos RTO
et les compteurs d<>compteurs CTU / CTD ne sont pas remis <20> z<>ro
automatiquement, il faut donc utiliser cette instruction. Lorsque
l'entr<74>e est vraie , le compteur ou la temporisation est remis <20>
z<>ro. Si l'entr<74>e reste <20> z<>ro, aucune action n'est prise.
Cette instruction est plac<61>e le plus <20> droite dans une s<>quence.
> FRONT MONTANT _
--[OSR_/ ]--
La sortie de cette instruction est normallement fausse. Si
l'instruction d'entr<74>e est vraie pendant ce scan et qu'elle <20>tait
fausse pendant le scan pr<70>c<EFBFBD>dent alors la sortie devient vraie. Elle
g<>n<EFBFBD>re une impulsion <20> chaque front montant du signal d'entr<74>e. Cette
instruction est utile si vous voulez intercepter le front montant
du signal.
> FRONT DESCENDANT _
--[OSF \_]--
La sortie de cette instruction est normallement fausse. Si
l'instruction d'entr<74>e est fausse (0) pendant ce scan et qu'elle
<20>tait vraie (1) pendant le scan pr<70>c<EFBFBD>dent alors la sortie devient
vraie. Elle g<>n<EFBFBD>re une impulsion <20> chaque front descendant du signal
d'entr<74>e. Cette instruction est utile si vous voulez intercepter le
front descendant d'un signal.
> COURT CIRCUIT (SHUNT), CIRCUIT OUVERT
----+----+---- ----+ +----
Une instruction shunt donne en sortie une condition qui est toujours
<20>gale <20> la condition d'entr<74>e. Une instruction Circuit Ouvert donne
toujours une valeur fausse en sortie.
Ces instructions sont en g<>n<EFBFBD>ral utilis<69>es en phase de test.
> RELAIS DE CONTROLE MAITRE
-{MASTER RLY}-
Par d<>faut, la condition d'entr<74>e d'une ligne est toujours vraie. Si
une instruction Relais de contr<74>le maitre est ex<65>cut<75>e avec une
valeur d'entr<74>e fausse, alors toutes les lignes suivantes deviendront
fausses. Ceci va continuer jusqu'<27> la rencontre de la prochaine
instruction relais de contr<74>le maitre qui annule l'instruction de
d<>part. Ces instructions doivent toujours <20>tre utilis<69>es par paires:
une pour commencer (qui peut <20>tre sous condition) qui commence la
partie d<>activ<69>e et une pour la terminer.
> MOUVOIR {destvar := } {Tret := }
-{ 123 MOV}- -{ srcvar MOV}-
Lorsque l'entr<74>e de cette instruction est vraie, elle va mettre la
variable de destination <20> une valeur <20>gale <20> la variable source ou <20>
la constante source. Quand l'entr<74>e de cette instruction est fausse
rien ne se passe. Vous pouvez affecter n'importe quelle variable
<20> une instruction de d<>placement, ceci inclu l'<27>tat de variables
compteurs ou temporisateurs qui se distinguent par l'ent<6E>te T ou
C. Par exemple mettre 0 dans Tsauvegard<72> <20>quivaut <20> faire une RES
de la temporisation. Cette instruction doit <20>tre compl<70>tement <20>
droite dans une s<>quence.
> OPERATIONS ARITHMETIQUES {ADD kay :=} {SUB Ccnt :=}
-{ 'a' + 10 }- -{ Ccnt - 10 }-
> {MUL dest :=} {DIV dv := }
-{ var * -990 }- -{ dv / -10000}-
Quand l'entr<74>e de cette instruction est vraie, elle place en
destination la variable <20>gale <20> l'expression calcul<75>e. Les op<6F>randes
peuvent <20>tre des variables (en incluant les variables compteurs et
tempos) ou des constantes. Ces instructions utilisent des valeurs 16
bits sign<67>es. Il faut se souvenir que le r<>sultat est <20>valu<6C> <20> chaque
cycle tant que la condition d'entr<74>e est vraie. Si vous incr<63>mentez
ou d<>cr<63>mentez une variable (si la variable de destination est
aussi une des op<6F>randes), le r<>sultat ne sera pas celui escompt<70>,
il faut utiliser typiquement un front montant ou descendant de la
condition d'entr<74>e qui ne sera <20>valu<6C> qu'une seule fois. La valeur
est tronqu<71>e <20> la valeur enti<74>re. Cette instruction doit <20>tre
compl<70>tement <20> droite dans une s<>quence.
> COMPARER [var ==] [var >] [1 >=]
-[ var2 ]- -[ 1 ]- -[ Ton]-
> [var /=] [-4 < ] [1 <=]
-[ var2 ]- -[ vartwo]- -[ Cup]-
Si l'entr<74>e de cette instruction est fausse alors la sortie est
fausse. Si l'entr<74>e est vraie, alors la sortie sera vraie si et
uniquement si la condition de sortie est vraie. Cette instruction
est utilis<69>e pour comparer (Egalit<69>, plus grand que,plus grand ou
<20>gal <20>, in<69>gal, plus petit que, plus petit ou <20>gal <20>) une variable <20>
une autre variable, ou pour comparer une variable avec une constante
16 bits sign<67>e.
> COMPTEUR DECOMPTEUR Cnom Cnom
--[CTU >=5]-- --[CTD >=5]--
Un compteur incr<63>mente ( Compteur CTU, count up) ou d<>cr<63>mente
(D<>compteur CTD, count down) une variable <20> chaque front montant de
la ligne en condition d'entr<74>e (CAD quand la signal passe de l'<27>tat
0 <20> l'<27>tat 1. La condition de sortie du compteur est vraie si la
variable du compteur est <20>gale ou plus grande que 5 (dans l'exemple),
et faux sinon. La condition de sortie de la ligne peut <20>tre vraie,
m<>me si la condition d'entr<74>e est fausse, cela d<>pend uniquement de la
valeur de la variable du compteur. Vous pouvez avoir un compteur ou
un d<>compteur avec le m<>me nom, qui vont incr<63>m<EFBFBD>nter ou decr<63>menter
une variable. L'instruction Remise <20> Z<>ro permet de resetter un
compteur (remettre <20> z<>ro), il est possible de modifier par des
op<6F>rations les variables des compteurs d<>compteurs.
> COMPTEUR CYCLIQUE Cnom
--{CTC 0:7}--
Un compteur cyclique fonctionne comme un compteur normal
CTU, exception faite, lorsque le compteur arrive <20> sa
limite sup<75>rieure, la variable du compteur revient <20> 0. dans
l'exemple la valeur du compteur <20>volue de la fa<66>on suivante :
0,1,2,4,5,6,7,0,1,2,3,4,5,6,7,0,1,3,4,5,etc. Ceci est tr<74>s pratique
en conbinaison avec des intructions conditionnelles sur la variable
Cnom. On peut utiliser ceci comme un s<>quenceur, l'horloge du compteur
CTC est valid<69>e par la condition d'entr<74>e associ<63>e <20> une instruction
de front montant.
Cette instruction doit <20>tre compl<70>tement <20> droite dans une s<>quence.
> REGISTRE A DECALAGE {SHIFT REG }
-{ reg0..3 }-
Un registre <20> d<>calage est associ<63> avec un jeu de variables. Le
registre <20> d<>calage de l'exemple donn<6E> est associ<63> avec les
variables`reg0', `reg1', `reg2', and `reg3'. L'entr<74>e du registre <20>
d<>calage est `reg0'. A chaque front montant de la condition d'entr<74>e
de la ligne, le registre <20> d<>calage va d<>caler d'une position <20>
droite. Ce qui donne `reg3 := reg2', `reg2 := reg1'. et `reg1 :=
reg0'.`reg0' est <20> gauche sans changement. Un registre <20> d<>calage
de plusieurs <20>l<EFBFBD>ments peut consommer beaucoup de place en m<>moire.
Cette instruction doit <20>tre compl<70>tement <20> droite dans une s<>quence.
> TABLEAU INDEXE {dest := }
-{ LUT[i] }-
Un tableau index<65> et un groupe ordonn<6E> de n valeurs Quand la condition
d'entr<74>e est vraie, la variable enti<74>re `dest' est mise <20> la valeur
correspondand <20> l'index i du tableau. L'index est compris entre 0 et
(n-1). Le comportement de cette instruction est ind<6E>fini si l'index
est en dehors du tableau
Cette instruction doit <20>tre compl<70>tement <20> droite dans une s<>quence.
> TABLEAU ELEMENTS LINEAIRES {yvar := }
-{ PWL[xvar] }-
C'est une bonne m<>thode pour <20>valuer de fa<66>on approximative une
fonction compliqu<71>e ou une courbe. Tr<54>s pratique par exemple pour
appliquer une courbe de calibration pour lin<69>ariser tension de sortie
d'un capteur dans une unit<69> convenable.
Supposez que vous essayez de faire une fonction pour convertir une
variable d'entr<74>e enti<74>re, x, en une variable de sortie enti<74>re, y,
vous connaissez la fonction en diff<66>rents points, par exemple vous
connaissez :
f(0) = 2
f(5) = 10
f(10) = 50
f(100) = 100
Ceci donne les points
(x0, y0) = ( 0, 2)
(x1, y1) = ( 5, 10)
(x2, y2) = ( 10, 50)
(x3, y3) = (100, 100)
li<6C>s <20> cette courbe. Vous pouvez entrer ces 4 points dans un
tableau associ<63> <20> l'instruction tableau d'<27>l<EFBFBD>ments lin<69>aires. Cette
instruction regarde la valeur de xvar et fixe la valeur de yvar
correspondante. Par exemple si vous mettez xvar = 10 , l'instruction
validera yvar = 50.
Si vous mettez une instruction avec une valeur xvar entre deux valeurs
de x du tableau (et par cons<6E>quence aussi de yvar). Une moyenne
proportionnelle entre les deux valeurs , pr<70>c<EFBFBD>dente et suivante de
xvar et de la valeur li<6C>e yvar, est effectu<74>e. Par exemple xvar =
55 donne en sortie yvar = 75 Les deux points xvar (10.50) et yvar
(50,75) , 55 est la moyenne entre 10 et 100 et 75 est la moyenne
entre 50 et 100, donc (55,75) sont li<6C>s ensemble par une ligne de
connection qui connecte ces deux points.
Ces points doivent <20>tre sp<73>cifi<66>s dans l'ordre ascendant des
coordonn<6E>es x. Il peut <20>tre impossible de faire certaines op<6F>rations
math<74>matiques n<>cessaires pour certains tableaux, utilisant des
entiers 16 bits. Dans ce LDmicro va provoquer une alarme. Ce tableau
va provoquer une erreur :
(x0, y0) = ( 0, 0)
(x1, y1) = (300, 300)
Vous pouvez supprimer ces erreurs en diminuant l'<27>cart entre les
points du tableau, par exemple ce tableau est <20>quivalent <20> celui ci
dessus , mais ne provoque pas d'erreur:
(x0, y0) = ( 0, 0)
(x1, y1) = (150, 150)
(x2, y2) = (300, 300)
Il n'est pratiquement jamais n<>cessaire d'utiliser plus de 5 ou
6 points. Ajouter des points augmente la taille du code et diminue
sa vitesse d'ex<65>cution. Le comportement, si vous passez une valeur
<20> xvar plus grande que la plus grande valeur du tableau , ou plus
petit que la plus petite valeur, est ind<6E>fini.
Cette instruction doit <20>tre compl<70>tement <20> droite dans une s<>quence.
> LECTURE CONVERTISSEUR A/D Anom
--{READ ADC}--
LDmicro peut g<>n<EFBFBD>rer du code pour utiliser les convertisseurs A/D
contenus dans certains microcontroleurs. Si la condition d'entr<74>e
de l'instruction est vraie, alors une acquisition du convertisseur
A/D est <20>ffectu<74>e et stock<63>e dans la variable Anom. Cette variable
peut <20>tre par la suite trait<69>e comme les autres variables par les
diff<66>rentes op<6F>rations arithm<68>tiques ou autres. Vous devez affecter
une broche du micro <20> la variable Anom de la m<>me fa<66>on que pour
les entr<74>es et sorties digitales par un double clic dans la list
affich<63>e au bas de l'<27>cran. Si la condition d'entr<74>e de la s<>quence
est fausse la variable Anom reste inchang<6E>e.
Pour tous les circuits support<72>s actuellement, 0 volt en entr<74>e
correspond <20> une lecture ADC de 0, et une valeur <20>gale <20> VDD (la
tension d'alimentation ) correspond <20> une lecture ADC de 1023. Si
vous utilisez un circuit AVR, vous devez connecter Aref <20> VDD.
Vous pouvez utiliser les op<6F>rations arithm<68>tiques pour mettre <20>
l'<27>chelle les lectures effectu<74>es dans l'unit<69> qui vous est la plus
appropri<72>e. Mais souvenez vous que tous les calculs sont faits en
utilisant les entiers.
En g<>n<EFBFBD>ral, toutes les broches ne sont pas utilisables pour les
lecture de convertisseur A/D. Le logiciel ne vous permet pas
d'affecter une broche non A/D pour une entr<74>e convertisseur.
Cette instruction doit <20>tre compl<70>tement <20> droite dans une s<>quence.
> FIXER RAPPORT CYCLE PWM duty_cycle
-{PWM 32.8 kHz}-
LDmicro peut g<>n<EFBFBD>rer du code pour utiliser les p<>riph<70>riques PWM
contenus dans certains microcontroleurs. Si la condition d'entr<74>e
de cette instruction est vraie, le rapport de cycle du p<>riph<70>rique
PWM va <20>tre fix<69> <20> la valeur de la variable Rapport de cycle PWM.
Le rapport de cycle est un nombre compris entre 0 (toujours au
niveau bas) et 100 (toujours au niveau haut). Si vous connaissez la
mani<6E>re dont les p<>riph<70>riques fonctionnent vous noterez que LDmicro
met automatiquement <20> l'<27>chelle la variable du rapport de cycle en
pourcentage de la p<>riode d'horloge PWM.
Vous pouvez sp<73>cifier la fr<66>quence de sortie PWM, en Hertz. Le
fr<66>quence que vous sp<73>cifiez peut ne pas <20>tre exactement accomplie, en
fonction des divisions de la fr<66>quence d'horloge du microcontroleur,
LDmicro va choisir une fr<66>quence approch<63>e. Si l'erreur est trop
importante, il vous avertit.Les vitesses rapides sont au d<>triment
de la r<>solution. Cette instruction doit <20>tre compl<70>tement <20> droite
dans une s<>quence.
Le runtime du language <20> contacts consomme un timers (du micro) pour
le temps de cycle, ce qui fait que le PWM est uniquement possible
avec des microcontroleurs ayant au moins deux timers utilisables.
PWM utilise CCP2 (pas CCP1) sur les PIC16F et OC2(pas OC1) sur les
Atmel AVR.
> METTRE PERSISTANT saved_var
--{PERSIST}--
Quand la condition d'entr<74>e de cette instruction est vraie, la
variable enti<74>re sp<73>cifi<66>e va <20>tre automatiquement sauvegard<72>e en
EEPROM, ce qui fait que cette valeur persiste m<>me apr<70>s une coupure
de l'alimentation du micro. Il n'y a pas <20> sp<73>cifier ou elle doit
<20>tre sauvegard<72>e en EEPROM, ceci est fait automatiquement, jusqu'a
ce quelle change <20> nouveau. La variable est automatiquement charg<72>e
<20> partir de l'EEPROM suite <20> un reset <20> la mise sous tension.
Si une variables, mise persistante, change fr<66>quemment, l'EEPROM de
votre micro peut <20>tre d<>truite tr<74>s rapidement, Le nombre de cycles
d'<27>criture dans l'EEPROM est limit<69> <20> environ 100 000 cycles Quand
la condition est fausse, rien n'apparait. Cette instruction doit
<20>tre compl<70>tement <20> droite dans une s<>quence.
> RECEPTION UART (SERIE) var
--{UART RECV}--
LDmicro peut g<>n<EFBFBD>rer du code pour utiliser l'UART, existant dans
certains microcontroleurs. Sur les AVR, avec de multiples UART,
uniquement l'UART1 est utilisable (pas l'UART0). Configurer la
vitesse en utilisant -> Param<61>tres -> Param<61>tres MCU. Toutes les
vitesses de liaison ne sont pas utilisables avec tous les quartz de
toutyes les fr<66>quences. Ldmicro vous avertit dans ce cas.
Si la condition d'entr<74>e de cette instruction est fausse, rien ne se
passe. Si la condition d'entr<74>e est vraie, elle essaie de recevoir
un caract<63>re en provenance de l'UART. Si aucun caract<63>re n'est lu
alors la condition de sortie devient fausse. Si un caract<63>re est
lu la valeur ASCII est stock<63>e dans 'var' et la condition de sortie
est vraie pour un seul cycle API.
> EMMISION UART (SERIE) var
--{UART SEND}--
LDmicro peut g<>n<EFBFBD>rer du code pour utiliser l'UART, existant dans
certains microcontroleurs. Sur les AVR, avec de multiples UART,
uniquement l'UART1 est utilisable (pas l'UART0). Configurer la
vitesse en utilisant -> Param<61>tres -> Param<61>tres MCU. Toutes les
vitesses de liaison ne sont pas utilisables avec tous les quartz
de toutyes les fr<66>quences. Ldmicro vous avertit dans ce cas.
Si la condition d'entr<74>e de cette instruction est fausse, rien ne
se passe. Si la condition d'entr<74>e est vraie alors cette instruction
<20>crit un seul caract<63>re vers l'UART. La valeur ASCII du caract<63>re <20>
transmettre doit avoir <20>t<EFBFBD> stock<63> dans 'var' par avance. La condition
de sortie de la s<>quence est vraie, si l'UART est occup<75>e (en cours
de transmission d'un caract<63>re), et fausse sinon.
Rappelez vous que les caract<63>res mettent un certain temps pour <20>tre
transmis. V<>rifiez la condition de sortie de cette instruction pour
vous assurer que le premier caract<63>re <20> bien <20>t<EFBFBD> transmis, avant
d'essayer d'envoyer un second caract<63>re, ou utiliser une temporisation
pour ins<6E>rer un d<>lai entre caract<63>res; Vous devez uniquement v<>rifier
que la condition d'entr<74>e est vraie (essayez de transmettre un
caract<63>re) quand la condition de sortie est fausse(UART non occupp<70>e).
Regardez l'instruction Chaine formatt<74>e(juste apr<70>s) avant d'utiliser
cette instruction, elle est plus simple <20> utiliser, et dans la
majorit<69> des cas, est capable de faire ce dont on a besoin.
> CHAINE FORMATTEE SUR UART var
-{"Pression: \3\r\n"}-
LDmicro peut g<>n<EFBFBD>rer du code pour utiliser l'UART, existant dans
certains microcontroleurs. Sur les AVR, avec de multiples UART,
uniquement l'UART1 est utilisable (pas l'UART0). Configurer la
vitesse en utilisant -> Param<61>tres -> Param<61>tres MCU. Toutes les
vitesses de liaison ne sont pas utilisables avec tous les quartz
de toutyes les fr<66>quences. Ldmicro vous avertit dans ce cas.
Quand la condition d'entr<74>e de cette instruction passe de faux <20> vrai,
elle commence <20> envoyer une chaine compl<70>te vers le port s<>rie. Si
la chaine comporte la s<>quence sp<73>ciale '3', alors cette s<>quence
va <20>tre remplac<61>e par la valeur de 'var', qui est automatiquement
converti en une chaine. La variable va <20>tre formatt<74>e pour prendre
exactement trois caract<63>res; par exemple si var = 35, la chaine
exacte qui va <20>tre "imprim<69>e" sera 'Pression: 35\r\n' (notez les
espaces suppl<70>mentaires). Si au lieu de cela var = 1432 , la sortie
est ind<6E>finie parceque 1432 comporte plus de 3 digits. Dans ce cas
vous devez n<>cessairement utiliser '\4' <20> la place.
Si la variable peut <20>tre n<>gative, alors utilisez '\-3d' (ou `\-4d'
etc.) <20> la place. Ceci oblige LDmicro <20> imprimer un espace d'ent<6E>te
pour les nombres positifs et un signe moins d'ent<6E>te pour les chiffres
n<>gatifs.
Si de multiples instructions de chaines formatt<74>es sont activ<69>es au
m<>me moment (ou si une est activ<69>e avant de finir la pr<70>c<EFBFBD>dente)
ou si ces instructions sont imbriqu<71>es avec des instructions TX
(transmission), le comportement est ind<6E>fini.
Il est aussi possible d'utiliser cette instruction pour sortie une
chaine fixe, sans l'intervention d'une variable en valeur enti<74>re
dans le texte qui est envoy<6F>e sur la ligne s<>rie. Dans ce cas,
simplement ne pas inclure de s<>quence sp<73>ciale Escape.
Utiliser `\\' pour l'anti-slash. en addition <20> une s<>quence escape
pour intervenir sue une variables enti<74>re, les caract<63>res de
contr<74>les suivants sont utilisables :
* \r -- retour en d<>but de ligne
* \n -- nouvelle ligne
* \f -- saut de page
* \b -- retour arri<72>re
* \xAB -- caract<63>re avec valeur ASCII 0xAB (hex)
La condition de sortie de cette instruction est vraie quand elle
transmet des donn<6E>es, sinon elle est fausse. Cette instruction
consomme une grande quantit<69> de m<>moire, elle doit <20>tre utilis<69>e
avec mod<6F>ration. L'impl<70>mentation pr<70>sente n'est pas efficace, mais
une meilleure impl<70>mentation demanderait une modification de tout
le reste.
NOTE CONCERNANT LES MATHS
=========================
Souvenez vous que LDmicro travaille uniquement en math<74>matiques entiers
16 bits. Ce qui fait que le r<>sultat final de m<>me que tous les calculs
m<EFBFBD>mes interm<72>diaires seront compris entre -32768 et 32767.
Par exemple, si vous voulez calculer y = (1/x)*1200,ou x est compris
entre 1 et 20, ce qui donne un r<>sultat entre 1200 et 60,le r<>sultat est
bien <20> l'int<6E>rieur d'un entier 16 bits, il doit donc <20>tre th<74>oriquement
possible de faire le calcul. Nous pouvons faire le calcul de deux fa<66>ons
d'abord faire 1/x et ensuite la multiplication:
|| {DIV temp :=} ||
||---------{ 1 / x }----------||
|| ||
|| {MUL y := } ||
||----------{ temp * 1200}----------||
|| ||
Ou uniquement faire simplement la division en une seule ligne :
|| {DIV y :=} ||
||-----------{ 1200 / x }-----------||
Math<EFBFBD>matiquement c'est identique, la premi<6D>re donne y = 0 , c'est <20> dire
une mauvais r<>sultat, si nous prenons par exemple x = 3 , 1/x = 0.333 mais
comme il s'agit d'un entier, la valeur pour Temp est de 0 et 0*1200 = 0
donc r<>sultat faux.Dans le deuxi<78>me cas, il n'y a pas de r<>sultat
interm<EFBFBD>diaire et le r<>sultat est correct dans tous les cas.
Si vous trouvez un probl<62>me avec vos calculs math<74>matiques, v<>rifiez les
r<EFBFBD>sultats interm<72>diaires, si il n'y a pas de d<>passement de capacit<69>s par
rapports aux valeurs enti<74>res. (par exemple 32767 + 1 = -32768). Quand
cela est possible essayer de choisir des valeurs entre -100 et 100.
Vous pouvez utiliser un certain facteur de multiplication ou division pour
mettre <20> l'echelle les variables lors de calculs par exemple : pour mettre
mettre <20> l'echelle y = 1.8*x , il est possible de faire y =(9/5)*x
(9/5 = 1.8) et coder ainsi y = (9*x)/5 en faisant d'abord la multiplication
|| {MUL temp :=} ||
||---------{ x * 9 }----------||
|| ||
|| {DIV y :=} ||
||-----------{ temp / 5 }-----------||
Ceci fonctionne tant que x < (32767 / 9), or x < 3640. Pour les grandes
valeurs de x,la variable `temp' va se mettre en d<>passement. Ceci est
similaire vers la limite basse de x.
STYLE DE CODIFICATION
=====================
Il est permis d'avoir plusieurs bobines en parall<6C>le, contr<74>l<EFBFBD>es par
une simple ligne comme ci-dessous :
|| Xa Ya ||
1 ||-------] [--------------( )-------||
|| ||
|| Xb Yb ||
||-------] [------+-------( )-------||
|| | ||
|| | Yc ||
|| +-------( )-------||
|| ||
<EFBFBD> la place de ceci :
|| Xa Ya ||
1 ||-------] [--------------( )-------||
|| ||
|| ||
|| ||
|| ||
|| Xb Yb ||
2 ||-------] [--------------( )-------||
|| ||
|| ||
|| ||
|| ||
|| Xb Yc ||
3 ||-------] [--------------( )-------||
|| ||
Il est permis th<74>oriquement d'<27>crire un programme avec une s<>quence tr<74>s
importante et de ne pas utiliser plusieurs lignes pour la faire. En
pratique c'est une mauvaise id<69>e, <20> cause de la compl<70>xit<69> que cela
peut engendrer et plus difficile <20> <20>diter sans effacer et redessiner un
certain nombre d'<27>l<EFBFBD>ments de logique.
N<EFBFBD>anmoins, c'est une bonne id<69>e de regrouper diff<66>rents <20>l<EFBFBD>ments d'un bloc
logique dans une seule s<>quence. Le code g<>n<EFBFBD>r<EFBFBD> est identique dans les
deux cas, et vous pouvez voir ce que fait la s<>quence dans le diagramme
<EFBFBD> contacts.
* * *
En g<>n<EFBFBD>ral, il est consid<69>r<EFBFBD> comme mauvais d'<27>crire du code dont la
sortie d<>pend de l'ordre d'ex<65>cution. Exemple : ce code n'est pas tr<74>s
bon lorsque xa et xb sont vrai en m<>me temps :
|| Xa {v := } ||
1 ||-------] [--------{ 12 MOV}--||
|| ||
|| Xb {v := } ||
||-------] [--------{ 23 MOV}--||
|| ||
|| ||
|| ||
|| ||
|| [v >] Yc ||
2 ||------[ 15]-------------( )-------||
|| ||
Ci-dessous un exemple pour convertir 4 bits Xb3:0 en un entier :
|| {v := } ||
3 ||-----------------------------------{ 0 MOV}--||
|| ||
|| Xb0 {ADD v :=} ||
||-------] [------------------{ v + 1 }-----------||
|| ||
|| Xb1 {ADD v :=} ||
||-------] [------------------{ v + 2 }-----------||
|| ||
|| Xb2 {ADD v :=} ||
||-------] [------------------{ v + 4 }-----------||
|| ||
|| Xb3 {ADD v :=} ||
||-------] [------------------{ v + 8 }-----------||
|| ||
Si l'instruction MOV est d<>plac<61>e en dessous des instructions ADD, la
valeur de la variable v, quand elle est lue autrepart dans le programme,
serait toujours 0. La sortie du code d<>pend alors de l'ordre d'<27>valuations
des instructions. Ce serait possible de modifier ce code pour <20>viter cela,
mais le code deviendrait tr<74>s encombrant.
DEFAUTS
=======
LDmicro ne g<>n<EFBFBD>re pas un code tr<74>s efficace; il est lent <20> ex<65>cuter et
il est gourmand en Flash et RAM. Un PIC milieu de gamme ou un AVR peut
tout de m<>me faire ce qu'un petit automate peut faire.
La longueur maximum des noms de variables est tr<74>s limit<69>e, ceci pour
<EFBFBD>tre int<6E>gr<67>e correctement dans le diagramme logique, je ne vois pas de
solution satisfaisante pour solutionner ce probl<62>me.
Si votre programme est trop important, vitesse ex<65>cution, m<>moire
programme ou contraintes de m<>moire de donn<6E>es pour le processeur que vous
avez choisi, il n'indiquera probablement pas d'erreur. Il se blocquera
simplement quelque part.
Si vous <20>tes programmeur n<>gligent dans les sauvegardes et les
chargements, il est possible qu'un crash se produise ou ex<65>cute un code
arbitraire corrompu ou un mauvais fichier .ld .
SVP, faire un rapport sur les bogues et les demandes de modifications.
Thanks to:
* Marcelo Solano, for reporting a UI bug under Win98
* Serge V. Polubarjev, for not only noticing that RA3:0 on the
PIC16F628 didn't work but also telling me how to fix it
* Maxim Ibragimov, for reporting and diagnosing major problems
with the till-then-untested ATmega16 and ATmega162 targets
* Bill Kishonti, for reporting that the simulator crashed when the
ladder logic program divided by zero
* Mohamed Tayae, for reporting that persistent variables were broken
on the PIC16F628
* David Rothwell, for reporting several user interface bugs and a
problem with the "Export as Text" function
Particular thanks to Marcel Vaufleury, for this translation (of both
the manual and the program's user interface) into French.
COPYING, AND DISCLAIMER
=======================
DO NOT USE CODE GENERATED BY LDMICRO IN APPLICATIONS WHERE SOFTWARE
FAILURE COULD RESULT IN DANGER TO HUMAN LIFE OR DAMAGE TO PROPERTY. THE
AUTHOR ASSUMES NO LIABILITY FOR ANY DAMAGES RESULTING FROM THE OPERATION
OF LDMICRO OR CODE GENERATED BY LDMICRO.
This program is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation, either version 3 of the License, or (at your
option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License along
with this program. If not, see <http://www.gnu.org/licenses/>.
Jonathan Westhues
Rijswijk -- Dec 2004
Waterloo ON -- Jun, Jul 2005
Cambridge MA -- Sep, Dec 2005
Feb, Mar 2006
Email: user jwesthues, at host cq.cx