ALPMN - Atelier Liégeois pour la Promotion du Modélisme Naval

... rgl

Programmation des MicroContrôleurs en BASIC
Programmer des MicroContrôleurs en Basic

(c) Roger LEGAT jr

Sur cette page:

   - Généralités d'introduction

   - Programmation des MicroContrôleurs en BASIC ou "pseudo BASIC", Basic orienté µC

   - Logiciels et matériel nécessaire (Basic Stamp, PIC, PICAXE, AVR)

   - Leur programmation In Situ (ICSP Programming: plus besoin d'enlever le MicroContrôleur du circuit pour le programmer !)

   - Notions de Programmation Structurée

   - Astuces en Programmation Structurée

Introduction - Présentation - Généralités

Basic est l'acronyme anglais pour Beginner's All-purpose Symbolic Instruction Code, càd "Code d'Instructions Symboliques multi-usages pour débutants" est une famille de langages de programmation de haut niveau ayant pour caractéristique sa facilité de lecture, de compréhension et donc d'utilisation.

Le language BASIC et, pour nos MCU, son indispensable compilateur est donc ainsi souvent associé aux "débutants".
Je pense néanmoins que c'est "un peu" restrictif et même légèrement ... péjoratif !

Pourquoi alors choisir d'utiliser un compilateur "Basic" ?
Assurément pour sa facilité d'apprentissage et de lisibilité des programmes ... admettons que ces arguments sont alors difficilement critiquables !

Le sujet est résolument vaste et fait déjà l'objet d'une multitudes de pages traitées sur le Web.
Vous en trouverez quelques références, certes pas exhaustives, à la page des Liens.

Pour ma part, cela fait plusieurs années que j'ai décortiqué, étudié, développé et amélioré les sytèmes d'extension de voies communément appelés modules Multi-Swiches et Multi-Prop.
Ce sont des systèmes électroniques qui permettent d'utiliser une voie de notre ensemble RC et ainsi "transformer" une simple sortie du récepteur en plusieurs sorties Tout ou Rien (T/R) ou Proportionnelles, par codage du signal émis par l'émetteur.

Mon dernier proto permet ainsi plusieurs dizaines de fonctions Tout ouRien (T/R - ToR) par voie, sur un émetteur de radio-commande classique !

Depuis la mise en oeuvre, relativement facile, des MicroContrôleurs (MCU - µC) par le modéliste particulier, il n'y a plus que son imagination pour limiter le terrain d'expérimentation de ces merveilleux composants électroniques programmables... de vrais petits "ordinateurs" hyper mini !

Je me suis ainsi fait la main avec les µC microcontrôleurs Basic-Stamp de Parallax®, pour la phase de conception des prototypes.
A moindre prix, je me suis alors intéressé à la vaste famille des PICAXE® faisant l'objet d'un Forum d'utilisateurs très actifs et réactifs... que du Bonheur !
Les programmes et applications étant ensuite transférés dans des PIC grâce à un programmateur, évidemment "fait maison".
Je me penche aujourd'hui, parallèlement à ces composants qui gardent leur facilité d'usage, sur les AVR de Atmel®.
Ces derniers disposent de multiples fonctions intégrées (ADC, PWM, Interruptions, ...), de commandes plus étendues, d'un calculs incluant les décimales, et tout cela pour un prix extrêmement avantageux tout en gardant une même et grande simplicité de programmation !

Je programme très facilement tous ces MicroContrôleurs en BASIC, ou plutôt en language assimilé BASIC, après élaboration d'un algorithme structuré.

Par "assimilé BASIC", ou "pseudo BASIC", comprenez qu'il s'agit d'un BASIC orienté MicroContrôleur et qu'il diffère légèrement du Basic initialement utilisé sous DOS.

( Il y en a encore parmi vous qui se rappellent du DOS et des petits programmes qui tenaient juste sur une disquette sans nécessiter des wagons entiers de dll ? voir notamment la page Prologic Compiler)

Ces µC m'ont permis de mettre au point des modules d'extension de voies (T/R ou Prop) et autres safe-servo, servo-treuils puissants, ..., ...

J'avais d'ailleurs commencé l'écriture d'un ouvrage technique ... que les alléas de la Vie m'ont empêchés de poursuivre à ce jour, bien qu'il compte déjà pas mal de pages et d'études différentes !

Mon dernier projet était la réalisation d'un émetteur, et de son codeur, ergonomique spécialement concu pour le modélisme naval, comprenant des commandes disposées spécialement pour des maquettes à moteur, ou à voile, et reprenant de multiples interrupteurs et potentiomètres pour les extensions de voies.

Mon "laboratoire" flottant expérimental étant alors mon très "petit-gros" remorqueur Zeehondje ... qui ne manque pas de place pour y disposer des "tonnes" de circuits et de batteries puisqu'il mesure 2,5 m pour un déplacement de 210KG !

Programmer les MicroContrôleurs en Basic

L'utilisation des microcontrôleurs, de toutes familles, est vraiment à la portée de tous car ils peuvent facilement être programmés en utilisant un language ne nécessitant pas un long apprentissage: Le BASIC !
Ce language n'enlèvera rien à l'efficacité de vos programmes en comparaison de ceux écrits en C, C+, Assembleur, ..., ..., ...

Comme dans tout language programmé, il faudra impérativement veuiller à écrire vos algorithmes sans erreur de structure !
Toutes ces erreurs de structures conduisent à la saturation de la pile opérationnelle (Over Stacking) de votre µC et ... à son plantage assuré, en cours de route, alors que tout semblait bien aller le jour précédent !
Problème classique d'un "mauvais" programme, d'un programme non structuré.
Vous-vous éviterez donc bon nombre de ces désagréments en appliquant les règles de la programmation structurée.que je vous invite à explorer avant de vous lancer dans l'écriture de votre premier algorithme vous évitant d'emblée les mauvaises habitudes qui ne manqueraient pas de revenir vous pourrir vos programmes.

Matériel et Logiciels nécessaires pour
programmer facilement vos MicroContrôleurs en Basic

La plupart des logiciels sont distribués par les fabricants cités dans la page. Beaucoup sont téléchargeables et sont gratuits !

Basic STAMP

Parallax®

La grande famille des Basic Stamp

Edition / Interpretation / Programmation: Basic Stamp Editor (Parallax®) (In Situ Programming) + Câble série RS232

Les dernières versions du programme et des Stamps permettent des commandes avancées (Boucles conditionnelles complètes, LCD, ...)

Le Basic Stamp est un Microcontrôleur facile à programmer et ne nécessitant aucun matériel particulier.

Cela en fait un outil souple et facile pour la mise au point de protos ou pour l'initiation à la programmation des µC.

PIC,

Stamp to PIC

MicroChip®

PIC, programmateur // et support Zif optionnel ou programmateur Série, type "JDM" à zif

Edition / Compilation: Pic Basic Pro Compiler (Licence !)
Programmation: EPIC Win + Interface // EPIC Plus Programmer (MicroEngineering Labs, inc®) ou Serial JDM Programmer

Une fois votre programme mis au point sur le Stamp, il est intéressant de la placer "définitivement" dans un PIC qui prendra place sur le circuit final et fonctionnel.
Pour ma part, j'ai un faible pour le petit 12F675 :-)

Le programme Stamp demandera juste quelques petites adaptations des commandes, notamment celles relatives au Temps, en fonction du quartz choisi pour l'horloge du PIC. Voir les spécifications du Pic Basic Pro Compiler.

Enfin, pour plus de facilité et de souplesse pour leur programmation, adaptez vos boards à Pic pour une programmation "In-Situ" exécutée directement sur votre platine sans devoir retirer le MicroContrôleur (Voir ci-dessous)

Choisissez toujours une interface de programmation permettant de disposer de 13,5 V pour la tension de programmation (Vpp) de quelques Pic particuliers.

Certains programmateurs de type JDM ne permettent pas tous la programmation en "haute" tension et se limitent à 5 volts !

Ce Pic Programmer est facilement réalisable mais il s'en trouve aussi pour quelques €uros sur ebay et munis de 2 supports ZIF !

Divers programmes dits "d'environnement" permettent un lien entre les programmes de compilation, d'assemblage et de programmation tout en restant dans un même environnement Windows.
Leur usage permet une grande souplesse car il évite de lancer plusieurs programmes successivement. Tout est géré par cet unique environnement.

Liste non exhaustive: CodeStudio, CodeDesigner, ...

Parallax® fournit un manuel extrêment complet reprenant toutes les fonctions et syntaxes de celles-ci ainsi que d'autres publications avec exemples de programmes et autres notes d'applications très pratiques.

PICAXE

A4 Technologie®



Les PICAXE sont une grande famille. Un module est même disponible au standard Arduino.

Serial (AxeEdition / Compilation / Programmation: Picaxe Editor 6 + Câble série RS232 ou cable USB/Série (Axe127)

Les Picaxe sont en fait des PIC standards dans lesquels a été chargé un interpreteur Basic. Ils se programment donc de la même manière que les deux µC vus ci-dessus.
Le Picaxe gère cependant un plus grand nombre de commandes intéressantes et son prix très accessible est incomparable à celui du Basic Stamp par exemple.

Pour le programmer, il suffit de disposer d'un câble série ou d'un câble USB/Série muni d'un adaptateur de tension conseillé et vendu sur le shop de Picaxe.com.

L'editeur dispose d'un module permettant d' "écrire" un programme à l'aide d'un gestionnaire d'organigramme.
Cette particularité est très appréciée par les écoles pour aborder immédiatement la logique de Programmation sans connaître un language particulier.
Le module se charge alors de traduire les organigrammes en language Basic.

Enfin, le programme est également pourvu d'un simulateur. Il est donc possible d'écrire un programme et voir à l'écran le résultat.. sans disposer du moindre matériel !

Vous trouverez sur le site de Picaxe.com toute la documentation utile et nécessaire (Commandes, ...)

Picaxe.com propose aussi toutes sortes d'extensions très pratiques comme des afficheurs OLED avec interface Série ne nécessitant qu'un seul bit de contrôle pour commander cet afficheur !

Simple mesure de température avec un capteur DS18B20

Exemple de deux afficheurs OLED branchés sur le module 28X2 au standard Arduino.

Le premier afficheur, à 2 lignes, indique une mesure entière tandis que le deuxième affficheur, à 4 lignes, affiche une mesure plus précise à deux décimales.

Les afficheurs OLED sont ici commandés en mode Série et ne nécessitent qu'un seul bit de contrôle !

Comparés à un afficheur LCD classique (le troisième en arrière-plan), la différence de visibilité et de contraste avec un OLED saute immédiatement aux yeux !

L'interface Série est aussi géré par un Picaxe qui commande l'afficheur en mode 8 bits.
Le code est publié sur Picaxe.com.

Enfin, cette interface est munie d'un jack 2.5mm permettant de la reprogrammer pour, par exemple, y insérer votre texte d'acceuil, vos caractères spéciaux, ...

AVR

Atmel®

AVR et programmateur ISP USB

Edition / Compilation / Simulation: BASCOM AVR (Atmel®)
Programmation: AVR Studio 4 (Atmel®) + interface USB STK500 Compatible (ISP: In Situ Programming)

Programmation "In-Situ" ISP - ICSP In-Situ Programming In-Circuit Serial Programming

La programmation ISP (In-Situ Programming) ou ICSP (In-Circuit Serial Programming) offre une très grande souplesse et une certaine sécurité "mécanique" à vos µC.
En effet, il n'est plus nécessaire de leur imposer les manipulations et les nombreux allers-retours entre leur platine et le programmateur, avec tous les risques d'endommagement de leurs finettes papattes de connexion.

Pour cela, il faudra simplement prévoir quelques aménagements spécifiques sur votre platine définitive et être attentif à l'utilisation faite des pins de programmation.

Pour le Basic Stamp, outre un connecteur RS232, rien n'est à prévoir car il est pourvu de pins réservés à sa programmation série, en sus de ses in/out classiques.

D'une manière générale, et pour tous les types de MicroContrôleurs, on pourra adapter la platine définitive avec un plus petit connecteur qu'une embase série RS232 / DB9.

Connectique utilisée pour une liaison ICSP pour tout type de MicroContrôleur

Pour les Pic, au niveau de la platine, il faudra ajouter un connecteur 5 pinheaders, avec détrompeur, pour les infos: VPP/MCLR (programming mode voltage) ), VDD (switched positive power), GND (negative power), PGD (Serial Data Line), PGC (Clock), qui permettront le raccordement du µC vers son programmateur externe.
C'est par le biais de ce connecteur que le µC Pic sera programmé.
Certains programmateurs comprennent aussi un 6ème pin pour l'info PGM. (low voltage programming enable)

Il faudra surtout veiller à la manière dont sont utilisés, et câblés, les pins servant à la programmation, RB6(Ck-16F84) et RB7(Data-16F84).
Il ne faut pas que ces pins, lorsqu'elles sont utilisées en fonctionnement normal du µC, soient, par exemple, reliées à la masse ou à Vcc, via une résistance de tirage.
En effet, cette configuration altèrerait inévitablement les signaux de programmation !
Il faudra donc en tenir compte impérativement lors de l'établissement du schéma et, partant, de l'algorithme.

Si on dispose d'un µC dont il n'est pas nécessaire d'utiliser toutes les in/out, on se réservera les ports de programmation à cet usage exclusif.
Les programmateurs de PIC sont généralement pourvu d'un connecteur de sortie permettant d'y raccorder une nappe à destination d'un autre connecteur "In Situ", de programmation, à placer sur votre platine définitive. (v. photo ci contre)

Mini programmateur ICSP pour PIC



            La plupart des µC de la série 16Fxx et 12Fxx devraient se contenter des 12 volts issus de la liaison RS232 pour le Vpp/MCLR.

Pour le Picaxe,
           La platine est à pourvoir d'un connecteur à 3 pins Tx-Rx-Gnd:
          Soit un connecteur 3 Pinheaders Mâle avec détrompeur (MOLEX) et/ou un petit jack 2,5mm Femelle stéréo.






                                                Shéma de l'adaptateur se trouvant dans le connecteur USB

Enfin, pour les AVR, à l'instar des Pics, il faudra aussi prévoir, sur le board, un connecteur "In Situ" pour entrer les infos de programmation issues du programmateur et réfléchir à l'utilisation et aux connexions de ces pins dans le circuit normal.
Pour autant que ces pins de programmation ne soient pas tirés à Gnd ou Vdd par le circuit habituel de la platine, une simple résistance "d'isolation" de 4k7 à 10K suffit.

Mini programmateur ICSP pour AVR



    RS232 pour Stamp





PIC Slot Programmer

RS2032 vers Jack 2.5mm

OU

                  USB vers Jack 2.5mm

Adaptateur Jack / PinHeaders
pour BreadBoard

AVR slot Programmer

Plus astucieux et plus pratique que de déplacer et manipuler le MicroContrôleur, outre un connecteur de programmation "In Situ", on peut placer des jumpers, qui seront enlevés lors de la programmation, pour isoler les pins de programmation et/ou d'alimentation du reste du circuit afin d'éviter d'altérer les données de programmation et d'isoler le reste du circuit de la tension d'alimentation !

Adaptations ICSP à prévoir sur la platine définitive (en cours d'élaboration)

et/ou

Notions de Programmation structurée

La programmation structurée est un language de programmation universel permettant d'élaborer des algorithmes sains, dépourvus d'erreurs de structures.
Nous pourrions résumer les impératifs de structures "classiques" en disant que chaque boucle doit avoir une seule entrée et une sortie; Aucune boucle ne peut restée ouverte; tout départ vers une instruction ou une routine doit obligatoirement revenir à son point d'appel dès qu'elle a été exécutée, ...
Evitez ainsi et surtout les "plats de spaghettis" provoqués par les instructions GOTO qui sont absolument à proscrire !!!
Il ne peut pas y avoir de "cul de sac", ou de "voies sans issue" dans vos programmes, ...

La programmation structurée utilise ses commandes propres et très limitées.
Ces commandes strictes vont jusqu'à ne pas connaître, par exemple, une instruction aussi "classique" que For/Next !
Nous verrons cependant ci-dessous qu'une telle boucle sera évidemment possible, mais en utlisant une boucle do While...

Cette écriture, ce lalnguage, ne sert donc qu'à assurer une structure parfaite à votre prochain algorithme.
Un programme écrit dans ce language "universel" simple, assez proche du Basic, mais aux commandes limitées devra donc ensuite être transposé dans le language de votre application finale en utilisant alors les commandes propres de ce language final, dépendant aussi du µC utilisé dans l'application.

En fait, nous avons déjà tous composé des lignes de codes en s'appliquant à respecter l'ordre des tâches à effectuer mais sans jamais trop se soucier des problèmes de structures qui apparaissent inévitablement dès que la routine commence à devenir plus complexe.

Ces erreurs, plutôt assimilables à une mauvaise habitude "chronique" proviennent de l'usage, faussement facile, de certains "anciens" langages de programmation, comme le BASIC sous DOS, dont les lignes de code étaient labellisées ou numérotées.

Ces lignes étaient alors exécutées dans l’ordre de leurs numéros de lignes.

Ainsi dit, nous ne voyons pas vraiment où peuvent se poser les problèmes me direz-vous !

Mais, en fait, tous ces langages comportent une instruction de branchement de type "Allez à cet endroit du programme", généralement un "GOTO"; instruction qui envoie directement le programme à la ligne spécifiée.

Le problème est que ce type de commande ne comporte pas d’instruction de "retour" comme Endif, Enddo, Return, ... qui " ferment " le bloc appellé.

On se retrouve alors en plein milieu d'un programme, sous un ou plusieurs blocs qui devraient encore être exécutés, mais où le système ne sais plus où il est, ni comment il doit poursuivre ou repartir pour exécuter correctement les autres commandes dans un ordre précis qui était prévu initialement par le programmeur.

Prenons l’exemple simple d’une boucle conditionnelle classique " Si … Alors … Sinon " ; "If .. Then .. Else"

Programmation non structurée

1000 IF [telle condition] Then Goto en 1100 Else Goto 1200

1050

1100 <instruction 1>

1110 etc...

1120 etc...

1190 Goto 1400

1200 <instruction 2>

1210 etc...

1215 IF ... Then goto 1450 ; saut conditionnel vers le bas !

1220 etc...

1300

1350 ... Goto 1400

1400 Suite de l'agorithme

1450 ... Goto 1400

1500 IF ... Then Goto 1120 ; remontee dans le programme !

1550

Un programme écrit de cette façon se présente comme une suite de branchements emmêlés les uns dans les autres.

Imaginez cette manière d'écrire dès qu'une boucle conditionnelle en appellerait une ou plusieurs autres (boucles imbriquées).

Outre le fait que cette structure ne favorise pas la lisibilité du programme, c’est une source importante d’erreurs, car tôt ou tard on oubliera un " aller à ", on en mettra un de trop ou le programme perdra tout simplement le fil d'Ariane qu'il est censé suivre du début à la fin de son exécution !

Au mieux, on dépassera les capacités de la "pile opérationnelle" du µC en lui imposant la gestion de trop de boucles successives qui ne se referment quasiment jamais.

Et pour autant que l'algorithme soit conséquent, ces divers GOTO créeront rapidement une jungle inextricable; un véritable plat de spaghettis !

A l’inverse, la programmation structurée, surtout si l’on prend soin de rationaliser la présentation "papier" en mettant des lignes de commentaires et en pratiquant l’indentation, évitera ces erreurs, et elle révèlera la structure logique du programme de manière très claire.

Programmation Structurée

IF [telle condition] Then

<instructions 1>

Else

<instructions 2>

Endif

Suite immédiate du programme en restant dans le "tronc" du programme.

D'une manière générale, il faut éviter d'utiliser une commande de branchement qui "sort" le pointeur du corps principal du programme, qui le dirige vers une partie basse du programme et qui ne lui permet pas de revenir à son point d'appel dès que le morceau de code conditionnel a été exécuté.

Ainsi, d'une manière générale, l' instruction GOTO est à proscrire impérativement* dans le corps de TOUS vos programmes.

On lui préfèrera sans retenue des appels à des sous-routines (sortes de sous-programmes écrit en parrallèle du code principal) qui, elles, se terminent par une instruction de type "Return" qui renvoie exactement le pointeur dans le programme principal, là où il l'avait quitté.

De plus, le corps principal (tronc) d'un programme ainsi structuré est particulièrement lisible.

Votre programme structuré se trouve finalement être un ensemble de petits sous-programmes traités dans l'ordre établi par votre programme principal.

Le corps principal d'un programme écrit en "structuré" est donc généralement court car il fait appel à un ensemble de sous-programmes (appellés routines, fonctions ou procédures) par la commande GOSUB.

Ces procédures sont toujours clôturées par une instruction de type RETURN qui ramène au tronc du programme principal.

Ces procédures peuvent d'ailleurs être ré-utilisées dans divers programmes en ne nécessitant aucune retouche particulière !

Exemple: Procédure d'envoi de caractères vers un afficheur LCD, Protocole de Tx ou de Rx (envoi/réception) vers interface I²C, ...

* A la limite, un usage du Goto qui pourrait être utile serait la possibilité, sans faire appel à une routine d'INTerruption, de sortir d'une boucle dont le language de programmation ne permet pas une instruction EXIT.

Je pense, par exemple, à une boucle For /Next qui ne prévoit pas de commande EXIT..

Symbol _ARM = pinC.3 : input C.3

Symbol Pressed = b2 ; State of a button

Pressed = 1

...

For i = 0 to 100 ; Delay 20 secondes

IF _ARM = Pressed then goto Armed ; EXIT For/Next

Toggle _LED

Pause 200 ; Loop for 20 seconds / 100 = 200ms at 4Mhz

; 200msec x 100 = 20000 msec = 20 sec

...

Armed:

...

Exemple d'un programme écrit en language structuré universel et adapté pour une programmation:
1) dans un PIC
2) dans un BasicStamp:

