Catégorie : Arduino

Faire varier l’intensité lumineuse d’une LED – Arduino

Afin de faire varier l’intensité lumineuse d’une LED, nous allons utiliser une sortie PWM.

PWM (Pulse-Width Modulation) signifie « Modulation de largeur d’impulsion ».

Si on donne la valeur 255 sur l’interface de la LED, celle-ci reçoit en continue une tension de 5V.
Si on diminue cette valeur, l’Arduino génère un signal carré.

Sur une période, la tension va rester un certain temps à 5V, puis redescendre à 0V. Plus on diminue cette valeur, plus le temps entre 2 états « haut » sera long…

Plus la valeur diminue, moins la LED serra alimentée. L’oeil a ainsi l’illusion que l’intensité de la LED diminue ou augmente avec le temps.

Sur l’Arduino, les interfaces permettant de faire du PWM sont les 3,5, 6, 9, 10 et 11 (celle avec le signe ~).

// Définition des broches et variables utilisées
int LED = 3;
// Rapport cyclique
int x; 

void setup() {
   pinMode(LED, OUTPUT);
}

void loop() {
  x = 0;

  // Allumer progressivement la LED (0 --> 255)
  while (x <= 255) {
    analogWrite(LED, x);
    delay(10);
    x = x + 1;
  }

  // Eteindre progressivement la LED (255 --> 0)
  x = 255;
  while (x >= 0) {   

    analogWrite(LED, x);
    delay(10);
    x = x - 1;
  }
  
}

Varier l'intensité d'une LED

Créer un compteur de passage avec un capteur ultrason HC-SR04 – Arduino

Il est assez simple de créer un compteur de passage afin d’enregistrer le nombre de personnes qui entre dans une pièce.

Nous pouvons utiliser un capteur ultrason HC-SR04. Lorsqu’une personne passera devant le capteur, celui-ci prendra la mesure de la distance entre lui et cette personne. Si la distance est inférieure à 10 cm, nous considérons qu’une personne a franchi la porte, et nous incrémentons ainsi le compteur.

Un interrupteur est branché à l’Arduino. Celui-ci permet de réinitialiser le compteur à 0. La LED permet d’indiquer qu’une personne a été détecté devant la porte.

// définition des broches et variables utilisées
int trig = 3;
int echo = 2;
int interrupteur = 7;
int led = 8;
int lecture_echo;
int distance;
int compteur = 0;
int a;


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

void loop()
{
  digitalWrite(trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig, LOW);
  lecture_echo = pulseIn(echo, HIGH);

  // La doc constructeur dit que si pn veut une distance en cm, il faut diviser l'echo par 58
  distance = lecture_echo / 58;

  // Il est possible d'afficher la distance en cm. Décommenter les lignes du dessous.
  //  Serial.print("Distance en cm : ");
  //  Serial.println(distance);

 // Si l'interrupteur est à 1, le compteur se remet à 0
  if (interrupteur = HIGH) {
    compteur = 0;
   }
  else {
    if (distance > 10) {
      a = 0;
    }
    if (distance < 10 && a == 0) {
      compteur = compteur + 1;
      a = 1;
      Serial.print("Compteur : ");
      Serial.println(compteur);
    }
    if (distance < 10) {
      digitalWrite(led, HIGH);
      delay(100);
      digitalWrite(led, LOW);
      delay(100);
    }
  }

}

Compteur - HC-RS04

Module RFID RC522 – Arduino

Ce page est obsolète… Se rendre ici pour la mise à jour : https://mataucarre.fr/index.php/2022/03/03/arduino-et-module-rfid-rc522-gerer-plusieurs-cartes/

Le Module RFID-RC522 est module RFID utilisé pour lecture/écriture sans contact d’un tag. Le lecteur utilise une communication SPI.

RFID est l’abréviation de Radio Frequency IDentification. Les modules RFID utilisent des champs électromagnétiques pour transférer des données entre la carte et le lecteur. Différents tags sont attachés à des objets (carte, porte clé…) et lorsque nous plaçons cet objet en face du lecteur, le lecteur lit ces balises.

Un avantage du RFID est qu’il n’a pas besoin d’être dans une ligne de mire pour être détecté.

Les Tags possèdent une antenne associée à une puce électronique qui leur permet de recevoir et de répondre aux requêtes radio émises depuis l’émetteur-récepteur.
Ils contiennent un identifiant individuel (standard Epc-96 sur 96 bits). Leur fonctionnement est passif (sans source d’énergie, donc c’est autonome et inusable).

RFID – RC522	Arduino Leonardo
VCC	3,3V
RST/Reset	ICSP 5
GND	ICSP 6
IRQ	/
MISO	ICSP 1
MOSI	ICSP 4
SCK	ICSP 3
SDA	Interface 10

Il faut télécharger les librairies suivantes et les installer dans le dossier librairies de votre dossier Arduino : Librairies RFID et SPI

Vous trouverez ensuite deux codes :
– Le premier permet de récupérer le numéro d’un TAG RFID
– Le second permet de vérifier si le TAG est correct (un numéro de TAG est en mémoire dans le programme).

#include <SPI.h>
#include <RFID.h>

RFID RFID(10,9); //RFID(SPI PIN, RST PIN)

int UID[5];

void setup()
{
  Serial.begin(9600);
  SPI.begin();
  RFID.init();  

}

void loop()
{
    if (RFID.isCard()) {  //Si une carte est présente près du lecteur
          if (RFID.readCardSerial()) {  // Si cette carte possède un numéro de série     
            Serial.print("L'UID est: ");
            for(int i=0;i<=4;i++)
            {
              UID[i]=RFID.serNum[i];
              Serial.print(UID[i],DEC);
              Serial.print(".");
            }
            Serial.println("");
          }          
          RFID.halt();
    }
    delay(100);    
}

Lecture d'un TAG RFID

#include <SPI.h>
#include <RFID.h>

RFID RFID(10,9);

int UID[5]={};
int IDCarte[5]={1,100,52,75,209}; // UID du badge ou de la carte acceptée sous forme de tableau (Array).
bool statut = 1;

void setup()
{
  Serial.begin(9600);
  SPI.begin();
  RFID.init();

}

void loop()
{
    
            
            for(int i=0;i<=4;i++)
            {
              UID[i]=RFID.serNum[i];

            }
          
          if (UID[0] == IDCarte[0]   // Si l'UID 0  est égale à 1
           && UID[1] == IDCarte[1]   // Et si l'UID 1  est égale à 100
           && UID[2] == IDCarte[2]   // Et si l'UID 1  est égale à 52
           && UID[3] == IDCarte[3]   // Et si l'UID 1  est égale à 75
           && UID[4] == IDCarte[4])  // Et si l'UID 1  est égale à 209
            {
              Serial.print("Bonne carte");}
            
            else
            {
             Serial.print("Mauvaise carte");
             
            }
            
          RFID.halt();
          delay(100);    

}

Comparer un numéro de carte, avec un autre en mémoire

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);
}