02-2 - Effet lumineux à deux leds

---------------------------------



Au vu de l'énnoncé, et de manière graphique, il est possible de représenté

cet effet de la manière suivante :



             Leds

        7 6 5 4 3 2 1 0

pas 1 - O . . . . . . O

pas 2 - . O . . . . O .

pas 3 - . . O . . O . .

pas 4 - . . . O O . . .

pas 5 - . . O . . O . .

pas 6 - . O . . . . O .



Avec le matériel utilisé , nous avons les 8 leds qui sont raccordées sur un

des octet de sortie du microcontrôleur. Si nous considérons chaque led comme

un bit de l'octet, nous pouvons calculer sa valeur numérique pour chaque pas :



             Leds

        7 6 5 4 3 2 1 0

pas 1 - O . . . . . . O : 128 + 1 = 129

pas 2 - . O . . . . O . :  64 + 2 =  66

pas 3 - . . O . . O . . :  32 + 4 =  36

pas 4 - . . . O O . . . :  16 + 8 =  24

pas 5 - . . O . . O . . :  32 + 4 =  36

pas 6 - . O . . . . O . :  64 + 2 =  66



-------------------------------------------------------------------------------

La manière la plus triviale de résoudre le problème est de faire une boucle

infinie qui vas envoyer séquentiellement les 6 valeurs en ajoutant une pause

entre chaque allumage de leds.



Ce qui vas nous donner en structurée :



BEGIN                         ' Début du programme



DECLARE Leds       AS BYTE    ' Octet contenant la valeur pour les leds

DECLARE PauseOn    AS WORD    ' Valeur de la pause T1 en ms (allumage)

DECLARE PauseOff   AS WORD    ' Valeur de la pause T2 en ms (extinction)



<Assigner la variable LEDS à l'octet de sortie correspondant>

LET PauseOn = 1000            ' Pause d'allumage réglée sur 1 seconde

LET PauseOff = 500            ' Pause d'extinction réglée sur 1/2 seconde

                              ' Ces valeurs peuvent-être ajustée en fonction

                              ' de l'effet voulu



DO WHILE Leds = Leds          ' Boucle infinie (condition toujours vraie!)

   LET Leds = 129             '   Allumage des leds 7 & 0

   PAUSE PauseOn ms           '   Pause d'une seconde

   LET Leds = 0               '   Extinction des leds

   PAUSE PauseOff ms          '   Pause d'une demi-seconde

   LET Leds = 66              '   Allumage des leds 6 & 1

   PAUSE PauseOn ms           '   Pause d'une seconde

   LET Leds = 0               '   Extinction des leds

   PAUSE PauseOff ms          '   Pause d'une demi-seconde

   LET Leds = 36              '   Allumage des leds 5 & 2

   PAUSE PauseOn ms           '   Pause d'une seconde

   LET Leds = 0               '   Extinction des leds

   PAUSE PauseOff ms          '   Pause d'une demi-seconde

   LET Leds = 24              '   Allumage des leds 4 & 3

   PAUSE PauseOn ms           '   Pause d'une seconde

   LET Leds = 0               '   Extinction des leds

   PAUSE PauseOff ms          '   Pause d'une demi-seconde

   LET Leds = 36              '   Allumage des leds 5 & 2

   PAUSE PauseOn ms           '   Pause d'une seconde

   LET Leds = 0               '   Extinction des leds

   PAUSE PauseOff ms          '   Pause d'une demi-seconde

   LET Leds = 66              '   Allumage des leds 6 & 1

   PAUSE PauseOn ms           '   Pause d'une seconde

   LET Leds = 0               '   Extinction des leds

   PAUSE PauseOff ms          '   Pause d'une demi-seconde

ENDDO                         ' Bouclage vers le début



END                           ' Fin du programme



-------------------------------------------------------------------------------

En analysant un peu plus le problème, nous remarquons que les valeurs

128, 64, 32, 16, 8, 4, 2, 1 sont en fait des puissances de 2, de 2^7 à 2^0.

Dès lors, nous pouvons avoir le tableau suivant :



             Leds

        7 6 5 4 3 2 1 0

pas 1 - O . . . . . . O : 2^7 + 2^0 = 128 + 1 = 129