' Déclaration des Variables :

   IN      Var       Word ‘1250/1875/2500 – BSIIsx

   i        Var       Nibble ‘(Word for PIC) 0 à 7

   Etat   Var       Nibble ‘(Word for PIC) (0,1,2)

    S0     Con     800 ‘Adapter en fonction du Quartz µC !

   S1     Con     1562
   S2     Con     2187
' Infos matériel

In/Out :            Pulsin                                      0

                        7 Sorties (*)                             1 à 7

                        Témoin dysfonctionnement    8

·         Suivant le type de codeur, il est possible de gérer 7, 8, 15 ou 16 sorties T/R.
   Le Pic doit cependant compter autant de in/out !
   Adapter les valeur / échantillonages, relatives au temps, en fonction du quartz utilisé !

Programme Structuré
universel

PIC Basic Pro Compiler (.pbp) pour PIC
'Pic 16 Mhz

Basic-Stamp V2.5 (.bsx) pour BasicStamp
'BasicStamp IIsx

BEGIN
Do While i=i

<Lire les impulsions sur 0, et placer dans IN>

    GoSub Tri

    GoSub Sorties

Enddo

END

‘------ SUBROUTINES ------------

SUB Tri

IF IN <S0 0 Then

<Allumer un témoin de dysfonction>

