Cours:ChenillardShieldNano : Différence entre versions

De troyesGEII
Aller à : navigation, rechercher
(Appui sur bp change de couleur de dégradé)
 
(31 révisions intermédiaires par le même utilisateur non affichées)
Ligne 124 : Ligne 124 :
 
=Chenillard=
 
=Chenillard=
  
=passage HSV=
+
==simple==
 +
Pour un chenillard, il n'y a toujours qu'une seule led allumée. On change de led qui s'allume régulièrement.
  
=représentation de la température avec les leds=
+
Lorsqu'on a allumé la dernière led, on recommence au début.
  
****************************************************************
+
{{Question|Ecrire le programme}}
****************************************************************
 
****************************************************************
 
****************************************************************
 
****************************************************************
 
  
=A supprimer !!!=
+
==double sens==
  
 +
On utilisera au choix 1 ou 2 boutons pour changer le "sens de déplacement" du chenillard.
  
==Gestion des leds==
+
{{Question|Ecrire le programme}}
  
===Notion de port===
+
'''Remarque :''' : Pensez à utiliser une variable, changer le sens selon se valeur.
  
[[Fichier:ArduinoNanoPinout|right|400px]]
+
==vitesse==
En observant attentivement la figure ci-contre, on constate que les pattes utilisées pour commander les leds n'ont pas été choisies au hasard.
 
  
En effet, nous utilisons les pattes 8 à 13, qui correspondent pour le µcontrôleur au PORTB (PB0, PB1, PB2, ...).
+
Vous disposez sur votre carte de potentiomètre qui donnent une tension analogique entre [0V 5V].
  
{{Info|Ainsi, il devient possible de modifier l'état de toutes ces sorties/leds, en une seule instruction :}}
+
{{Question|En utilisant le {{CAN}} (analogRead), faire un sorte qu'on puisse modifier la vitesse du chenillard}}
  
<source lang=c>
+
==autre type==
void setup()
 
{
 
  // déclarer toutes les pattes en sortie :
 
  
}
+
il existe d'autres types de chenillard :
 +
*double
 +
*à accumulation
 +
*...
  
void loop()
+
à découvrir par vous même !
{
 
  //mettre toutes les sorties à '1'
 
  PORTB = 0b00111111; 
 
  delay(200);
 
  //mettre toutes les sorties à '0'
 
  PORTB = 0b00000000;  // ou PORTB = 0x00; ou encore PORTB = 0;
 
  delay(200);
 
}
 
</source>
 
  
==={{Vert|Utilisation}}===
+
=couleurs TSV (ou HSV)=
  
{| class="wikitable"
+
Il existe différentes façons de représenter les couleurs, chacune ayant ses avantages et inconvénients.
|-
 
||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]||[[Fichier:Leda.png]]||[[Fichier:Leda.png]]
 
|-
 
||[[Fichier:Leda.png]]||[[Fichier:Leda.png]]||[[Fichier:Leda.png]]||[[Fichier:Leda.png]]||[[Fichier:Lede.png]]||[[Fichier:Leda.png]]
 
|}
 
  
{{Question|En vous inspirant du programme précédent, faire un programme affichant successivement ces 2 motifs pendant 0,5s.}}
+
Nous souhaitons utiliser la représentation [https://fr.wikipedia.org/wiki/Teinte_Saturation_Valeur TSV]
  
=={{Bleu|Chenillard}}==
 
  
{{Question|Écrire le programme du chenillard}}
+
Comme les leds que nous utilisons fonctionnent en RGB, nous devons réaliser une fonction qui convertit de TSV en RGB.
  
Il s'agit d'allumer une seule led et de faire en sorte qu'elle se "déplace" de droite à gauche :
 
  
{| class="wikitable"
+
{{info|Pour créer une fonction, nous devons choisir :}}
|-
+
*le nom de la fonction
||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]||[[Fichier:Leda.png]]
+
*le nombre et le type des paramètres
|-
+
*la valeur retournée, ou plutôt le type retourné
||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]||[[Fichier:Leda.png]]||[[Fichier:Lede.png]]
+
{{Rouge|Attention, une fonction ne peut retourner qu'une seule variable !!}}
|-
 
|colspan="8"|<center>...</center>
 
|-
 
||[[Fichier:Leda.png]]||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]
 
|}
 
  
'''Remarque''' : Rappelez-vous qu'il y a déjà une "boucle" dans votre programme .... la fonction loop !
+
De façon général, la création d'une nouvelle fonction ressemblera donc à :
 +
<source lang=cpp>
 +
typeRetour maFonction(type1 parametre1, type2, parametre2, ....)
 +
{
 +
  typeRetour val;
 +
  ...
 +
  ...
 +
  return val;
 +
}
 +
</source>
  
{{Aide|Une boucle bien sûr !}}
 
  
  
 +
{{Todo|Ajouter la fonction de conversion HSV vers RGB qui :}}
 +
*a 3 paramètres d'entrée (les 3 composantes H, S et V)
 +
**H représente la teinte (c'est ce qu'on appelle communément la couleur ! ) : entre 0 et 360, valeur d'un angle sur le cercle des couleurs :
 +
***0° rouge
 +
***60° jaune
 +
***120° vert
 +
***180° cyan
 +
***240° bleu
 +
***300° magenta
 +
**S représente la saturation : entre 0 et 100, plus la saturation est faible plus la couleur est terne ( couleur "grise" )
 +
**V représente l'intensité lumineuse : entre 0 et 100, plus la valeur est fiable plus la couleur est sombre
 +
*retourne une couleur {{Rouge|rgb_color}}
 +
*vous pouvez trouver la [https://www.codespeedy.com/hsv-to-rgb-in-cpp/ méthode de conversion sur cette page]
  
Pour réaliser un chenillard simple, nous devons envoyer successivement les valeurs suivantes sur le port :
+
<source lang=cpp>
{|
+
rgb_color HSVtoRGB(float H, float S,float V)
!
+
{
! colspan="8"|Binaire
+
    rgb_color couleurRGB;
!
+
    float s = S/100;
! Décimal
+
    float v = V/100;
|-
+
    float C = s*v;
|val1 = ||0||0||0||0||0||0||0||{{rouge|1}}|| ||align="center"| 1
+
    float X = C*(1-abs(fmod(H/60.0, 2)-1));
|-
+
    float m = v-C;
|val2 = ||0||0||0||0||0||0||{{rouge|1}}||0|| ||align="center"| 2
+
    float r,g,b;
|-
+
    if(H >= 0 && H < 60){
|val3 = ||0||0||0||0||0||{{rouge|1}}||0||0|| ||align="center"| 4
+
        r = C,g = X,b = 0;
|-
+
    }
|val4 = ||0||0||0||0||{{rouge|1}}||0||0||0|| ||align="center"| 8
+
    else if(H >= 60 && H < 120){
|-
+
        r = X,g = C,b = 0;
|val5 = ||0||0||0||{{rouge|1}}||0||0||0||0|| ||align="center"| 16
+
    }
|-
+
    else if(H >= 120 && H < 180){
|val6 = ||0||0||{{rouge|1}}||0||0||0||0||0|| ||align="center"| 32
+
        r = 0,g = C,b = X;
|}
+
    }
 +
    else if(H >= 180 && H < 240){
 +
        r = 0,g = X,b = C;
 +
    }
 +
    else if(H >= 240 && H < 300){
 +
        r = X,g = 0,b = C;
 +
    }
 +
    else{
 +
        r = C,g = 0,b = X;
 +
    }
 +
   
 +
    couleurRGB.red = (r+m)*255;
 +
    couleurRGB.green = (g+m)*255;
 +
    couleurRGB.blue = (b+m)*255;
  
{{Rouge|Remarque}} : Une solution élégante consiste à utiliser [https://www.arduino.cc/en/Reference/Bitshift les opérateurs de décalage]
+
    return couleurRGB;
 +
}</source>
  
{{finAide}}
 
  
=={{Bleu|Changer la vitesse}}==
+
{{Question|faire alors un programme qui fait varier la teinte sur chacune des leds de façon à avoir un effet "arc-en-ciel"}}
  
{{Question|Modifier votre programme pour que la vitesse du chenillard dépende du potentiomètre}}
+
'''Ex:'''
 
+
<source lang=cpp>
'''Remarque''' : il s'agit bien évidemment de faire [https://www.arduino.cc/en/Reference/analogRead une lecture analogique].
+
...
 
+
tableauCouleurs[3] = HSVtoRGB(200,100,10);
 
+
...
=={{Bleu|Changer le sens de "rotation"}}==
+
</source>
 
 
{{Question|Modifier votre programme pour que le sens de rotation dépende de la position de l'interrupteur}}
 
 
 
=={{Bleu|Mise en route/arrêt}}==
 
 
 
On souhaite pouvoir arrêter/démarrer le chenillard à chaque {{Rouge|appui}} sur le bouton poussoir.
 
 
 
{{Question|Faire les modifications nécessaires pour répondre à ce nouveau cahier des charges.}}
 
 
 
={{Rouge|Allons plus loin}}=
 
 
 
Pour les 2 programmes suivants, en cas de besoin, vous pouvez chercher des informations [[Cours:Tp_II|sur cette page]].
 
 
 
=={{Bleu|Chenillard double}}==
 
 
 
Pour un chenillard double, 2 leds se déplacent en sens opposé.
 
 
 
{{Question|Écrire le programme correspondant.}}
 
 
 
 
 
=={{Bleu|Chenillard à entassement}}==
 
 
 
un chenillard à entassement est un chenillard simple avec une led qui se déplace, mais une fois arrivée à l'extrémité la led reste allumée et on en rajoute une au départ, qui se déplace et s'empile sur la précédente ....  
 
 
 
{{Question|Écrire le programme correspondant.}}
 
 
 
 
 
=={{Bleu|Plusieurs mode}}==
 
  
 +
=représentation de la température avec les leds=
  
{{Question|Faire en sorte que chaque appui sur le bouton poussoir change le type de chenillard :}}
+
{{Question|Reprendre le programme de mesure de la température et utilisez les leds pour faire un affichage de cette température}}
* arrêté
 
* simple
 
* double
 
* entassement
 

Version actuelle datée du 16 octobre 2023 à 17:41

Retour à la liste des Tps

Éléments de correction


Nous allons utiliser les 8 leds ws2812B de notre shield. Une seule broche permet de piloter ces 8 leds : elles sont toutes chaînées.

LedsWs2812b.png

Nous utiliserons la librairie PololuLedStrip qu'il faudra bien évidemment installer !!

Découverte

Exemple

Todo.jpg Le programme suivant vous donne un exemple d'utilisation. Vérifiez que ce programme fonctionne correctement sur votre carte.

#include <PololuLedStrip.h>
// Create an ledStrip object and specify the pin it will use.
PololuLedStrip<4> rubanLed;
// Create a buffer for holding the colors (3 bytes per color).
#define nbLeds 8
rgb_color tableauCouleurs[nbLeds];

void setup()
{

}

void loop() {
  // put your main code here, to run repeatedly:
  
  // on complète le tableau avec les couleurs souhaitées pour chaque led
  tableauCouleurs[0] = rgb_color(0,0,10);
  tableauCouleurs[1] = rgb_color(10,0,0);
  tableauCouleurs[2] = rgb_color(0,10,0);
  tableauCouleurs[3] = rgb_color(10,0,10);
  tableauCouleurs[4] = rgb_color(0,10,10);
  tableauCouleurs[5] = rgb_color(10,10,0);
  tableauCouleurs[6] = rgb_color(10,10,10);
  tableauCouleurs[7] = rgb_color(2,2,2);
  // une fois le tableau complété/modifié,
  // on génère le signal pour modifier l'état des leds
  rubanLed.write(tableauCouleurs, nbLeds);
  delay(500);

  // on peut également changer les couleurs indépendamment
  tableauCouleurs[0].red=0;
  tableauCouleurs[0].green=0;
  tableauCouleurs[0].blue=1;
  
  tableauCouleurs[1].red=1;
  tableauCouleurs[1].green=0;
  tableauCouleurs[1].blue=0;
  
  tableauCouleurs[2].red=0;
  tableauCouleurs[2].green=1;
  tableauCouleurs[2].blue=0;
  
  tableauCouleurs[3].red=1;
  tableauCouleurs[3].green=0;
  tableauCouleurs[3].blue=1;
  
  tableauCouleurs[4].red=0;
  tableauCouleurs[4].green=1;
  tableauCouleurs[4].blue=1;
  
  tableauCouleurs[5].red=1;
  tableauCouleurs[5].green=1;
  tableauCouleurs[5].blue=0;
  
  tableauCouleurs[6].red=1;
  tableauCouleurs[6].green=1;
  tableauCouleurs[6].blue=1;
  
  tableauCouleurs[7].red=0;
  tableauCouleurs[7].green=0;
  tableauCouleurs[7].blue=0;
  
  rubanLed.write(tableauCouleurs, nbLeds);
  delay(500);
}

Dégradé de couleur

dégradé de couleur

Question.jpg Modifier le programme pour réaliser un dégradé de bleu, la valeur devra varier entre 1 et 9

Info.jpg On pourra astucieusement utiliser une boucle for

Ex :

for (int i=0;i<4;i++)
{
  tableauCouleurs[i].red=i*10;
}

Remarque :

Afin de vérifier les couleurs choisies, vous pouvez facilement afficher les couleurs des différentes leds de la façon suivante :

for (int i=0;i<8;i++)
{
  Serial.print(tableauCouleurs[i].red);
  Serial.print(" ");
}

Question.jpg Modifier votre programme pour faire un dégradé des 3 couleurs successivement

Appui sur bp change de couleur de dégradé

On souhaite changer la couleur du dégradé à chaque appui sur le bouton.

Question.jpg En utilisant l'interruption associée à l'un des 2 boutons, faire en sorte que :

  • à chaque appui, une variable mode change de valeur.
  • dans votre fonction loop changer la couleur des leds suivant la valeur de la variable mode

Chenillard

simple

Pour un chenillard, il n'y a toujours qu'une seule led allumée. On change de led qui s'allume régulièrement.

Lorsqu'on a allumé la dernière led, on recommence au début.

Question.jpg Ecrire le programme

double sens

On utilisera au choix 1 ou 2 boutons pour changer le "sens de déplacement" du chenillard.

Question.jpg Ecrire le programme

Remarque : : Pensez à utiliser une variable, changer le sens selon se valeur.

vitesse

Vous disposez sur votre carte de potentiomètre qui donnent une tension analogique entre [0V 5V].

Question.jpg En utilisant le Convertisseur Analogique Numérique (analogRead), faire un sorte qu'on puisse modifier la vitesse du chenillard

autre type

il existe d'autres types de chenillard :

  • double
  • à accumulation
  • ...

à découvrir par vous même !

couleurs TSV (ou HSV)

Il existe différentes façons de représenter les couleurs, chacune ayant ses avantages et inconvénients.

Nous souhaitons utiliser la représentation TSV


Comme les leds que nous utilisons fonctionnent en RGB, nous devons réaliser une fonction qui convertit de TSV en RGB.


Info.jpg Pour créer une fonction, nous devons choisir :

  • le nom de la fonction
  • le nombre et le type des paramètres
  • la valeur retournée, ou plutôt le type retourné

Attention, une fonction ne peut retourner qu'une seule variable !!

De façon général, la création d'une nouvelle fonction ressemblera donc à :

typeRetour maFonction(type1 parametre1, type2, parametre2, ....)
{
  typeRetour val;
  ...
  ...
  return val;
}


Todo.jpg Ajouter la fonction de conversion HSV vers RGB qui :

  • a 3 paramètres d'entrée (les 3 composantes H, S et V)
    • H représente la teinte (c'est ce qu'on appelle communément la couleur ! ) : entre 0 et 360, valeur d'un angle sur le cercle des couleurs :
      • 0° rouge
      • 60° jaune
      • 120° vert
      • 180° cyan
      • 240° bleu
      • 300° magenta
    • S représente la saturation : entre 0 et 100, plus la saturation est faible plus la couleur est terne ( couleur "grise" )
    • V représente l'intensité lumineuse : entre 0 et 100, plus la valeur est fiable plus la couleur est sombre
  • retourne une couleur rgb_color
  • vous pouvez trouver la méthode de conversion sur cette page
rgb_color HSVtoRGB(float H, float S,float V)
{
    rgb_color couleurRGB;
    float s = S/100;
    float v = V/100;
    float C = s*v;
    float X = C*(1-abs(fmod(H/60.0, 2)-1));
    float m = v-C;
    float r,g,b;
    if(H >= 0 && H < 60){
        r = C,g = X,b = 0;
    }
    else if(H >= 60 && H < 120){
        r = X,g = C,b = 0;
    }
    else if(H >= 120 && H < 180){
        r = 0,g = C,b = X;
    }
    else if(H >= 180 && H < 240){
        r = 0,g = X,b = C;
    }
    else if(H >= 240 && H < 300){
        r = X,g = 0,b = C;
    }
    else{
        r = C,g = 0,b = X;
    }
    
    couleurRGB.red = (r+m)*255;
    couleurRGB.green = (g+m)*255;
    couleurRGB.blue = (b+m)*255;

    return couleurRGB;
}


Question.jpg faire alors un programme qui fait varier la teinte sur chacune des leds de façon à avoir un effet "arc-en-ciel"

Ex:

...
tableauCouleurs[3] = HSVtoRGB(200,100,10);
...

représentation de la température avec les leds

Question.jpg Reprendre le programme de mesure de la température et utilisez les leds pour faire un affichage de cette température