pas 2 - . O . . . . O . : 2^6 + 2^1 =  64 + 2 =  66

pas 3 - . . O . . O . . : 2^5 + 2^2 =  32 + 4 =  36

pas 4 - . . . O O . . . : 2^4 + 2^3 =  16 + 8 =  24

pas 5 - . . O . . O . . : 2^5 + 2^2 =  32 + 4 =  36

pas 6 - . O . . . . O . : 2^6 + 2^1 =  64 + 2 =  66



Dans ce tableau, nous remarquons que pour chaque pas, nous avons

les exposants de 2 qui sont des valeurs complémentaires : 

7 & 0, 6 & 1, 5 & 2, 4 & 3, dont la somme des deux valeurs

est toujours égale à 7. Et en analysant les valeurs, nous constatons

que si I représente la valeur de l'indice de comptage, qui varie de

7 à 4, nous aurrons la première valeur qui sera égale à 2^I et la 

seconde qui sera égale à 2^(7-I).



Toujours en observant le tableau, nous remarquons que nous pouvons faire

deux boucles. La première décomptera de 7 à 5, tandis que la deuxième

comptera de 4 à 6. Ces deux boucles seront imbriquées dans une boucle infinie.



Nous aurrons alors la structurée suivante :



BEGIN                         ' Début du programme



DECLARE I          AS NIBBLE  ' Compteur pour les boucles de comptage

DECLARE Leds       AS BYTE    ' Octet contenant la valeur pour les leds

DECLARE PauseOn    AS WORD    ' Valeur de la pause T1 en ms (allumage)

DECLARE PauseOff   AS WORD    ' Valeur de la pause T2 en ms (extinction)



<Assigner la variable LEDS à l'octet de sortie correspondant>

LET PauseOn = 1000            ' Pause d'allumage réglée sur 1 seconde

LET PauseOff = 500            ' Pause d'extinction réglée sur 1/2 seconde

                              ' Ces valeurs peuvent-être ajustée en fonction

                              ' de l'effet voulu



DO WHILE Leds = Leds          ' Boucle infinie (condition toujours vraie!)

   LET I = 7                  '   Initialisation de la variable de (dé)comptage

   DO WHILE I > 4             '   Début de la première boucle de comptage

      LET Leds = 2^I + 2^(7-I)'     Calcul de la valeur de l'octet de sortie

      PAUSE PauseOn ms        '     Pause d'une seconde

      LET Leds = 0            '     Extinction des leds

      PAUSE PauseOff ms       '     Pause d'une demi-seconde

      LET I = I - 1           '     Décrémentation du compteur

   ENDDO                      '   Fin de la première boucle de comptage

   LET I = 4                  '   Initialisation de la variable de comptage

   DO WHILE I < 7             '   Debut de la seconde boucle de comptage

      LET Leds = 2^I + 2^(7-I)'     Calcul de la valeur de l'octet de sortie

      PAUSE PauseOn ms        '     Pause d'une seconde

      LET Leds = 0            '     Extinction des leds

      PAUSE PauseOff ms       '     Pause d'une demi-seconde

      LET I = I + 1           '     Incrément du compteur

   ENDDO                      '   Fin de la seconde boucle de comptage

ENDDO                         ' Fin de la boucle infinie



END                           ' Fin du programme





Remarque : Lors de l'écriture du programme dans le stamp, comme l'opérateur

exposant "^" n'existe pas, nous utiliserons l'instruction DCD, qui correspond

en fait à un exposant de 2. (En fait, DCD n est équivalent à 2^n)



-------------------------------------------------------------------------------

Si maintenant, dans le tableau précédent, nous inversons les termes de

l'addition dans les 3 derniers pas du tableau, , nous remarquons que,

à par un "saut" entre les pas 3 et 4, les valeurs se suivent soit en incrément,

soit en décrément.



             Leds

        7 6 5 4 3 2 1 0

pas 1 - O . . . . . . O : 2^7 + 2^0 = 128 +  1 = 129

pas 2 - . O . . . . O . : 2^6 + 2^1 =  64 +  2 =  66

pas 3 - . . O . . O . . : 2^5 + 2^2 =  32 +  4 =  36