Let Etat = 1     ‘Voie OFF

Else

    <Désactiver témoin de dysfonction>

    IF IN <=S1 Then       ‘SeuilSynchro

    Let I=0             ‘RAZ Var indicée

    Let Etat=0   ‘Synchro

    Else

         IF IN <S2 Then ‘SeuilOFF

         Let Etat=1   ‘Voie OFF

         Else

         Let Etat=2   ‘Voie ON

         Endif

    Endif

Endif

Endsub ‘and return
‘ ----------------------------------------------

SUB Sorties

IF Etat<>0 Then

    IF Etat=1 Then

    <Placer i à 0>      ‘Voie OFF

    Else   ’Etat=2

    <Placer i à 1>      ‘Voie ON

    Endif

    Let i=i+1

Endif

Endsub ‘and return

Debut:

Pulsin 0,1,IN

GoSub Tri

GoSub Sorties

Goto Debut 'Le seul GOTO permis pour fermer la boucle principale !

END

‘------ SUBROUTINES ------------

Tri:

IF IN <256 Then

High 8    ‘Témoin de dysfonction

Let Etat = 1     ‘Voie OFF

Else

    Low 8      ‘Désactive témoin dysfonction

    IF IN <=499 Then      ‘<=1562 &&&

    Let i=0                    ‘RAZ Var indicée

    Let Etat=0   ‘Synchro

    Else

         IF IN <699 Then   ‘<2187 &&&

         Let Etat=1   ‘Voie OFF

         Else

         Let Etat=2   ‘Voie ON

         Endif

    Endif

