Contrôler une LED RGB – Arduino

Une led RGB contient en fait trois Leds ; une rouge, une verte et une bleue. En modulant l’intensité lumineuse de chaque couleur, on peut obtenir toutes les couleurs possibles.

Une commande PWM pour chaque LED permet ainsi de mélanger les trois couleurs (rouge, verte et bleu) avec des intensités différentes.

Un nuancier est disponible sur le site : https://lehollandaisvolant.net/tout/tools/color/.

Nous pouvons obtenir la couleur en fonction des trois rapports cycliques.

Attention, certaines cartes de LED RGB intègrent déjà les résistances de limitation de courant. Il n’est donc pas nécessaire de les ajouter sur votre breadboard. Il faudra également faire attention au câblage indiquée sur cette carte (les interfaces risquent de ne pas être dans le même ordre que dans le schéma de câblage suivant) !!

Ce programme permet d’afficher une couleur rouge, une couleur verte, puis une couleur bleu. Il est donc possible d’obtenir plus de nuance en faisant varier les sorties PWM de la commande analogWrite entre 0 et 255.

// Définition des broches utilisées
int Rouge = 11;    // R sur broche 11
int Vert = 9; // V sur la broche 9
int Bleu = 10; // B sur la broche 10

void setup()
    {
pinMode(Rouge, OUTPUT);
pinMode(Vert, OUTPUT);
pinMode(Bleu, OUTPUT);

    }
    
void loop()
    {
  
//Affichage de la couleur Rouge 
analogWrite(Rouge,255);    // Rouge 
analogWrite(Vert,0);    // Vert 
analogWrite(Bleu,0);    // Bleu

delay(1000);

//Affichage de la couleur verte 
analogWrite(Rouge,0);    // Rouge 
analogWrite(Vert,255);    // Vert 
analogWrite(Bleu,0);    // Bleu

delay(1000);

//Affichage de la couleur bleue 
analogWrite(Rouge,0);    // Rouge 
analogWrite(Vert,0);    // Vert 
analogWrite(Bleu,255);    // Bleu

delay(1000);
}

Capteur Détecteur de Flamme KY-026 – Arduino

Le capteur de flamme KY-026 est un capteur qui permet de mesurer des longueurs d’onde sur une plage comprise entre 760 nm et 1100 nm. Ce capteur réagira donc en présence d’une flamme.

Caractéristiques :
– Extrêmement sensible aux longueurs d’ondes entre 760-1100nm
– Seuil de détection de flamme modifiable par un potentiomètre
– Plage d’angle de détection: environ 60 degrés
– Alimentation: 3.3-5.5 VDC

// Définition des broches utilisées
int Led = 1 ;// LED
int capt_num = 3; // Interface Capteur Flamme
int capt_ana = A3; //  Interface Capteur Flamme
 
int val ;
float capteur_flamme; 
 
void setup ()
{
  pinMode(Led, OUTPUT);// Définir l'interface de la LED en sortie
  pinMode(capt_num, INPUT);// Définir l'interface du capteur de flamme en entrée
  pinMode(capt_ana, INPUT);// Définir l'interface du capteur de flamme en entrée
  Serial.begin(9600);
}
 
void loop ()
{
  capteur_flamme = analogRead(capt_ana);
  
  Serial.println(capteur_flamme);  
   
  val = digitalRead (capt_num) ;
    if (val == HIGH) // Quand le capteur détecte une flamme, la led s'allume
  {
    digitalWrite (Led, HIGH);
    Serial.println("Flamme");  
  }
  else
  {
    digitalWrite (Led, LOW);
    Serial.println("Pas de flamme");
  }
  delay(2000);
}

Capteur de tempétature TMP36 – Arduino

Afin de récupérer une température avec un Arduino, nous pouvons utiliser un capteur TMP36.

Ce capteur doit-être alimenté entre 2.7 et 5.5V, et consomme moins de 50µA en fonctionnement, et 0.5µA en veille

Attention au branchement de ce capteur. S’il est branché dans le mauvais sens, il risque de chauffer très vite et à de hautes températures. Vous risquez une brûlure si vous entrez en contact avec lui !

Le document constructeur est disponible ici : datasheet