pas 4 - . . . O O . . . : 2^3 + 2^4 =   8 + 16 =  24

pas 5 - . . O . . O . . : 2^2 + 2^5 =   4 + 32 =  36

pas 6 - . O . . . . O . : 2^1 + 2^6 =   2 + 64 =  66



La tentation est grande "d'adapter" le tableau en ajoutant un pas

intermédiaire entre les pas 3 et 4 pour obtenir le tableau suivant :



             Leds

        7 6 5 4 3 2 1 0

pas 1 - O . . . . . . O : 2^7 + 2^0 = 128 +  1 = 129

pas 2 - . O . . . . O . : 2^6 + 2^1 =  64 +  2 =  66

pas 3 - . . O . . O . . : 2^5 + 2^2 =  32 +  4 =  36

pas 4 - . . . O O . . . : 2^4 + 2^3 =  16 +  8 =  24

pas 5 - . . . O O . . . : 2^3 + 2^4 =   8 + 16 =  24

pas 6 - . . O . . O . . : 2^2 + 2^5 =   4 + 32 =  36

pas 7 - . O . . . . O . : 2^1 + 2^6 =   2 + 64 =  66



Mais en fait, cette solution n'est pas la bonne puisqu'elle

s'éloigne du "cahier des charges". Maintenant, lors du processus

de développement, il est éventuellement possible de proposer

cette solution au "client"....



Pour s'en tenir au cahier des charges, nous écrirons donc une

seule boucle qui variera de 0 à 6, avec une exeption au pas n°3

ou au pas n°4 qui "sautera" ce pas.



Nous aurrons alors la structurée suivante :



BEGIN                         ' Début du programme



DECLARE I          AS NIBBLE  ' Compteur pour les boucles de comptage

DECLARE Leds       AS BYTE    ' Octet contenant la valeur pour les leds

DECLARE PauseOn    AS WORD    ' Valeur de la pause T1 en ms (allumage)

DECLARE PauseOff   AS WORD    ' Valeur de la pause T2 en ms (extinction)



<Assigner la variable LEDS à l'octet de sortie correspondant>

LET PauseOn = 1000            ' Pause d'allumage réglée sur 1 seconde

LET PauseOff = 500            ' Pause d'extinction réglée sur 1/2 seconde

                              ' Ces valeurs peuvent-être ajustée en fonction

                              ' de l'effet voulu



DO WHILE Leds = Leds          ' Boucle infinie (condition toujours vraie!)

   LET I = 0                  '   Initialisation de la variable de comptage

   DO WHILE I < 7             '   Début de la boucle de comptage

      IF I <> 3 THEN          '     "Saute" le calcul si I=3 (bon aussi avec 4)

        LET Leds = 2^(7-I) + 2^I '    Calcul de la valeur de l'octet de sortie

        PAUSE PauseOn ms      '       Pause d'une seconde

        LET Leds = 0          '       Extinction des leds

        PAUSE PauseOff ms     '       Pause d'une demi-seconde

        LET I = I + 1         '       Incrémentation du compteur

      ENDIF                   '     Fin du saut sur la valeur de I

   ENDDO                      '   Fin de la boucle de comptage

ENDDO                         ' Fin de la boucle infinie



END                           ' Fin du programme



-------------------------------------------------------------------------------

Encore une autre méthode :

--------------------------

Reprenons le tableau précedent en y ajoutant les valeurs

en hexa en dernière colonne:



             Leds

        7 6 5 4 3 2 1 0

pas 1 - O . . . . . . O : 2^7 + 2^0 = 128 +  1 = 129 = $81

pas 2 - . O . . . . O . : 2^6 + 2^1 =  64 +  2 =  66 = $42

pas 3 - . . O . . O . . : 2^5 + 2^2 =  32 +  4 =  36 = $24

pas 4 - . . . O O . . . : 2^3 + 2^4 =   8 + 16 =  24 = $18

pas 5 - . . O . . O . . : 2^2 + 2^5 =   4 + 32 =  36 = $24

pas 6 - . O . . . . O . : 2^1 + 2^6 =   2 + 64 =  66 = $42



Si nous considérons nos huit leds, non pas comme un octet, mais comme deux

nibbles, nous nous rendons compte que chaque nibble correpons à un digit