Endif

Return

‘ -------------------------------------------

Sorties:

IF Etat<>0 Then

    IF Etat=1 Then

    Low i      ‘Voie OFF

    Else        ’Etat=2

    High i     ‘Voie ON

    Endif

    Let i=i+1

Endif

Return

Debut:

Pulsin 0,1,IN

GoSub Tri

GoSub Sorties

Goto Debut 'Le seul GOTO permis pour fermer la boucle principale !

STOP

‘------ SUBROUTINES ------------

Tri:

    IF IN <S0 Then

    High 8    ‘Témoin de dysfonction

    Etat = 1 ‘Voie OFF

    Else

      Low 8          ‘Désactive témoin dysfct

       IF IN <S1 Then      ‘<=1562 &&&

        i=0           ‘RAZ Var indicée

        Etat=0 ‘Synchro

       Else

         IF IN <S2 Then   ‘<2187 &&&

         Etat=1    ‘Voie OFF

         Else

         Etat=2    ‘Voie ON

         Endif

       Endif

    Endif

Return

‘ -----------------------------------------

Sorties:

    IF Etat<>0 Then

         IF Etat=1 Then

         Low i      ‘Voie OFF

         Else        ’Etat=2

         High i     ‘Voie ON

         Endif

         i=i+1

    Endif

