Sorties analogiques d’Arduino. Intensité lumineuse.

L’objectif de ce projet nous dirige à pouvoir contrôler l’intensité d’une led usant les sorties PWM (signal à rapport cyclique variable) qui correspondent aux pins digitaux (broches) précédés du symbole « ~ » sur notre plaque.

Pour commencer, on changera l’intensité d’une seule led. Après, on fera de même avec trois diodes ( bleue, verte et rouge), et finalement, on variera l’intensité avec une led RBG, fournie des trois couleurs primaires et des résistances intégrées.

Les ampoules ou diodes led sont des dispositifs analogiques, cela implique qu’elles peuvent présenter plusieurs états; c’est à dire, qu’elles peuvent s’illuminer avec différentes intensités et de façon graduelle.

Le microcontrôleur d’ Arduino Uno détiens des convertisseurs analogiques capables de traduire la valeur reçue à travers l’entrée analogique; mais pour les sorties analogiques il doit se servir du signal PWM. Le principe PWM est de construire un signal qui est alternativement LOW et HIGH et de répéter très vite cette alternance. Une led, par exemple, est donc alternativement allumée et éteinte mais le cycle est tellement rapide qui donne l’illusion d’une diode allumée en permanence. Les sorties PWM sur Arduino sont précédés du symbole « ~« .

Varier l’intensité lumineuse d’une diode électroluminescente (led).

Il est nécessaire:

• Arduino Uno ou équivalent.
• Une plaque d’essai ou breadboard.
• Deux fils.
• Une led.
• Une résistance de 220 Ohms.

Pour le schéma de ce projet nous allons connecter l’anode (+) au pin ou broche 9 (sortie PWM), et la cathode (-) on la reliera à la masse avec une résistance:

code:

int intensite = 0;
int croissance = 5;   //Peut être négatif (décroissance)
void setup(){
  pinMode(9, OUTPUT); // LED connectée au pin 9 (PWM)
}
void loop() {
  analogWrite(9, intensite);
  intensite = intensite + croissance;
  /* Inverser  */
  if (intensite == 0 || intensite == 255) {
    croissance = -croissance;
  }
  delay(40);  // attente
}

Nous avons créé deux variables: une, où on va garder la valeur de l’intensité, et une autre qu’ indiquera combien va s’accroître cette intensité à chaque tour.

Dans la fonction setup() on configure le pin 9 comme sortie avec l’instruction pinMode().

Et dans la boucle loop(), d’abord on va allumer la led avec la valeur de la variable intensité (initialement 0). Après, on ira intensifiant de 5 en 5 la variable. À un moment précis, cette variable sera de 255, c’est pour cela que nous avons programmer une instruction if() qu’inversera la valeur de la variable croissance dès quelle arrive à 255 ou 0. De cette façon, la valeur augmente, mais arrivée à 255, elle diminue à nouveau jusqu’au 0, ainsi cycliquement.

Modifier la luminosité d’une led à souhait à travers l’envoie de l’intensité.

Pour l’exemple suivant nous avons 3 led (rouge, verte, bleue) connectées, chaque une, à travers son régulateur de tension, à un pin PWM différent. L’idée est de modifier la luminosité envoyant l’ instruction par le biais du moniteur série. Notamment, si on veut éteindre la diode rouge, on devrait le faire avec l’instruction r0, et si on veut l’allumer, r255. Pour allumer la diode bleue à mi- intensité, on commanderait b125.

Il est nécessaire:

• Arduino Uno o équivalent.
• Une plaque d’essai ou breadboard.
• 3 fils.
• 3 led: rouge, verte, bleue.
• 3 résistances de 220 Ohms.

code:

char couleur;   // important que se soit du type char et non byte
byte lueur;

void setup() {
  Serial.begin(9600);
  pinMode(5, OUTPUT); // Pin configuré comme sortie
  pinMode(6, OUTPUT);
  pinMode(9, OUTPUT);
  analogWrite(5, 127); // on établit une lueur initial moyenne
  analogWrite(6, 127);
  analogWrite(9, 127);
}
void loop () {
  // on lit la première lettre reçue par le canal série
  if (Serial.available()>0) {
    couleur=Serial.read();
    if( couleur == 'r' || couleur == 'g' || couleur == 'b' ) {
      delay(5);
      // on tire le numéro qui suit à la première lettre
      lueur=byte(Serial.parseInt());
      if(couleur == 'r') {
        analogWrite(5, lueur);
      }else if(couleur == 'g'){
        analogWrite(6, lueur);
      }else if(couleur == 'b'){
        analogWrite(9, lueur);
      }
    }
  }
  delay(100); // on attend pour recevoir les données série correctement
}

