LA VAGUE ou Faire un chenillard à puissance variable.



En fait, les leds doivent s'allumer avec des puissances variables

et donner l'impression d'une vague.



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

OPTIMISATION DU PROGRAMME



Après avoir écrit le programme dans le STAMP2, et après avoir essayé quelques

valeurs pour "durée", nous constatons que seul la valeur 1 donne des résultats

acceptables. Toutes les autres valeurs donnent une espèce de clignotement qui

est du plus mauvais effet. Donc, il faut trouver une autre idée pour contrôler

la vitesse de défilement. 



Puisqu'il ne nous est pas possible de faire varier le temps d'allumage des leds

en faisant varier durée, nous allons répéter la séquence "FOR n=0 to 7 ... 

NEXT" un certain nombre de fois, ce qui aurra pour effet de ralentir la vitesse

de défilement. Nous allons donc ajouter une boucle "FOR...NEXT", avec une

variable de comptage supplémentaire (i) et dont la valeur maximale sera

"durée".



D'autre part, il serait intéressant de pouvoir "paramétrer" le programme pour

qu'il puisse fonctionner avec d'autres niveaux d'intensité que 16. Pour cela,

nous remarquons que une fois le nombre de niveaux d'intensité défini, (16),

nous avons le nombre de pas qui vaut 29 soit (16*2)-3, (nous l'appellerons a).

Le premier seuil de test qui vaut 30, soit (16*2)-2, (nous l'appellerons b),

le second seuil de test qui vaut 15, soit 16-1, (nous l'appellerons c). Et

enfin pour l'allumage des leds, le multiplicateur d'intensité vaut 16, soit

256/16, (et nous l'appellerons d). Donc, pour un nombre (nbre) qui défini le

nombre de niveaux d'intensité, nous aurrons a=(nbre*2)-3, b=(nbre*2)-2=a+1,

c=nbre-1 et d=256/nbre.



Après toutes ces remarques et observations, nous pouvons réécrire le programme

en structurée, puis sur le STAMP2.

























































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

Structure du programme



BEGIN



DECLARE pas AS byte        ' numéro du pas, varie de 0 à 29

DECLARE intensité AS byte  ' "niveau" pour chaque led, peut varier de 0 à 36

                           ' puis valeur de l'intensité d'éclairement

DECLARE n AS nibble        ' indice du numéro de led, varie de 0 à 7

DECLARE led(7) AS nibble   ' intensité de chaque led, varie de 0 à 255

DECLARE durée AS byte      ' définit la durée d'éclairement des leds

DECLARE i AS byte          ' variable de comptage pour la durée

DECLARE nbre AS byte       ' définit le nombre de niveaux d'intensité

DECLARE a AS Byte          ' constante calculée, définit le nombre de pas

DECLARE b AS Byte          ' constante calculée, définit un seuil de test

DECLARE c AS Byte          ' constante calculée, définit un seuil de test

DECLARE d AS Byte          ' constante calculée, définit le multiplicateur

                           ' utilisé pour allumer la led avec PWM



LET durée=2                ' définit durée comme une constante. Ceci nous

                           ' permettra de "jouer" avec la durée d'éclairement

                           ' afin de déterminer le meilleur effet.

LET nbre=16                ' définit le nombre de niveaux d'intensité. Ici 

                           ' aussi, nous pourrons "jouer" sur cette valeur

                           ' pour varier les différents effets.



LET a=nbre*2-3             ' définit a, b , c et d comme des constantes

LET b=a+1                  ' les valeurs a, b, c et d étant dérivées de nbre.

LET c=nbre-1

LET d=INT(256/nbre)



DO WHILE pas=pas           ' boucle "infinie"

   LET pas=0

   DO WHILE pas<b

      LET n=0

      DO WHILE n<8

         LET intensité=pas+n

         IF intensité>a THEN

            LET intensité=intensité-b

         ELSE

            IF intensité>c THEN

               LET intensité=b-intensité

            ENDIF

         ENDIF

         LET led(n)=d*intensité

         <Allumer la led(n) pendant la durée définie>

      ENDDO

   ENDDO

ENDDO



END



Attention, lorsque nous allons retranscrire ce programme dans le STAMP2, il

faudra bien se rappeller que les seuil de test ne seront pas les mêmes. Comme,

pour garder les mêmes structures pour les IF, nous devons faire les test inverse,

et que l'utilisation de la boucle FOR...NEXT utilise en fait un (=)

plutôt qu'un (<), les valeurs de a, b, c et d seront utilisée différement.

Elle vaudront : a=nbre*2-3, b=a+1, c=nbre et d=INT(256/nbre). Comme c=nbre,

nous pouvons utilser nbre à sa place, la constante d ne change pas, mais il sera

inutile d'utiliser INT dans le STAMP2,  puisqu'il ne calcule qu'en entier,

et l'utilisation de a et de b sera inversée.



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

'Listing du programme pour le STAMP2



' définition des variables

pas         VAR   byte  'variable de comptage pour leds

intensité   VAR   byte  'puissance d'allumage de la led

n           VAR   nib   'comptage pour chaque led

i           VAR   nib   'comptage pour répétitions



' définition des constantes

nbre        CON   16    'Valeur comprise entre 2 et 128

vitesse     CON   2     'nombre de répétions



' définition des constantes calculées

a           CON   nbre*2-3

b           CON   a+1

d           CON   256/nbre





' programme

début:   FOR pas=0 to a

            FOR i=0 to vitesse

               FOR n=0 to 7

                  intensité=pas+n

                  IF intensité<b THEN saut1

                     intensité=intensité-b

                  GOTO saut2

saut1:            IF intensité<nbre THEN saut2

                     intensité=b-intensité

saut2:               PWM n,d*intensité,1

               NEXT

            NEXT

         NEXT

         GOTO début



' Après écriture de ce programme dans le STAMP2, vous pourrez experimenter

' différentes valeurs pour les constantes "nbre" et "vitesse".

' Bon amusement.