Return

Dans le language structuré universel, vous constaterez que les commandes propres aux languages finaux sont remplacés par des < expressions verbales >.
Celles-ci seront remplacés par les commandes ad-hocs, une fois le language choisi en fonction du matériel à programmer.
La structure parfaite du language structuré sera cependant respectée, garantissant ainsi un programme final sans défaut de fonctionnemnt.

Bref, ce sont là toutes les bases de la Programmation Structurée, développées plus amplement ici que je vous invite à appliquer systématiquement !

Astuces - Programmation structurée

Se voulant être universel, pour pouvoir ensuite être transposé dans le language de votre application finale, le nombre d'instructions "structurelles" disponibles en programmation structurée est particulièrement limité.

Mais nous avons cependant vu que les commandes d'exécution, particulières et propres à chaque matériel qui sera utilisé est écrit en language verbal clair.
Exemple: <Saisir température et placer dans la Variable XYZ>, <Allumer brûleur>, < Afficher le niveau>, <Déclencher l'alarme>, ..., ...

Il faudraainsi utiliser quelques routines habituelles pour « simuler » des fonctions, parfois toutes faites dans votre language final, et auxquelles ont est souvent bien confortablement habitués ... mais qui ne sont pas admises en programmation structurée !

Exemples non exhaustifs:

