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. Pendant l'exécution du programme, envoyer la valeur de la variable de boucle à l'écran du PC, puis lorsque un cycle complet est éffectué, (allumage, puis extinction), envoyer son numéro de téléphone dans le haut parleur de la carte de test (sortie 11). Pour mieux comprendre ce qui est demandé, nous allons établir un tableau qui expliquera un peu mieux ce qu'il faut faire. Voici un exemple avec la puissance en % : pas led7 led6 led5 led4 led3 led2 led1 led0 0 00 00 00 00 00 00 00 00 1 01 00 00 00 00 00 00 00 2 02 01 00 00 00 00 00 00 3 03 02 01 00 00 00 00 00 4 04 03 02 01 00 00 00 00 98 98 97 96 95 94 93 92 91 99 99 98 97 96 95 94 93 92 100 100 99 98 97 96 95 94 93 101 99 100 99 98 97 96 95 94 102 98 99 100 99 98 97 96 95 103 97 98 99 100 99 98 97 96 104 96 97 98 99 100 99 98 97 105 95 96 97 98 99 100 99 98 106 94 95 96 97 98 99 100 99 107 93 94 95 96 97 98 99 100 108 92 93 94 95 96 97 98 99 109 91 92 93 94 95 96 97 98 110 90 91 92 93 94 95 96 97 199 01 02 03 04 05 06 07 08 200 00 01 02 03 04 05 06 07 201 00 00 01 02 03 04 05 06 202 00 00 00 01 02 03 04 05 203 00 00 00 00 01 02 03 04 204 00 00 00 00 00 01 02 03 205 00 00 00 00 00 00 01 02 206 00 00 00 00 00 00 00 01 207 00 00 00 00 00 00 00 00 L'exemple donné l'est ici avec 100 niveaux d'éclairement. En fait, nous savons que pour cet exercice, nous allons utiliser l'instruction PWM du STAMP2. Or, cette instruction utilise 256 niveaux de puissance (de 0 à 255), et comme ça fait beaucoup, nous allons réduire ce nombre à 16 ou à 32 (toujours des puissance de 2). Si nous prenons un exemple avec 16 niveaux d'éclairement, (de 0 à 15) il nous suffira de diviser 256 par 16, et nous obtenons un pas de 16 pour l'utisation de la commande PWM. Voici le tabeau de puissance avec 16 niveaux: pas led7 led6 led5 led4 led3 led2 led1 led0 0 00 00 00 00 00 00 00 00 1 01 00 00 00 00 00 00 00 2 02 01 00 00 00 00 00 00 3 03 02 01 00 00 00 00 00 4 04 03 02 01 00 00 00 00 5 05 04 03 02 01 00 00 00 6 06 05 04 03 02 01 00 00 7 07 06 05 04 03 02 01 00 8 08 07 06 05 04 03 02 01 9 09 08 07 06 05 04 03 02 10 10 09 08 07 06 05 04 03 11 11 10 09 08 07 06 05 04 12 12 11 10 09 08 07 06 05 13 13 12 11 10 09 08 07 06 14 14 13 12 11 10 09 08 07 15 15 14 13 12 11 10 09 08 16 14 15 14 13 12 11 10 09 17 13 14 15 14 13 12 11 10 18 12 13 14 15 14 13 12 11 19 11 12 13 14 15 14 13 12 20 10 11 12 13 14 15 14 13 21 09 10 11 12 13 14 15 14 22 08 09 10 11 12 13 14 15 23 07 08 09 10 11 12 13 14 24 06 07 08 09 10 11 12 13 25 05 06 07 08 09 10 11 12 26 04 05 06 07 08 09 10 11 27 03 04 05 06 07 08 09 10 28 02 03 04 05 06 07 08 09 29 01 02 03 04 05 06 07 08 30 00 01 02 03 04 05 06 07 31 01 00 01 02 03 04 05 06 32 02 01 00 01 02 03 04 05 33 03 02 01 00 01 02 03 04 34 04 03 02 01 00 01 02 03 35 05 04 03 02 01 00 01 02 36 06 05 04 03 02 01 00 01 37 07 06 05 04 03 02 01 00 38 08 07 06 05 04 03 02 01 En observant ce tableau, nous nous rendons compte que si nous voulons avoir un mouvement continu de nos leds, il serait intéressant de commencer notre boucle au pas numéro 7 et de la terminer au pas numéro au pas 36, puisque le pas numéro 37 est identique au pas numéro 7. nous aurons ainsi un mouvement qui aurra l'impression de ne jamais avoir de cassure. Nous obtenons donc finalement le tableau suivant : pas led7 led6 led5 led4 led3 led2 led1 led0 0 07 06 05 04 03 02 01 00 1 08 07 06 05 04 03 02 01 2 09 08 07 06 05 04 03 02 3 10 09 08 07 06 05 04 03 4 11 10 09 08 07 06 05 04 5 12 11 10 09 08 07 06 05 6 13 12 11 10 09 08 07 06 7 14 13 12 11 10 09 08 07 8 15 14 13 12 11 10 09 08 9 14 15 14 13 12 11 10 09 10 13 14 15 14 13 12 11 10 11 12 13 14 15 14 13 12 11 12 11 12 13 14 15 14 13 12 13 10 11 12 13 14 15 14 13 14 09 10 11 12 13 14 15 14 15 08 09 10 11 12 13 14 15 16 07 08 09 10 11 12 13 14 17 06 07 08 09 10 11 12 13 18 05 06 07 08 09 10 11 12 19 04 05 06 07 08 09 10 11 20 03 04 05 06 07 08 09 10 21 02 03 04 05 06 07 08 09 22 01 02 03 04 05 06 07 08 23 00 01 02 03 04 05 06 07 24 01 00 01 02 03 04 05 06 25 02 01 00 01 02 03 04 05 26 03 02 01 00 01 02 03 04 27 04 03 02 01 00 01 02 03 28 05 04 03 02 01 00 01 02 29 06 05 04 03 02 01 00 01 Ce tableau nous fait remarquer trois choses. La première, est qu'il n'est composé que de 30 lignes, alors que nous aurrions pu nous attendre à en avoir 32 (16 * 2), en fait, si nous observons la colonne de la Led0, nous remarquons que l'intensité varie de 0 à 15 (16 pas), puis de 14 à 1 (14 pas) et ceci vient du fait que les pas 0 et 15 ne sont éfféctués qu'une seule fois, alors que tous les autres pas sont répétés 2 fois. La deuxième se remarque bien en observant la dernière colonne (de nouveau la led0). Pour les pas 0 à 15, le niveau d'intensité est le même que le numéro du pas. Par contre, pour les pas 16 à 29, le niveau d'intensité décroit, et un petit calcul rapide nous montre que " intensité = 30 - pas". Donc pour la led0, nous avons "intensité = pas" pour les pas de 0 à 15, et "intensité = 30-pas" pour les pas supérieurs à 15. La dernière, est que la puissance de chaque led peut-être déduite du numéro du pas par un petit calcul simple. En effet, si nous prenons comme exemple la led5, nous remarquons que sa puissance est égale à celle du pas plus 5, ce qui pourrais s'écrire "led(n) = pas+n". Au nombre obtenu, il suffit d'appliquer la règle que nous avons deduite dans la deuxième remarque. Le problème est que arrivé à 30, le calcul devient faux. Par contre, si à partir de 30 nous retranchons 30 au lieu de 15, le calcul redevient juste. Donc, en résumé, nous pouvons établir le calcul suivant pour la led(n): Niveau = pas + n pour niveau < 15 alors intensité = niveau pour niveau compris entre 15 et 30 alors intensité = 30 - niveau et pour niveau > 30 alors intensité = niveau - 30 Il ne nous reste plus qu'a coucher tout cela sur le papier. Commençons par la programmation structurée. Tout d'abord, il faut définir les variables utilisées. Le raisonnement précédent, nous a montré que nous allons avoir besoin d'une variable de comptage du pas (pas) qui variera de 0 à 29. Puis une variable pour chaque led (n) qui variera de 0 à 7. Puis une variable qui sera utilisée pour le calcul du "pas" de chaque led (intensité) qui variera de 0 à 36 (29+7), cette variable pourra aussi contenir en fin de traitement, la valeur de l'intensité à envoyer dans la LED, à ce moment, sa valeur devra être comprise entre 0 et 15. Evidement, il nous faudra une variable tableau qui contiendra le niveau d'intensité de chaque led (led(n)). Cette variable variera de 0 à 255, puisque ce sont les valeurs utilisée dans l'intruction PWM. Et enfin, il nous faudra une contante de temps pour déterminer la durée d'éclairement des leds, nous l'appellerons durée. Une fois les variables définie, et le raisonnement établi, il n'y a plus qu'a ... ******************************************************************************* 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 LET durée = 2 ' définit durée comme une constante. Ceci nous ' permettra de "jouer" avec la durée d'éclairage ' afin de déterminer le meilleur effet. DO WHILE pas=pas ' boucle "infinie" LET pas=0 DO WHILE pas<30 LET n=0 DO WHILE n<8 LET intensité=pas+n IF intensité>29 THEN LET intensité=intensité-30 ELSE IF intensité>15 THEN LET intensité=30-intensité ENDIF ENDIF LET led(n)=16*intensité ENDDO ENDDO ENDDO END ***************************************************************************** 'Listing du programme pour le STAMP2 pas VAR byte ' numéro du pas, varie de 0 à 29 intensité VAR byte ' "pas" pour chaque led, peut varier de 0 à 36 ' puis calcul de l'intensité, varie de 0 à 15 n VAR nib ' indice du numéro de led, varie de 0 à 7 durée CON 2 ' définit la durée d'éclairement des leds ' Notez que dans les STAMP2, la variable led(n) n'existe pas, puisque l'indice ' (n) servira d'argument à la commande PWM. début: FOR pas=0 to 29 FOR n=0 to 7 intensité=pas+n IF intensité<30 THEN saut1 intensité=intensité-30 GOTO saut2 saut1: IF intensité<16 THEN saut2 intensité=30-intensité saut2: PWM n,16*intensité,durée NEXT DEBUG ?pas NEXT DTMFOUT 11,[0,4,2,2,4,0,6,9,4] GOTO debut ***************************************************************************** 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. Enfin, les intructions DEBUG et DTMFOUT n'étant pas d'une importance capitale pour réaliser l'effet lumineux, nous allons les supprimer. 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 pasa THEN LET intensité=intensité-b ELSE IF intensité>c THEN LET intensité=b-intensité ENDIF ENDIF LET led(n)=d*intensité 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é