Caractéristiques :
– Taille: boitier TO-92 à 3 broches (similaire à un transistor)
– Gamme de température: -40°C a 150°C / -40°F a 302°F
– Tension de sortie: 0.1V (-40°C) to 2.0V (150°C) mais la précision diminue après 125°C
– Tension d’alimentation: 2.7V a 5.5V

//définition des broches utilisées
int capteur_temp = 0; 
 
void setup()
{
  Serial.begin(9600);  
}

void loop()                   
{

// Lecture de l'entrée analogique
 int reading = analogRead(capteur_temp);  
 
// Conversion de la lecture d'entrée en tension
 float volt = reading * 5.0;
 volt = volt / 1024.0; 
 
 // Afficher la tension d'entrée
 Serial.print(volt); Serial.println(" volts");
 
 // Afficher la température
 float temperature = (volt - 0.5) * 100 ;  // Convertir la tension en temperature
                                               
 Serial.print(temperature); 
Serial.println(" degrees C");
 
 delay(1000);                                   
}

Capteur à Ultrason HC-SR04 – Raspberry Pi

Les informations sur les caractéristiques du capteur sont disponibles ici.

Le signal de sortie du capteur (ECHO) sur le HC-SR04 est de à 5V. Cependant, nous pouvons envoyer sur la broche d’entrée sur du GPIO Raspberry Pi 3,3V.

En envoyant un signal 5V dans ce port d’entrée de 3,3 V non protégé, on pourrait endommager les broches GPIO.
Nous aurons besoin d’utiliser un diviseur de tension, composé de deux résistances, pour abaisser la tension de sortie du capteur à une tension que le Raspberry Pi peut manipuler.

Schéma de câblage :

# Importer les librairies 
import time
import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BCM)

# Definir les ports GPIO
GPIO_TRIGGER = 23
GPIO_ECHO = 24

# Definir les ports GPIO en entrée et Sortie
GPIO.setup(GPIO_TRIGGER,GPIO.OUT)  # Trigger
GPIO.setup(GPIO_ECHO,GPIO.IN)      # Echo

GPIO.output(GPIO_TRIGGER, False)
time.sleep(0.5)

# Envoyer une impulsion de 10us sur le Trigger
GPIO.output(GPIO_TRIGGER, True)
time.sleep(0.00001)
GPIO.output(GPIO_TRIGGER, False)
start = time.time()
while GPIO.input(GPIO_ECHO)==0:
  start = time.time()

while GPIO.input(GPIO_ECHO)==1:
  stop = time.time()

# Calculer la longueur de la pulsation
elapsed = stop-start

distance = elapsed * 34000
distance = distance / 2

print "Distance : %.1f" % distance

# Reset GPIO
GPIO.cleanup()

Capteur à Ultrason HC-SR04 – Arduino

Un capteur ultrason envoie un son puis mesure le temps que l’echo va mettre à revenir.

Le capteur HC-SR04 utilise les ultrasons pour déterminer la distance d’un objet. Il offre une excellente plage de détection sans contact, avec des mesures de haute précision et stables. Son fonctionnement n’est pas influencé par la lumière du soleil ou des matériaux sombres, bien que des matériaux comme les vêtements puissent être difficiles à détecter.

Caractéristiques :

– Dimensions : 45 mm x 20 mm x 15 mm

– Plage de mesure : 2 cm à 400 cm

– Résolution de la mesure : 0.3 cm

– Angle de mesure efficace : 15 °

– Largeur d’impulsion sur l’entrée de déclenchement : 10 μs (Trigger Input Pulse width)

Nous savons que le son se déplace à une vitesse v = 330m.s-1
Le son met donc 3 secondes pour se déplacer sur 1km et il faut à peu près 3 millisecondes au son pour parcourir 1 mètre :

// définition des broches utilisées
int trig = 8;
int echo = 7;
float lecture_echo;
float cm;

void setup()
{
pinMode(trig, OUTPUT);
digitalWrite(trig, LOW);
pinMode(echo, INPUT);
Serial.begin(9600);
}

void loop()
{
digitalWrite(trig, HIGH);
delayMicroseconds(10);
digitalWrite(trig, LOW);
lecture_echo = pulseIn(echo, HIGH);
cm = lecture_echo / 58;
Serial.print("Distance : ");
Serial.println(cm);
delay(1000);
}

HC-SR04