Pour changer l’intensité des diodes on indique la première lettre de la couleur (r, g, b) et, comme deuxième paramètre, on choisit une valeur entre 0 et 255.

Pour simplifier au moment d’introduire les données, on peut garder le même circuit changeant le code: c’est possible de modifier l’intensité en écrivant les trois valeurs de lueur séparées avec des virgules (r, g, b), disons (100, 50, 200).

byte lueurRouge, lueurVerte, lueurBleue;

void setup() {
  Serial.begin(9600);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(9, OUTPUT);
  analogWrite(5, 127);
  analogWrite(6, 127);
  analogWrite(9, 127);
}
void loop () {
  //on lit toutes les lettres reçues par le canal série
  while (Serial.available()>0) {
    //on cherche le suivant nombre entier valide dans les données entrantes
    lueurRouge = Serial.parseInt();
    //on recherche à nouveau
    lueurVerte = Serial.parseInt();
    //on recherche
    lueurBleue = Serial.parseInt();
    //on attend le caractère de nouvelle ligne: marque la fin
    if (Serial.read() == '\n') {
      //on limite les valeurs lues dans l’intervalle 0-255, au cas où
      lueurRouge = constrain(lueurRouge, 0, 255);
      lueurVerte = constrain(lueurVerte, 0, 255);
      lueurBleue = constrain(lueurBleue, 0, 255);
      //on illumine les diodes convenablement
      analogWrite(5, lueurRouge);
      analogWrite(6, lueurVerte);
      analogWrite(9, lueurBleue);
    }
  }
}

Mélange de couleurs. Led RBG.

On va essayer le fonctionnement de la diode led RBG d’anode commune avec 4 broches F5 5MM et le module RBG KY-016 à trois couleurs et résistances intégrées.

Il est nécessaire:

• Arduino Uno ou équivalent.
• Une plaque d’essai ou breadboard.
• 4 fils.
• Une led RBG d’anode commune 4 pin F5.
• 3 résistances de 220 Ohms.

Dans ce schéma on peut voir comment chaque branche de couleur est connectée à une sortie PWM via une résistance de 220 Ohms. La branche bleue est reliée au pin 11, la rouge est reliée au 10, et la verte se connecte au pin 9. L’anode commune est liée à la masse.

Code:

int LedVerte = 9;
int LedRouge = 10;
int LedBleue = 11;

void setup() {
  pinMode(LedRouge, OUTPUT);
  pinMode(LedVerte, OUTPUT);
  pinMode(LedBleue, OUTPUT);
}

void loop() {
  // Rouge
  analogWrite(LedRouge, 255);
  analogWrite(LedVerte, 0);
  analogWrite(LedBleue, 0);
  delay(2000);
  // Verte
  analogWrite(LedRouge, 0);
  analogWrite(LedVerte, 255);
  analogWrite(LedBleue, 0);
  delay(2000);
  // Bleue
  analogWrite(LedRouge, 0);
  analogWrite(LedVerte, 0);
  analogWrite(LedBleue, 255);
  delay(2000);
}

Maintenant, nous allons essayer le module RGB KY-016 à trois couleurs. Souvenez-vous que ce module incorpore les résistances nécessaires.

Il est nécessaire:

• Arduino Uno ou équivalent.
• Une plaque d’essai ou breadboard.
• 4 fils.
• Un module led RBG KY-016 trois couleurs et résistances.

Code:

const int PinLedRouge = 9;
const int PinLedVerte = 10;
const int PinLedBleue = 11;
 
void setup() 
{
  Serial.begin(9600);    
  pinMode(PinLedVerte, OUTPUT);
  pinMode(PinLedRouge, OUTPUT);
  pinMode(PinLedBleue, OUTPUT);
}
 
void loop() {
  // Verte
  Serial.println("Verte!");
  digitalWrite(PinLedRouge, LOW);
  digitalWrite(PinLedVerte, HIGH);
  digitalWrite(PinLedBleue, LOW);
  delay(500);
  // Rouge
  Serial.println("Rouge!");
  digitalWrite(PinLedRouge, HIGH);
  digitalWrite(PinLedVerte, LOW);
  digitalWrite(PinLedBleue, LOW);
  delay(500);
  // Bleue
  Serial.println("Bleue!");
  digitalWrite(PinLedRouge, LOW);
  digitalWrite(PinLedVerte, LOW);
  digitalWrite(PinLedBleue, HIGH);
  delay(500);
}

« Précédent

Module Led RBG.

Suivant »

Joystick à deux axes pour Arduino.

Articles similaires

Écran LCD 1602 illumination verte compatible avec Arduino.

Module horloge pour Arduino DS1302, (RTC) Real-Time-Clock.

Faire une horloge avec Arduino, le module DS3231 et l’écran LCD.