Certaines commandes que nous utilisons habituellement dans les languages de programmation usuels n'existent pas en Programmtion structurée !

En effet, se voulant le plus universel possible, le language spartiate de la programmtion structurée se limite à des commandes essentielles (déclarations de variables, boucles et conditionnelles).

Il est néanmoins possible de les "réécrir" en language structuré:

FOR … NEXT

Let J = 0

Do while J<=9 ‘ Boucle exécutée 10x, tant que que J<=9

< instructions >

Let J = J+1 ‘ i = 0 à 10, mais lorsque i=10, le pointeur remonte mais

Enddo ‘ la boucle ne sera plus exécutée.

Let J = 0$

Do ‘ Ouverture de boucle

< instructions >

Let J = J+1 ‘ Boucle exécutée 10x, jusqu’à ce que J=10

Until J<10 ‘ i= 0 à 10, mais lorsque i =10 la boucle ne s’exécute plus

‘ et le pointeur ne remonte plus. Le programme continue de suite.

MOD (calcul du reste d’une division)

MOD (n/d) =  n - d*INT(n/d)  
 

  5 3
-3 1
2

Soit la division A/B

Partie entière : K= A/B Si la variable n’a pas été définie en virgule flottante, le processeur ne travaille qu’en mode entier.

Reste (MOD) = A-KB

Exemple:

K = 5/3 = 1,~~667~~

MOD 5/3 = 5-1x3 = 2

Thèmes développés:

Programmation des MCU en BASIC
Programmation structurée
Programmation des Basic Stamp
Programmation des Picaxe
Programmation des PIC en Basic
Programmation des AVR en Basic

Trafic Visiteurs: