diff options
Diffstat (limited to 'ldmicro/manual-fr.txt')
| -rw-r--r-- | ldmicro/manual-fr.txt | 1017 |
1 files changed, 1017 insertions, 0 deletions
diff --git a/ldmicro/manual-fr.txt b/ldmicro/manual-fr.txt new file mode 100644 index 0000000..57dc52e --- /dev/null +++ b/ldmicro/manual-fr.txt @@ -0,0 +1,1017 @@ +INTRODUCTION
+============
+
+LDmicro génére du code natif pour certains microcontroleurs Microchip
+PIC16F et Atmel AVR. Usuellement les programmes de developpement pour ces
+microcontrolleurs sont é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és à l'architecture
+des processeurs, qui de façon interne exécutent une liste d'instructions.
+
+Les API (Automates Programmables Industriels, PLC en anglais, SPS en
+allemand) utilisent une autre voie et sont programmés en Langage à
+Contacts (ou LADDER). Un programme simple est représenté 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ésentent des Entrées, qui peuvent être des contacts de relais. Les
+commandes --( )-- sont des Sorties, qui peuvent représenter des bobines de
+relais. Beaucoup de références de programmes de langage à contacts (LADDER)
+existent sur Internet et sont à quelques détails près, identiques à
+l'implémentation représentée ci-dessus.
+
+Un certain nombre de différences apparaissent entre les programmes en
+langage évolués ( C, Basic, Etc..) et les programmes pour API:
+
+ * Le programme est représenté dans un format graphique, et non
+ comme une liste de commandes en format texte. Beaucoup de personnes
+ trouve cela plus facile à comprendre.
+
+ * Au niveau de base, le programme apparait comme un diagramme
+ de circuit avec des contacts de relais (Entrées) et des bobines
+ (Sorties). Ceci est intuitif pour les programmeurs qui connaissent
+ la théorie des circuits électriques.
+
+ * Le compilateur de langage à contacts vérifie tout ceci lors
+ de la compilation. Vous n'avez pas à écrire de code quand une
+ Sortie est remplacée et est remise en Entrée ou si une temporisation
+ est modifiée, vous n'avez pas non plus à spécifier l'ordre où les
+ calculs doivent être effectués. L'outil API (PLC) s'occupe de cela
+ pour vous.
+
+
+LDmicro compile le langage à contact (ladder) en code pour PIC16F ou
+AVR. Les processeurs suivants sont supportés:
+
+ * PIC16F877
+ * PIC16F628
+ * PIC16F876 (non testé)
+ * PIC16F88 (non testé)
+ * PIC16F819 (non testé)
+ * PIC16F887 (non testé)
+ * PIC16F886 (non testé)
+ * ATmega128
+ * ATmega64
+ * ATmega162 (non testé)
+ * ATmega32 (non testé)
+ * ATmega16 (non testé)
+ * ATmega8 (non testé)
+
+Il doit ê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 à contacts pour votre
+programme. Vous pouvez simuler le fonctionnement logique en temps réel sur
+votre PC. Quand vous êtes convaincu que le fonctionnement est correct,
+vous pouvez affecter les broches du microcontroleur pour les Entré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çu pour être similaire à la majorité des API commerciaux.
+Il y a quelques exceptions, et une partie des possibilités n'est
+pas standard avec le matériel industriel. Lire attentivement la
+description de chaque instruction même si elle parait familière. Ce
+document considère que vous avez une connaisance de base du langage à
+contact et de la structure des logiciels pour automates programmables.
+Cycle d'exécution : Lecture des Entrées -> Calculs -> Ecriture des Sorties
+
+
+CIBLES ADDITIONNELLES
+=====================
+
+Il est aussi possible de géné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é. LDmicro gérére uniquement
+le source pour le cycle de l'API. Vous êtes responsable de l'appel de
+chaque séquence du cycle et de l'implémentation de toutes les Entrées
+/ Sorties (Lecture/Ecriture des Entrées digitales, etc ...). Voir les
+commentaires dans le code source pour plus de détails.
+
+Finalement, LDmicro peut générer un code byte indépendant du processeur
+pour une machine virtuelle prévue pour faire fonctionner ce type de code.
+J'ai prévu un exemple simple d'implémentation d'un interpréteur /VM
+écrit en code C le plus portable possible. La cible fonctionne juste sur
+quelques plateformes ou vous pouvez prévoir votre VM. Ceci peut être utile
+pour des applications ou vous pouvez utiliser le languages à 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'é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é 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é d'associer LDmicro avec les fichiers d'extention .ld.
+Ceci permet à 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és sous la forme:
+`ldmicro.exe /c src.ld dest.hex', LDmicro compilera le programme`src.ld',
+et sauvegardera le fichier compilé sous`dest.hex'. Après compilation
+LDmicro se termine, que la compilation soit correcte ou pas. Aucun
+message n'est affiché sur la console. Ce mode est pratique uniquement
+lorsque vous exécutez LDmicro en ligne de commande.
+
+
+BASES
+=====
+
+Si vous exé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 à 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 édités par
+d'autres outils.
+
+Si vous ne chargez pas un programme existant, LDmicro démarre en insérant
+une ligne vide. Vous pouvez ajouter les instructions pour votre programme:
+par exemple ajouter un jeu de contacts (Instruction -> Insérer Contact)
+qui sera nommé `Xnew'. `X' désigne un contact qui peut être lié à une
+broche d'entrée du microcontroleur, vous pouvez affecter la broche pour
+ce contact plus tard après avoir choisi le microcontroleur et renommé
+les contacts. La première lettre indique de quel type de composants il
+s'agit par exemple :
+
+ * Xnom -- Relié à une broche d'entrée du microcontroleur
+ * Ynom -- Relié à 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érique (Entier : Integer)
+
+Choisir le reste du nom pour décrire l'utilisation de ce que fait cet
+objet et qui doit être unique dans tout le programme. Un même nom doit
+toujours se référer au même objet dans le programme en entier.Par
+exemple , vous aurez une erreur si vous utilisez une tempo travail
+(TON) appellée TDelai et une tempo repos (TOF) appellée aussi TDelai
+dans le même programme, le comptage effectué par ces tempo utilisera le
+même emplacement en mémoire, mais il est acceptable d'avoir une tempo
+sauvegardé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 être des lettres, chiffres ou le
+caractère _. Un nom de variable ne doit pas commencer par un chiffre.
+Les noms de variables sont sensibles à 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ès aux accumulateurs des temporisations ou des
+compteurs. Cela peut quelquefois être très utile, par exemple si vous
+voulez contrôler la valeur d'un compteur ou d'une temporisation dans
+une ligne particulière.
+
+Les variables sont toujours des entiers 16 bits. Leur valeur peut
+donc être comprise entre -32768 et 32767 inclus. Les variables sont
+toujours signées. Vous pouvez les spécifier de façon littérale comme
+des nombres décimaux normaux (0, 1234, -56), vous pouvez aussi les
+spécifier en caractères ASCII ('A', 'z') en mettant le caractère entre
+des guillemets simples. Vous pouvez utiliser un caractère ASCII dans la
+majorité des endroits où vous pouvez utiliser les nombres décimaux.
+
+En bas de l'écran, vous pouvez voir la liste de tous les objets
+utilisés dans votre programme. La liste est automatiquement générée
+à partir du programme. La majorité des objets ne necessitent aucune
+configuration. Seuls : les objets `Xnom', `Ynom', and `Anom' doivent être
+affectés à une broche du micro La première chose à faire est de choisir
+la microcontroleur utilisé : Paramères -> Microcontroleur ensuite vous
+affectez les broches en faisant un double clic dans la liste.
+
+Vous pouvez modifier le programme en insérant ou supprimant des
+instructions. Le curseur clignote dans la programme pour indiquer
+l'instruction courante sélectionnée et le point d'insertion. S'il ne
+clignote pas pressez <Tab> ou cliquer sur une instruction, ou vous
+pouvez insérer une nouvelle instruction à la droite ou à la gauche
+(en série avec), ou au dessous ou au dessus (en parallèle avec) de
+l'instruction sélectionnée. Quelques opérations ne sont pas permises ,
+par exemple aucune instruction permise à 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ès
+dans le menu. Vous pouvez faire un circuit complexe en plaçant plusieurs
+branches en parallèle ou en série avec une ligne, mais il est plus clair
+de faire plusieurs lignes.
+
+Une fois votre programme é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é différemment en mode
+simulation. Les instructions activées sont affichées en rouge vif, les
+instructions qui ne le sont pas sont affichées en grisé. 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 à
+jour en temps réel en fonction des changements d'état des entrées.
+
+Vous pouvez valider l'état des entrées du programme en faisant un
+double clic sur l'entrée dans la liste au bas de l'écran, ou sur le
+contact `Xnom' de l'instruction dans le programme, pour avoir le reflet
+automatiquement de la validation d'une entré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érer un fichier .HEX qui sera programmé dans le
+microcontroleur que vous avez choisi par Paramètres -> Microcontroleur
+Vous devez affecter les broches d'entré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'écran. Une boite de dialogue vous
+demande de choisir une des broches non affectées dans la liste.
+
+Vous devez aussi choisir la temps de cycle que voulez utiliser pour
+votre application, vous devez aussi choisir la fréquence d'horloge du
+processeur. Faire Paramètres -> Paramètres MCU dans le menu. En général,
+le temps de cycle peut être laissé à la valeur par défaut (10 ms) qui est
+une bonne valeur pour la majorité des applications. Indiquer la fréquence
+du quartz utilisé (ou du résonateur céramique ou autres..) et cliquer OK.
+
+Maintenant vous pouvez créer le fichier pour intégrer dans le
+microcontroleur. Choisir Compilation -> Compiler, ou compiler sous...
+Si vous avez précédemment compilé votre programme, vous pouvez spécifier
+un nom différent de fichier de sortie. Si votre programme ne comporte
+pas d'erreur (lié à la structure du programme), LDmicro génére un fichier
+IHEX prêt à être programmé dans le chip.
+
+Utilisez votre logiciel et maté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é 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 à 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ée ou de Sortie
+ ou de Relais interne est vraie, sinon l'instruction sera fausse.
+ Cette instruction peut vérifier l'état d'une broche d'entrée, d'une
+ broche de sortie ou d'un relais interne
+
+
+> CONTACT, NORMALLEMENT FERME Xnom Rnom Ynom
+ ----]/[---- ----]/[---- ----]/[----
+
+ Si le signal arrivant à 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'état d'une broche d'entré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 à cette instruction est faux, alors le relais
+ interne ou la broche de sortie est faux (mise à zéro). Si le signal
+ arrivant à cette instruction est vrai(1), alors le relais interne ou
+ la broche de sortie est validée (mise à 1). Il n'est pas important
+ d'affecter une variable à une bobine.
+ Cette instruction est placée le plus à droite dans une séquence.
+
+
+> BOBINE, INVERSE Rnom Ynom
+ ----(/)---- ----(/)----
+
+ Si le signal arrivant à cette instruction est vrai, alors le relais
+ interne ou la broche de sortie est faux (mise à zéro). Si le signal
+ arrivant à cette instruction est faux(0), alors le relais interne ou
+ la broche de sortie est validée (mise à 1). Il n'est pas important
+ d'affecter une variable à une bobine.
+ Cette instruction est placée le plus à droite dans une séquence.
+
+
+> BOBINE, ACCROCHAGE Rnom Ynom
+ ----(S)---- ----(S)----
+
+ Si le signal arrivant à cette instruction est vrai, alors le
+ relais interne ou la broche de sortie est validée (mise à 1). Cette
+ instruction permet de changer l'état d'un relais ou d'une sortie :
+ uniquement passe à vrai, ou reste vrai si elle était déjà à 1,
+ elle est typiquement utilisée en combinaison avec une Bobine REMISE
+ A ZERO.
+ Cette instruction est placée le plus à droite dans une séquence.
+
+
+> BOBINE, REMISE A ZERO Rnom Ynom
+ ----(R)---- ----(R)----
+
+ Si le signal arrivant à cette instruction est vrai, alors le relais
+ interne ou la sortie est mise à zéro (0), si elle était déjà à 0,
+ il n'y a aucun changement, cette instruction change l'état d'une
+ sortie uniquement si elle était à 1, cette instruction fonctionne en
+ combinaison avec l'instruction ci-dessus Bobine à ACCROCHAGE.
+ Cette instruction est placée le plus à droite dans une séquence.
+
+
+> TEMPORISATION TRAVAIL Tdon
+ -[TON 1.000 s]-
+
+ Quand la signal arrivant à cette instruction passe de faux à vrai
+ (0 à 1), le signal de sortie attend 1.000 seconde avant de passer
+ à 1. Quand le signal de commande de cette instruction passe ZERO,
+ le signal de sortie passe immédiatement à zéro. La tempo est remise
+ à zéro à chaque fois que l'entrée repasse à zéro. L'entrée doit être
+ maintenue vraie à 1 pendant au moins 1000 millisecondes consécutives
+ avant que la sortie ne devienne vraie. le délai est configurable.
+
+ La variable `Tnom' compte depuis zéro en unités de temps de scan.
+ L'instruction Ton devient vraie en sortie quand la variable du
+ compteur est plus grande ou égale au delai fixé. 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 à l'instruction passe de l'état vrai
+ (1) à l'état faux (0), la sortie attend 1.000 s avant de dévenir
+ faux (0) Quand le signal arrivant à l'instruction passe de l'état
+ faux à l'état vrai, le signal passe à vrai immédiatement. La
+ temporisation est remise à zéro à chaque fois que l'entrée devient
+ fausse. L'entrée doit être maintenue à l'état faux pendant au moins
+ 1000 ms consécutives avant que la sortie ne passe à l'état faux. La
+ temporisation est configurable.
+
+ La variable `Tname' compte depuis zéro en unités de temps de scan.
+ L'instruction Ton devient vraie en sortie quand la variable du
+ compteur est plus grande ou égale au delai fixé. 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ée a été à l'état
+ vrai (1). Si l'entrée a été vraie pendant au moins 1.000s la sortie
+ devient vraie (1).L'entrée n'a pas besoin d'être vraie pendant 1000 ms
+ consécutives. Si l'entré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ès être passé à l'état vrai, la sortie reste
+ vraie quelque soit la commande de l'instruction. La temporisation
+ doit être remise à zéro par une instruction de RES (reset).
+
+ La variable `Tnom' compte depuis zéro en unités de temps de scan.
+ L'instruction Ton devient vraie en sortie quand la variable du
+ compteur est plus grande ou égale au delai fixé. Il est possible
+ de manipuler la variable du compteur en dehors, par exemple par une
+ instruction MOVE.
+
+
+> RES Remise à Zéro Trto Citems
+ ----{RES}---- ----{RES}----
+
+ Cette instruction fait un remise à zéro d'une temporisation ou d'un
+ compteur. Les tempos TON et TOF sont automatiquement remisent à zéro
+ lorsque leurs entré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 à zéro
+ automatiquement, il faut donc utiliser cette instruction. Lorsque
+ l'entrée est vraie , le compteur ou la temporisation est remis à
+ zéro. Si l'entrée reste à zéro, aucune action n'est prise.
+ Cette instruction est placée le plus à droite dans une séquence.
+
+
+> FRONT MONTANT _
+ --[OSR_/ ]--
+
+ La sortie de cette instruction est normallement fausse. Si
+ l'instruction d'entrée est vraie pendant ce scan et qu'elle était
+ fausse pendant le scan précédent alors la sortie devient vraie. Elle
+ génére une impulsion à chaque front montant du signal d'entré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ée est fausse (0) pendant ce scan et qu'elle
+ était vraie (1) pendant le scan précédent alors la sortie devient
+ vraie. Elle génére une impulsion à chaque front descendant du signal
+ d'entré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
+ égale à la condition d'entrée. Une instruction Circuit Ouvert donne
+ toujours une valeur fausse en sortie.
+ Ces instructions sont en général utilisées en phase de test.
+
+
+> RELAIS DE CONTROLE MAITRE
+ -{MASTER RLY}-
+
+ Par défaut, la condition d'entrée d'une ligne est toujours vraie. Si
+ une instruction Relais de contrôle maitre est exécutée avec une
+ valeur d'entrée fausse, alors toutes les lignes suivantes deviendront
+ fausses. Ceci va continuer jusqu'à la rencontre de la prochaine
+ instruction relais de contrôle maitre qui annule l'instruction de
+ départ. Ces instructions doivent toujours être utilisées par paires:
+ une pour commencer (qui peut être sous condition) qui commence la
+ partie déactivée et une pour la terminer.
+
+
+> MOUVOIR {destvar := } {Tret := }
+ -{ 123 MOV}- -{ srcvar MOV}-
+
+ Lorsque l'entrée de cette instruction est vraie, elle va mettre la
+ variable de destination à une valeur égale à la variable source ou à
+ la constante source. Quand l'entrée de cette instruction est fausse
+ rien ne se passe. Vous pouvez affecter n'importe quelle variable
+ à une instruction de déplacement, ceci inclu l'état de variables
+ compteurs ou temporisateurs qui se distinguent par l'entête T ou
+ C. Par exemple mettre 0 dans Tsauvegardé équivaut à faire une RES
+ de la temporisation. Cette instruction doit être complétement à
+ 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ée de cette instruction est vraie, elle place en
+ destination la variable égale à l'expression calculée. Les opérandes
+ peuvent être des variables (en incluant les variables compteurs et
+ tempos) ou des constantes. Ces instructions utilisent des valeurs 16
+ bits signées. Il faut se souvenir que le résultat est évalué à chaque
+ cycle tant que la condition d'entrée est vraie. Si vous incrémentez
+ ou décrémentez une variable (si la variable de destination est
+ aussi une des opérandes), le résultat ne sera pas celui escompté,
+ il faut utiliser typiquement un front montant ou descendant de la
+ condition d'entrée qui ne sera évalué qu'une seule fois. La valeur
+ est tronquée à la valeur entière. Cette instruction doit être
+ complétement à droite dans une séquence.
+
+
+> COMPARER [var ==] [var >] [1 >=]
+ -[ var2 ]- -[ 1 ]- -[ Ton]-
+
+> [var /=] [-4 < ] [1 <=]
+ -[ var2 ]- -[ vartwo]- -[ Cup]-
+
+ Si l'entrée de cette instruction est fausse alors la sortie est
+ fausse. Si l'entrée est vraie, alors la sortie sera vraie si et
+ uniquement si la condition de sortie est vraie. Cette instruction
+ est utilisée pour comparer (Egalité, plus grand que,plus grand ou
+ égal à, inégal, plus petit que, plus petit ou égal à) une variable à
+ une autre variable, ou pour comparer une variable avec une constante
+ 16 bits signée.
+
+
+> COMPTEUR DECOMPTEUR Cnom Cnom
+ --[CTU >=5]-- --[CTD >=5]--
+
+ Un compteur incrémente ( Compteur CTU, count up) ou décrémente
+ (Décompteur CTD, count down) une variable à chaque front montant de
+ la ligne en condition d'entrée (CAD quand la signal passe de l'état
+ 0 à l'état 1. La condition de sortie du compteur est vraie si la
+ variable du compteur est égale ou plus grande que 5 (dans l'exemple),
+ et faux sinon. La condition de sortie de la ligne peut être vraie,
+ même si la condition d'entré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éménter ou decrémenter
+ une variable. L'instruction Remise à Zéro permet de resetter un
+ compteur (remettre à zéro), il est possible de modifier par des
+ opé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 à sa
+ limite supérieure, la variable du compteur revient à 0. dans
+ l'exemple la valeur du compteur évolue de la faç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è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ée par la condition d'entrée associée à une instruction
+ de front montant.
+ Cette instruction doit être complétement à droite dans une séquence.
+
+
+> REGISTRE A DECALAGE {SHIFT REG }
+ -{ reg0..3 }-
+
+ Un registre à décalage est associé avec un jeu de variables. Le
+ registre à décalage de l'exemple donné est associé avec les
+ variables`reg0', `reg1', `reg2', and `reg3'. L'entrée du registre à
+ décalage est `reg0'. A chaque front montant de la condition d'entrée
+ de la ligne, le registre à décalage va décaler d'une position à
+ droite. Ce qui donne `reg3 := reg2', `reg2 := reg1'. et `reg1 :=
+ reg0'.`reg0' est à gauche sans changement. Un registre à décalage
+ de plusieurs éléments peut consommer beaucoup de place en mémoire.
+ Cette instruction doit être complétement à droite dans une séquence.
+
+
+> TABLEAU INDEXE {dest := }
+ -{ LUT[i] }-
+
+ Un tableau indexé et un groupe ordonné de n valeurs Quand la condition
+ d'entrée est vraie, la variable entière `dest' est mise à la valeur
+ correspondand à l'index i du tableau. L'index est compris entre 0 et
+ (n-1). Le comportement de cette instruction est indéfini si l'index
+ est en dehors du tableau
+ Cette instruction doit être complétement à droite dans une séquence.
+
+
+> TABLEAU ELEMENTS LINEAIRES {yvar := }
+ -{ PWL[xvar] }-
+
+ C'est une bonne méthode pour évaluer de façon approximative une
+ fonction compliquée ou une courbe. Très pratique par exemple pour
+ appliquer une courbe de calibration pour linéariser tension de sortie
+ d'un capteur dans une unité convenable.
+
+ Supposez que vous essayez de faire une fonction pour convertir une
+ variable d'entrée entière, x, en une variable de sortie entière, y,
+ vous connaissez la fonction en diffé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és à cette courbe. Vous pouvez entrer ces 4 points dans un
+ tableau associé à l'instruction tableau d'éléments liné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équence aussi de yvar). Une moyenne
+ proportionnelle entre les deux valeurs , précédente et suivante de
+ xvar et de la valeur liée yvar, est effectué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és ensemble par une ligne de
+ connection qui connecte ces deux points.
+
+ Ces points doivent être spécifiés dans l'ordre ascendant des
+ coordonnées x. Il peut être impossible de faire certaines opérations
+ mathé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'écart entre les
+ points du tableau, par exemple ce tableau est équivalent à 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écution. Le comportement, si vous passez une valeur
+ à xvar plus grande que la plus grande valeur du tableau , ou plus
+ petit que la plus petite valeur, est indéfini.
+ Cette instruction doit être complétement à droite dans une séquence.
+
+
+> LECTURE CONVERTISSEUR A/D Anom
+ --{READ ADC}--
+
+ LDmicro peut générer du code pour utiliser les convertisseurs A/D
+ contenus dans certains microcontroleurs. Si la condition d'entrée
+ de l'instruction est vraie, alors une acquisition du convertisseur
+ A/D est éffectuée et stockée dans la variable Anom. Cette variable
+ peut être par la suite traitée comme les autres variables par les
+ différentes opérations arithmétiques ou autres. Vous devez affecter
+ une broche du micro à la variable Anom de la même façon que pour
+ les entrées et sorties digitales par un double clic dans la list
+ affichée au bas de l'écran. Si la condition d'entrée de la séquence
+ est fausse la variable Anom reste inchangée.
+
+ Pour tous les circuits supportés actuellement, 0 volt en entrée
+ correspond à une lecture ADC de 0, et une valeur égale à VDD (la
+ tension d'alimentation ) correspond à une lecture ADC de 1023. Si
+ vous utilisez un circuit AVR, vous devez connecter Aref à VDD.
+
+ Vous pouvez utiliser les opérations arithmétiques pour mettre à
+ l'échelle les lectures effectuées dans l'unité qui vous est la plus
+ appropriée. Mais souvenez vous que tous les calculs sont faits en
+ utilisant les entiers.
+
+ En géné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ée convertisseur.
+ Cette instruction doit être complétement à droite dans une séquence.
+
+
+> FIXER RAPPORT CYCLE PWM duty_cycle
+ -{PWM 32.8 kHz}-
+
+ LDmicro peut générer du code pour utiliser les périphériques PWM
+ contenus dans certains microcontroleurs. Si la condition d'entrée
+ de cette instruction est vraie, le rapport de cycle du périphérique
+ PWM va être fixé à 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ère dont les périphériques fonctionnent vous noterez que LDmicro
+ met automatiquement à l'échelle la variable du rapport de cycle en
+ pourcentage de la période d'horloge PWM.
+
+ Vous pouvez spécifier la fréquence de sortie PWM, en Hertz. Le
+ fréquence que vous spécifiez peut ne pas être exactement accomplie, en
+ fonction des divisions de la fréquence d'horloge du microcontroleur,
+ LDmicro va choisir une fréquence approchée. Si l'erreur est trop
+ importante, il vous avertit.Les vitesses rapides sont au détriment
+ de la résolution. Cette instruction doit être complétement à droite
+ dans une séquence.
+
+ Le runtime du language à 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ée de cette instruction est vraie, la
+ variable entière spécifiée va être automatiquement sauvegardée en
+ EEPROM, ce qui fait que cette valeur persiste même après une coupure
+ de l'alimentation du micro. Il n'y a pas à spécifier ou elle doit
+ être sauvegardée en EEPROM, ceci est fait automatiquement, jusqu'a
+ ce quelle change à nouveau. La variable est automatiquement chargée
+ à partir de l'EEPROM suite à un reset à la mise sous tension.
+
+ Si une variables, mise persistante, change fréquemment, l'EEPROM de
+ votre micro peut être détruite très rapidement, Le nombre de cycles
+ d'écriture dans l'EEPROM est limité à environ 100 000 cycles Quand
+ la condition est fausse, rien n'apparait. Cette instruction doit
+ être complétement à droite dans une séquence.
+
+
+> RECEPTION UART (SERIE) var
+ --{UART RECV}--
+
+ LDmicro peut géné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ètres -> Paramètres MCU. Toutes les
+ vitesses de liaison ne sont pas utilisables avec tous les quartz de
+ toutyes les fréquences. Ldmicro vous avertit dans ce cas.
+
+ Si la condition d'entrée de cette instruction est fausse, rien ne se
+ passe. Si la condition d'entrée est vraie, elle essaie de recevoir
+ un caractère en provenance de l'UART. Si aucun caractère n'est lu
+ alors la condition de sortie devient fausse. Si un caractère est
+ lu la valeur ASCII est stocké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é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ètres -> Paramètres MCU. Toutes les
+ vitesses de liaison ne sont pas utilisables avec tous les quartz
+ de toutyes les fréquences. Ldmicro vous avertit dans ce cas.
+
+ Si la condition d'entrée de cette instruction est fausse, rien ne
+ se passe. Si la condition d'entrée est vraie alors cette instruction
+ écrit un seul caractère vers l'UART. La valeur ASCII du caractère à
+ transmettre doit avoir été stocké dans 'var' par avance. La condition
+ de sortie de la séquence est vraie, si l'UART est occupée (en cours
+ de transmission d'un caractère), et fausse sinon.
+
+ Rappelez vous que les caractères mettent un certain temps pour être
+ transmis. Vérifiez la condition de sortie de cette instruction pour
+ vous assurer que le premier caractère à bien été transmis, avant
+ d'essayer d'envoyer un second caractère, ou utiliser une temporisation
+ pour insérer un délai entre caractères; Vous devez uniquement vérifier
+ que la condition d'entrée est vraie (essayez de transmettre un
+ caractère) quand la condition de sortie est fausse(UART non occuppée).
+
+ Regardez l'instruction Chaine formattée(juste après) avant d'utiliser
+ cette instruction, elle est plus simple à utiliser, et dans la
+ majorité des cas, est capable de faire ce dont on a besoin.
+
+
+> CHAINE FORMATTEE SUR UART var
+ -{"Pression: \3\r\n"}-
+
+ LDmicro peut géné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ètres -> Paramètres MCU. Toutes les
+ vitesses de liaison ne sont pas utilisables avec tous les quartz
+ de toutyes les fréquences. Ldmicro vous avertit dans ce cas.
+
+ Quand la condition d'entrée de cette instruction passe de faux à vrai,
+ elle commence à envoyer une chaine compléte vers le port série. Si
+ la chaine comporte la séquence spéciale '3', alors cette séquence
+ va être remplacée par la valeur de 'var', qui est automatiquement
+ converti en une chaine. La variable va être formattée pour prendre
+ exactement trois caractères; par exemple si var = 35, la chaine
+ exacte qui va être "imprimée" sera 'Pression: 35\r\n' (notez les
+ espaces supplémentaires). Si au lieu de cela var = 1432 , la sortie
+ est indéfinie parceque 1432 comporte plus de 3 digits. Dans ce cas
+ vous devez nécessairement utiliser '\4' à la place.
+
+ Si la variable peut être négative, alors utilisez '\-3d' (ou `\-4d'
+ etc.) à la place. Ceci oblige LDmicro à imprimer un espace d'entête
+ pour les nombres positifs et un signe moins d'entête pour les chiffres
+ négatifs.
+
+ Si de multiples instructions de chaines formattées sont activées au
+ même moment (ou si une est activée avant de finir la précédente)
+ ou si ces instructions sont imbriquées avec des instructions TX
+ (transmission), le comportement est indéfini.
+
+ Il est aussi possible d'utiliser cette instruction pour sortie une
+ chaine fixe, sans l'intervention d'une variable en valeur entière
+ dans le texte qui est envoyée sur la ligne série. Dans ce cas,
+ simplement ne pas inclure de séquence spéciale Escape.
+
+ Utiliser `\\' pour l'anti-slash. en addition à une séquence escape
+ pour intervenir sue une variables entière, les caractères de
+ contrôles suivants sont utilisables :
+
+ * \r -- retour en début de ligne
+ * \n -- nouvelle ligne
+ * \f -- saut de page
+ * \b -- retour arrière
+ * \xAB -- caractère avec valeur ASCII 0xAB (hex)
+
+ La condition de sortie de cette instruction est vraie quand elle
+ transmet des données, sinon elle est fausse. Cette instruction
+ consomme une grande quantité de mémoire, elle doit être utilisée
+ avec modération. L'implémentation présente n'est pas efficace, mais
+ une meilleure implémentation demanderait une modification de tout
+ le reste.
+
+NOTE CONCERNANT LES MATHS
+=========================
+
+Souvenez vous que LDmicro travaille uniquement en mathématiques entiers
+16 bits. Ce qui fait que le résultat final de même que tous les calculs
+mêmes intermé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 à l'intérieur d'un entier 16 bits, il doit donc être théoriquement
+possible de faire le calcul. Nous pouvons faire le calcul de deux faç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ématiquement c'est identique, la première donne y = 0 , c'est à 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ème cas, il n'y a pas de résultat
+intermédiaire et le résultat est correct dans tous les cas.
+
+Si vous trouvez un problème avec vos calculs mathématiques, vérifiez les
+résultats intermédiaires, si il n'y a pas de dépassement de capacités par
+rapports aux valeurs entiè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 à l'echelle les variables lors de calculs par exemple : pour mettre
+mettre à 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èle, contrôlées par
+une simple ligne comme ci-dessous :
+
+ || Xa Ya ||
+ 1 ||-------] [--------------( )-------||
+ || ||
+ || Xb Yb ||
+ ||-------] [------+-------( )-------||
+ || | ||
+ || | Yc ||
+ || +-------( )-------||
+ || ||
+
+à la place de ceci :
+
+ || Xa Ya ||
+ 1 ||-------] [--------------( )-------||
+ || ||
+ || ||
+ || ||
+ || ||
+ || Xb Yb ||
+ 2 ||-------] [--------------( )-------||
+ || ||
+ || ||
+ || ||
+ || ||
+ || Xb Yc ||
+ 3 ||-------] [--------------( )-------||
+ || ||
+
+Il est permis théoriquement d'écrire un programme avec une séquence très
+importante et de ne pas utiliser plusieurs lignes pour la faire. En
+pratique c'est une mauvaise idée, à cause de la compléxité que cela
+peut engendrer et plus difficile à éditer sans effacer et redessiner un
+certain nombre d'éléments de logique.
+
+Néanmoins, c'est une bonne idée de regrouper différents éléments d'un bloc
+logique dans une seule séquence. Le code généré est identique dans les
+deux cas, et vous pouvez voir ce que fait la séquence dans le diagramme
+à contacts.
+
+ * * *
+
+En général, il est considéré comme mauvais d'écrire du code dont la
+sortie dépend de l'ordre d'exécution. Exemple : ce code n'est pas trè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é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'évaluations
+des instructions. Ce serait possible de modifier ce code pour éviter cela,
+mais le code deviendrait très encombrant.
+
+DEFAUTS
+=======
+
+LDmicro ne génére pas un code très efficace; il est lent à exé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ès limitée, ceci pour
+être intégrée correctement dans le diagramme logique, je ne vois pas de
+solution satisfaisante pour solutionner ce problème.
+
+Si votre programme est trop important, vitesse exécution, mémoire
+programme ou contraintes de mémoire de données pour le processeur que vous
+avez choisi, il n'indiquera probablement pas d'erreur. Il se blocquera
+simplement quelque part.
+
+Si vous êtes programmeur négligent dans les sauvegardes et les
+chargements, il est possible qu'un crash se produise ou exé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
+
+
|