Cours:ChenillardShieldNano : Différence entre versions

De troyesGEII
Aller à : navigation, rechercher
(couleurs TSV (ou HSV))
 
(25 révisions intermédiaires par le même utilisateur non affichées)
Ligne 123 : Ligne 123 :
  
 
=Chenillard=
 
=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|Ecrire le programme}}
 +
 +
==double sens==
 +
 +
On utilisera au choix 1 ou 2 boutons pour changer le "sens de déplacement" du chenillard.
 +
 +
{{Question|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|En utilisant le {{CAN}} (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)=
 
=couleurs TSV (ou HSV)=
Ligne 140 : Ligne 170 :
 
{{Rouge|Attention, une fonction ne peut retourner qu'une seule variable !!}}
 
{{Rouge|Attention, une fonction ne peut retourner qu'une seule variable !!}}
  
La création d'une nouvelle fonction ressemblera donc à :
+
De façon général, la création d'une nouvelle fonction ressemblera donc à :
 
<source lang=cpp>
 
<source lang=cpp>
 
typeRetour maFonction(type1 parametre1, type2, parametre2, ....)
 
typeRetour maFonction(type1 parametre1, type2, parametre2, ....)
Ligne 153 : Ligne 183 :
  
  
{{Question|Ecrire une fonction de conversion TSV vers RGB qui :}}
+
{{Todo|Ajouter la fonction de conversion HSV vers RGB qui :}}
*aura 3 paramètres d'entrée (les 3 composantes T, S et V)
+
*a 3 paramètres d'entrée (les 3 composantes H, S et V)
*retournera une couleur {{Rouge|rgb_color}}}
+
**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 :
*effectuera la conversion de la façon suivante :
+
***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]
  
=représentation de la température avec les leds=
+
<source lang=cpp>
 +
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;
****************************************************************
+
}</source>
****************************************************************
 
****************************************************************
 
****************************************************************
 
  
=A supprimer !!!=
 
  
 +
{{Question|faire alors un programme qui fait varier la teinte sur chacune des leds de façon à avoir un effet "arc-en-ciel"}}
  
==Gestion des leds==
+
'''Ex:'''
 
+
<source lang=cpp>
===Notion de port===
+
...
 
+
tableauCouleurs[3] = HSVtoRGB(200,100,10);
[[Fichier:ArduinoNanoPinout|right|400px]]
+
...
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, ...).
 
 
 
{{Info|Ainsi, il devient possible de modifier l'état de toutes ces sorties/leds, en une seule instruction :}}
 
 
 
<source lang=c>
 
void setup()
 
{
 
  // déclarer toutes les pattes en sortie :
 
 
 
}
 
 
 
void loop()
 
{
 
  //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>
 
</source>
  
==={{Vert|Utilisation}}===
+
=représentation de la température avec les leds=
 
 
{| class="wikitable"
 
|-
 
||[[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.}}
 
 
 
=={{Bleu|Chenillard}}==
 
 
 
{{Question|Écrire le programme du chenillard}}
 
 
 
Il s'agit d'allumer une seule led et de faire en sorte qu'elle se "déplace" de droite à gauche :
 
 
 
{| class="wikitable"
 
|-
 
||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]||[[Fichier:Leda.png]]
 
|-
 
||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]||[[Fichier:Lede.png]]||[[Fichier:Leda.png]]||[[Fichier:Lede.png]]
 
|-
 
|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 !
 
 
 
{{Aide|Une boucle bien sûr !}}
 
 
 
 
 
 
 
Pour réaliser un chenillard simple, nous devons envoyer successivement les valeurs suivantes sur le port :
 
{|
 
!
 
! colspan="8"|Binaire
 
!
 
! Décimal
 
|-
 
|val1 = ||0||0||0||0||0||0||0||{{rouge|1}}|| ||align="center"| 1
 
|-
 
|val2 = ||0||0||0||0||0||0||{{rouge|1}}||0|| ||align="center"| 2
 
|-
 
|val3 = ||0||0||0||0||0||{{rouge|1}}||0||0|| ||align="center"| 4
 
|-
 
|val4 = ||0||0||0||0||{{rouge|1}}||0||0||0|| ||align="center"| 8
 
|-
 
|val5 = ||0||0||0||{{rouge|1}}||0||0||0||0|| ||align="center"| 16
 
|-
 
|val6 = ||0||0||{{rouge|1}}||0||0||0||0||0|| ||align="center"| 32
 
|}
 
 
 
{{Rouge|Remarque}} : Une solution élégante consiste à utiliser [https://www.arduino.cc/en/Reference/Bitshift les opérateurs de décalage]
 
 
 
{{finAide}}
 
 
 
=={{Bleu|Changer la vitesse}}==
 
 
 
{{Question|Modifier votre programme pour que la vitesse du chenillard dépende du potentiomètre}}
 
 
 
'''Remarque''' : il s'agit bien évidemment de faire [https://www.arduino.cc/en/Reference/analogRead une lecture analogique].
 
 
 
 
 
=={{Bleu|Changer le sens de "rotation"}}==
 
 
 
{{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}}==
 
 
 
  
{{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