hecadécimal. Le premier nibble (le nibble de poid faible) représente les

quatre leds de poids faible (0, 1, 2 et 3), tandis que le deuxième nibble

représente les quatre leds de poids fort ((4, 5, 6 et 7).

Si maintenant, pour chaque valeur hexadécimale nous mettons en relation

les puissance de 2 correspondantes, et que nous mettons en évidence une

relation de calcul entre le numéro du pas, et le calcul de l'exposant,

nous obtenons le tableau suivant :



 Pas  - Hex - 2^n ->   Exp1 ->   Exp2

-------------------------------------

  0   - 8-1 - 3/0 ->    pas -> 3-Exp1

  1   - 4-2 - 2/1 ->    pas -> 3-Exp1

  2   - 2-4 - 1/2 ->    pas -> 3-Exp1

  3   - 1-8 - 0/3 ->    pas -> 3-Exp1

  4   - 2-4 - 1/2 ->  6-pas -> 3-Exp1

  5   - 4-2 - 2/1 ->  6-pas -> 3-Exp1



Nous pouvons donc en déduire que l'exposant 1 peut-être calculé

par la relation suivante : Exp1 = ABS(INT(pas/4)*6 - pas)

et l'exposant2 sera calculé par la relation : Exp2 = 3 - Exp1.



Il ne nous reste plus qu'à mettre tout çà en musique ;)



BEGIN                         ' Début du programme



DECLARE I          AS NIBBLE  ' Compteur pour les boucles de comptage

DECLARE Led1       AS NIBBLE  ' Nibble pour les leds 0 à 3

DECLARE Led2       AS NIBBLE  ' Nibble pour les leds 4 à 7

DECLARE PauseOn    AS WORD    ' Valeur de la pause T1 en ms (allumage)

DECLARE PauseOff   AS WORD    ' Valeur de la pause T2 en ms (extinction)



<Assigner la variable Led1 et Led2 à l'octet de sortie correspondant>

LET PauseOn = 1000            ' Pause d'allumage réglée sur 1 seconde

LET PauseOff = 500            ' Pause d'extinction réglée sur 1/2 seconde

                              ' Ces valeurs peuvent-être ajustée en fonction

                              ' de l'effet voulu



DO WHILE Led1 = Led1          ' Boucle infinie (condition toujours vraie!)

   LET I = 0                  '   Initialisation de la variable de comptage

   DO WHILE I < 6             '   Début de la boucle de comptage

     LET Led1 = 2^ABS(INT(I/4)*6 - I)    ' Calcul du nibble de poids faible

     LET Led2 = 2^(3-ABS(INT(I/4)*6 - I))' Calcul du nibble de poids fort

     PAUSE PauseOn ms         '     Pause d'une seconde

     LET Leds = 0             '     Extinction des leds

     PAUSE PauseOff ms        '     Pause d'une demi-seconde

     LET I = I + 1            '     Incrémentation du compteur

   ENDDO                      '   Fin de la boucle de comptage

ENDDO                         ' Fin de la boucle infinie



END                           ' Fin du programme



-------------------------------------------------------------------------------

*******************************************************************************

-------------------------------------------------------------------------------

Variante n°1

------------

Selon l'énnocé du problème, nous pouvons écrire le tableau suivant :



            Leds       :        Binaire       =Total=Complément=Hexa

-----------------------:----------------------=-----=----------=----

Pas1 - O O O O O O O O : 128+64+32+16+8+4+2+1 = 255 =  255-  0 = $FF

Pas2 - . O O O O O O . :     64+32+16+8+4+2   = 126 =  255-129 = $7E

Pas3 - . . O O O O . . :        32+16+8+4     =  60 =  255-195 = $3C

Pas4 - . . . O O . . . :           16+8       =  24 =  255-231 = $18

Pas5 - . . O . . O . . :        32     +4     =  36 =  255-219 = $24

Pas6 - . O . . . . O . :     64          +2   =  66 =  255-189 = $42

Pas7 - O . . . . . . O : 128               +1 = 129 =  255-126 = $81

Pas8 - O O . . . . O O : 128+64          +2+1 = 195 =  255- 60 = $C3

Pas9 - O O O . . O O O : 128+64+32     +4+2+1 = 231 =  255- 24 = $E7



De ce tableau, nous pouvons en déduire certaines relations :

Par exemple :

Pas1 = Pas2 + Pas7 = Pas3 + Pas8 = Pas4 + Pas9 

 255 =  126 +  129 =   60 +  195 =   24 +  231 = 255

ou : 

Pas8 - O O . . . . O O : 128+64          +2+1 = 195 = 255- 60 - $C3

Pas9 - O O O . . O O O : 128+64+32     +4+2+1 = 231 = 255- 24 - $E7

Pas1 - O O O O O O O O : 128+64+32+16+8+4+2+1 = 255 = 255-  0 - $FF

Pas2 - . O O O O O O . :     64+32+16+8+4+2   = 126 = 255-129 - $7E

Pas3 - . . O O O O . . :        32+16+8+4     =  60 = 255-195 - $3C

-----------------------:----------------------=-----=--------------

Pas4 - . . . O O . . . :           16+8       =  24 = 255-231 - $18

Pas5 - . . O . . O . . :        32     +4     =  36 = 255-219 - $24

Pas6 - . O . . . . O . :     64          +2   =  66 = 255-189 - $42

Pas7 - O . . . . . . O : 128               +1 = 129 = 255-126 - $81



A l'observation de ces "relations", nous remarquons qu'il n'y a pas

moyen de resortir une seule relation. Plusieurs boucles de calculs

devront donc être utilisées. La solution qui semble intéressante

içi est de créer un tableau contenant les différentes valeurs

à envoyer dans l'octet de sortie. Nous avons alors :



   Leds(1) = 255

   Leds(2) = 126

   Leds(3) =  60

   Leds(4) =  24

   Leds(5) =  36

   Leds(6) =  66

   Leds(7) = 129

   Leds(8) = 195

   Leds(9) = 231



Nous aurrons alors la structurée suivante :



BEGIN                         ' Début du programme



DECLARE I          AS NIBBLE  ' Compteur pour les boucles de comptage

DECLARE Leds(9)    AS BYTE    ' Tabeau contenant les valeurs de sortie

DECLARE Led        AS BYTE    ' Octet reprenant la valeur de sortie

DECLARE PauseOn    AS WORD    ' Valeur de la pause T1 en ms (allumage)



<Assigner la variable Led à l'octet de sortie correspondant>



LET Leds(1) = 255             ' Mise à jour du tableau Leds(9)

LET Leds(2) = 126             ' avec les différentes valeurs

LET Leds(3) = 60              ' nécessaires à l'éffet désiré.

LET Leds(4) = 24              '

LET Leds(5) = 36              '

LET Leds(6) = 66              '

LET Leds(7) = 129             '

LET Leds(8) = 195             '

LET Leds(9) = 231             '

LET PauseOn = 100             ' Pause d'allumage réglée sur 1 seconde

                              ' Cette valeur peut-être ajustée en fonction

                              ' de l'effet voulu



DO WHILE Led = Led            ' Boucle infinie (condition toujours vraie!)

   LET I = 1                  '   Initialisation de la variable de comptage

   DO WHILE I < 10            '   Début de la boucle de comptage

     LET Led = Leds(I)        '   Assignation de la valeur de Led

     PAUSE PauseOn ms         '     Pause d'une seconde

     LET I = I + 1            '     Incrémentation du compteur

   ENDDO                      '   Fin de la boucle de comptage

ENDDO                         ' Fin de la boucle infinie



END                           ' Fin du programme



-------------------------------------------------------------------------------

Il est possible de créer une variante de ce programme en mettant

les différentes valeurs nécessaires à l'éffet voulu dans la mémoire

EEprom du microcontrôleur.



Nous aurrons alors la structurée suivante :



BEGIN                         ' Début du programme



DECLARE I          AS NIBBLE  ' Compteur pour les boucles de comptage

DECLARE Adresse    AS WORD    ' Tabeau contenant les valeurs de sortie

DECLARE Led        AS BYTE    ' Octet reprenant la valeur de sortie

DECLARE PauseOn    AS WORD    ' Valeur de la pause T1 en ms (allumage)



<Assigner la variable Led à l'octet de sortie correspondant>



<Stocker dans la mémoire EEprom les valeurs :

 255,126,60,24,36,66,129,195,231,100>



LET PauseOn = 100             ' Pause d'allumage réglée sur 1 seconde

                              ' Cette valeur peut-être ajustée en fonction

                              ' de l'effet voulu

LET Adresse = <Adresse de base de l'EEprom> 



DO WHILE Led = Led            ' Boucle infinie (condition toujours vraie!)

   LET I = 0                  '   Initialisation de la variable de comptage

   DO WHILE I < 9             '   Début de la boucle de comptage

     LET Led = <Valeur stockée à l'adresse "Adresse+I">

                              '     Assignation de la valeur de Led

     PAUSE PauseOn ms         '     Pause

     LET I = I + 1            '     Incrémentation du compteur

   ENDDO                      '   Fin de la boucle de comptage

ENDDO                         ' Fin de la boucle infinie



END                           ' Fin du programme



-------------------------------------------------------------------------------

*******************************************************************************

-------------------------------------------------------------------------------

Variante n°2

------------

Dans la variante 2 nous alons ajouter la possibilité d'arrêter

l'effet lumineux avec les touches noires, et de le redémarrer avec

les touches rouges.



Il faudra inclure une variable de contrôle qui permettra de savoir

s'il faut ou non exécuter les séquences d'allumage.

Et pour que l'on puisse lire le "clavier" de manière régulière,

il faudra inclure la lecture dans la boucle d'allumage des leds.



Si nous regardons le hardware, nous voyons que :

 - les touches sont raccordées sur le 3ème nibble des entrées

 - Les touches rouges correspondent aux bits 0 & 1 et sont à 0 au repos

 - Les touches noires correspondent aux bits 2 & 3 et sont à 1 au repos

 - Donc la valeur au repos du "clavier" est 12 (%1100)

 - L'appuis d'une ou de deux touches noires correspond à 0, 4 ou 8.

 - L'appuis d'une ou de deux touches rouhges correspond à 13, 14 ou 15

 - Donc, nous pouvons dire que l'appuis d'une ou de deux touches noires

   vas nous donner une valeur de "clavier" inférieure à 9, et l'appuis

   de une ou deux touches rouges, nous donne une valeur supérieure à 12.



Ce qui vas nous donner en structurée :



BEGIN                         ' Début du programme



DECLARE I          AS NIBBLE  ' Compteur pour les boucles de comptage

DECLARE Adresse    AS WORD    ' Tabeau contenant les valeurs de sortie

DECLARE Led        AS BYTE    ' Octet reprenant la valeur de sortie

DECLARE Arret      AS BIT     ' Flag pour l'arrêt de l'effet

                              ' 0 = RUN & 1 = STOP

DECLARE Clavier    AS NIBBLE  ' Variable de lecture du clavier

DECLARE PauseOn    AS WORD    ' Valeur de la pause T1 en ms (allumage)

<Assigner la variable Led à l'octet de sortie correspondant>

<Assigner les touches du clavier sur la variable "Clavier">

<Stocker dans la mémoire EEprom les valeurs :

 255,126,60,24,36,66,129,195,231,100>

LET PauseOn = 100             ' Pause d'allumage réglée sur 1 seconde

                              ' Cette valeur peut-être ajustée en fonction

                              ' de l'effet voulu

LET Adresse = <Adresse de base de l'EEprom> 

LET Arret   = 0               ' Permet le déroulement de l'effet

DO WHILE Led = Led            ' Boucle infinie (condition toujours vraie!)

   LET I = 0                  '   Initialisation de la variable de comptage

   DO WHILE I < 9             '   Début de la boucle de comptage

     IF Arret = 0 THEN        '     Test si la variable arrêt est sur "RUN"

       LET Led = <Valeur stockée à l'adresse "Adresse+I">

                              '       Assignation de la valeur de Led

       PAUSE PauseOn ms       '       Petite Pause

     ENDIF                    '     Fin du test de l'arrêt de l'effet

     IF Clavier < 9 THEN      '     Si une touche noire est appuyée

       Arret = 1              '       Arrêt de l'effet

     ELSE                     '     Sinon

       IF Clavier > 12 THEN   '       Si une touche rouge est appuyée

         Arret = 0            '         Redémarrage de l'effet

       ENDIF                  '       Fin du test "touches rouges"

     ENDIF                    '     Fin du test "touches noires"

     LET I = I + 1            '     Incrémentation du compteur

   ENDDO                      '   Fin de la boucle de comptage

ENDDO                         ' Fin de la boucle infinie



END                           ' Fin du programme



-------------------------------------------------------------------------------

*******************************************************************************

-------------------------------------------------------------------------------

Variante 3

----------

Deux différences par rapport à ce que nous avons déjà vu :

 - Le test de l'intérupteur sera inclus dans la boucle infine.

 - Nous utiliserons une sous-routine pour la lecture des potentiomètres

   et des boutons poussoirs. Cette sous-routine sera incluse à l'intérieur

   des boucles d'effet.



Programmation structurée

------------------------

BEGIN                         ' Début du programme



DECLARE  I        AS NIBBLE      ' Variable pour le compteur

DECLARE  Led      AS BYTE        ' Assignation de Led sur les sorties

DECLARE  Led1     AS NIBBLE      ' Assignation des variables Led1 & Led2

DECLARE  Led2     AS NIBBLE      ' sur le port de sortie

DECLARE  PauseOn  AS WORD        ' Constante pour tempo d'allumage (Pin15)

DECLARE  PauseOff AS BYTE        ' Constante pour tempo d'extinction (Pin14)

DECLARE  Arret    AS BIT         ' Variable de contrôle de défilement

DECLARE  Clavier  AS NIBBLE      ' Assignation des 4 touches dans un nibble



<Stocker dans la mémoire EEprom les valeurs suivantes 

 255,126,60,24,36,66,129,195,231>' Mise en mémoire EEprom les différentes

                                 ' valeurs nécessaires à l'effet voulu



DO WHILE led = led        ' Début de la boucle infinie



  IF IN13 = 0 THEN        ' Test position intérupteur



    LET I = 0             ' Initialisation de la variable de comptage

    DO WHILE I < 9        '  Début de boucle effet n°1

      GOSUB Pots          '   Lecture des pots

      IF Arret=0 THEN     '   Test de fonctionnement

        LET Led = <Position mémoire I>  '   Allumage des leds

        PAUSE PauseOn     '    Pause une seconde

      ENDIF               '   Fin du test de fonctionnement

      LET I = I + 1       '   Incrémentation de la variable de comptage

    ENDDO                 '  Fin de la boucle pour effet n°1



  ELSE                    ' Test autre position intérupteur



    LET I = 0             '  Initialisation de la variable de comptage

    DO WHILE I < 6        '   Début de boucle effet n°2

      GOSUB pots          '    Lecture des pots

      IF Arret=0 THEN     '    Test de fonctionnement

        LET Led1 = DCD ABS((I/4)*6 - I)     ' Allumage des leds

        LET Led2 = DCD (3-ABS((I/4)*6 - I)) ' sur chaque nibble

        PAUSE PauseOn     '     Pause d'allumage

        LET Led = 0       '     Extinction des leds

        PAUSE PauseOff    '     Pause d'extinction

      ENDIF               '    Fin du test de fonctionnement

      LET I = I + 1       '    Incrémentation de la variable de comptage

    ENDDO                 '   Fin de la deuxième boucle

  ENDIF                   '  Fin de la boucle pour effet n°2



ENDDO                     ' Fin de la boucle infinie



' Sous routine lecture des pots et des 4 touches

' ----------------------------------------------

SUB Pots                   ' Début de la routine

  LET PauseOff = <Lecture du pot sur entrée 14>   ' Lecture de l'I/O 14

  LET PauseOn  = <Lecture du pot sur entrée 15>   ' Lecture de l'I/O 15

  IF Clavier < 9 THEN      '     Si une touche noire est appuyée

    Arret = 1              '       Arrêt de l'effet

  ELSE                     '     Sinon

    IF Clavier > 12 THEN   '       Si une touche rouge est appuyée

      Arret = 0            '         Redémarrage de l'effet

    ENDIF                  '       Fin du test "touches rouges"

  ENDIF                    '     Fin du test "touches noires"

ENDSUB                     ' Fin de la routine et retour