Nous vous remercions d’avoir choisi notre livre pour faire vos premiers pas dans le monde de l’électronique.

 

Sur cette page, vous trouverez toutes les ressources indispensables pour réaliser les projets présentés dans l’ouvrage :

  • Schémas électroniques

  • Programmes Arduino

  • Bibliothèques à télécharger

Choix d’un kit Arduino

Lorsque l’on débute avec Arduino, il n’est pas toujours facile de savoir quels composants ajouter à la carte pour créer ses propres circuits. C’est pourquoi des kits pour débutants ont été conçus, afin de fournir tous les éléments essentiels pour bien commencer.

Nous vous proposons ici deux kits populaires : le kit officiel Arduino et un kit Elegoo.

Le kit officiel Arduino vous permet de commencer avec une carte Arduino UNO R3 authentique. Ce kit contient plus d’une centaine de composants, vous offrant tout ce dont vous avez besoin pour réaliser vos propres projets électroniques. 

Le kit officiel Arduino est disponible pour environ 95 euros sur Amazon.

 

Le kit Elegoo est livré avec une carte ELEGOO UNO R3, qui est une version compatible avec l’Arduino UNO R3. Le kit Elegoo comprend également une large gamme de composants électroniques, tels que des résistances, des condensateurs, des diodes, des transistors et des boutons-poussoirs.

Son prix est actuellement de 70 euros. Vous pouvez le retrouvez sur Amazon.

Arduino IDE

L’Environnement de Développement Intégré Arduino est un logiciel conçu pour faciliter la communication entre votre carte Arduino et votre programme. Il intègre un compilateur qui traduit le code source en langage machine, afin que la carte puisse l’exécuter.


Basé sur le logiciel Processing, l’Arduino IDE est un outil open source, ce qui signifie qu’il est libre d’utilisation et de modification. De plus, bien qu’il soit principalement conçu pour les cartes Arduino, il peut également être utilisé pour programmer d’autres types de cartes.

Vous pouvez télécharger le logiciel Arduino IDE directement depuis le site officiel d’Arduino à l’adresse suivante : https://www.arduino.cc/en/software.

Il est disponible pour les systèmes d’exploitation Windows, Mac et Linux, et est entièrement open source.

Votre premier circuit : Allumer une LED

C’est l’heure de faire vos premiers pas avec votre Arduino ! Dans ce premier projet, nous allons explorer un concept fondamental de l’électronique : allumer une LED. Ce sera l’occasion idéale de découvrir les entrées et sorties de votre carte Arduino.

Pour réaliser ce circuit, nous allons connecter une LED aux bornes +3.3V et GND de l’Arduino. Vous aurez besoin de deux fils de connexion et d’une résistance de 220Ω. Tous ces composants sont disponibles dans les kits que nous vous avons présentés précédemment.

int led_Broche = 11;  // On assigne la LED à la broche 11.

void setup() {
    pinMode(led_Broche, OUTPUT); // On assigne la LED en sortie
}

void loop() {
   digitalWrite(led_Broche,HIGH); // On allume la LED
   delay(1000); // On fait une pause pour voir la LED allumée avant de l'éteindre
   digitalWrite(led_Broche,LOW); // On éteint la LED
   delay(1000); 
}

Dans ce programme, la LED s’allume pendant 1 seconde, puis s’éteint pendant le même intervalle de temps. Vous pouvez télécharger ce programme depuis notre drive.

Matrice de LED sur Arduino UNO R4 Wifi

La matrice de LED intégrée à la carte Arduino Uno R4 WiFi est une fonctionnalité innovante qui permet d’afficher des informations directement sur la carte. Composée d’une grille de 12×8 LEDs, cette matrice offre une manière simple et efficace de visualiser des textes, des chiffres ou des graphiques simples.

Dans ce chapitre, nous allons apprendre à afficher deux emojis : un smiley et un coeur :

Voici le code à télécharger sur votre Arduino pour afficher les deux emojis, un toutes les 0,5 seconde :

#include "Arduino_LED_Matrix.h"

ArduinoLEDMatrix matrix;

void setup() {
  Serial.begin(115200);
  matrix.begin();
}

const uint32_t happy[] = {
    0x19819,
    0x80000001,
    0x81f8000
};
const uint32_t heart[] = {
    0x3184a444,
    0x44042081,
    0x100a0040
};
  
void loop(){
  matrix.loadFrame(happy);
  delay(500);

  matrix.loadFrame(heart);
  delay(500);
}

Vous pouvez retrouver ce programme sur notre espace partagé.

Bouton poussoir

Le bouton poussoir est un interrupteur électrique qui revient automatiquement à sa position initiale après avoir été pressé. Il est largement utilisé dans la vie quotidienne, par exemple pour appeler un ascenseur ou pour les touches du clavier de votre ordinateur.

Dans un circuit Arduino, un bouton poussoir permet d’ajouter une interaction avec l’utilisateur. Dans ce premier circuit, nous allons apprendre comment lire les états d’un bouton poussoir à partir de la carte Arduino.

Voici le circuit à réaliser pour pouvoir lire les valeurs du bouton poussoir :

Comme vous pouvez voir sur le schéma nous avons ajouté une résistance de pull-down de 10 kilo-ohms (couleur orange noir marron) afin que le signal soit bien à 0V lorsque l’on n’appuie pas sur le bouton poussoir.

Voici le programme pour lire la valeur du bouton poussoir sur Arduino IDE :

const int pin_INTERRUPTEUR = 2; // L’interrupteur est attaché au pin 2 
 
void setup() { 
    // Initialisation de la communication avec le moniteur série 
    Serial.begin(9600);  
    pinMode(pin_INTERRUPTEUR,INPUT); 
} 
 
void loop() { 
    delay(1000); // Attente de 1000 ms 
    // Récupère l’état du bouton 
    boolean etatBouton = digitalRead(pin_INTERRUPTEUR); 
    Serial.print("Valeur bouton poussoir :");
    Serial.println(etatBouton); // Affiche l’état du bouton sur le moniteur 
}

Capteur de distance

capteur ultrason

Le capteur de distance, aussi appelé capteur à ultrasons, permet de mesurer des distances avec une grande précision. Il peut estimer des distances allant de 2 cm à 400 cm, avec une précision de 3 mm.

C’est l’un des capteurs les plus utilisés et les plus économiques. Vous pouvez l’utiliser pour diverses applications, telles que la navigation d’un robot, la création d’un radar de recul pour voiture, et bien d’autres projets.

Pour mesurer la distance, le capteur à ultrasons émet un signal via la borne Trigger (Trig), qui est ensuite réfléchi par un objet et capté par la borne Echo. Le temps écoulé entre l’émission du signal et sa réception par la borne Echo permet de calculer la distance entre le capteur et l’objet.

 

Voici le schéma du circuit pour connecter le capteur de distance à la carte Arduino Uno :

Voici un programme permettant de mesurer la distance à l’aide du capteur de distance :

// Définition des pins
const int trigPin = 2;  // Pin de Trigger
const int echoPin = 3; // Pin d'Echo

void setup() {
  // Initialisation des pins
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  
  // Initialisation de la communication série
  Serial.begin(9600);
}

void loop() {
  // Envoi d'un signal de déclenchement de 10 microsecondes
  digitalWrite(trigPin, LOW);  
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH); // Envoyer une impulsion
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);  // Terminer l'impulsion

  // Lecture de la durée de l'écho
  long duration = pulseIn(echoPin, HIGH);

  // Calcul de la distance (vitesse du son = 343 m/s, soit 0.034 cm/us)
  // Divisé par 2 car l'impulsion fait un aller-retour
  long distance = (duration / 2) * 0.0343; 

  // Affichage de la distance dans le moniteur série
  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println(" cm");

  delay(500);  // Délai avant la prochaine mesure
}

Buzzer

Les buzzers produisent des sons grâce à une lame qui vibre sous l’effet piézoélectrique. Avec une carte Arduino, il est facile de contrôler un buzzer pour générer des bips, des mélodies ou des alertes sonores, selon vos besoins. Les buzzers sont couramment utilisés dans des dispositifs d’alarme, des ordinateurs, des minuteries, et bien d’autres applications.

Il existe deux types principaux de buzzers : les buzzers actifs et les buzzers passifs.

  • Buzzer Actif : Ce type de buzzer possède un oscillateur intégré, ce qui lui permet de produire un son dès qu’il est alimenté. Il ne nécessite pas de signal de commande complexe et peut être directement alimenté par une sortie numérique de l’Arduino.
  • Buzzer Passif : Contrairement au buzzer actif, le buzzer passif nécessite un signal d’entrée pour émettre un son. En utilisant une sortie PWM (modulation de largeur d’impulsion) de l’Arduino, vous pouvez contrôler la fréquence et la durée du son.

Pour faire fonctionner le programme, vous devez d’abord installer la librairie dédiée au buzzer. Cette librairie contient toutes les notes que le composant peut jouer.

#include "pitches.h" // La librairie pour le buzzer passif
// notes de la melodie
int melodie[] = {NOTE_C5, NOTE_D5, NOTE_E5, NOTE_F5, NOTE_G5, NOTE_A5, NOTE_B5, NOTE_C6}; // Voici des notes déjà incluses dans la librairie
int duree = 500;  // durée de chaque melodie 
 
void setup() { }

void loop() { 
// Pour toute les notes de la liste melodie 
  for (int thisNote = 0; thisNote < 8; thisNote++) { 
    tone(8, melodie[thisNote], duree); // On joue la note avec la duree choisit
    delay(1000); // Nouveau son après 1 seconde de pause
  }
  delay(2000); }

Ecran LCD

L’écran à cristaux liquides LCD 16×2 est l’un des dispositifs les plus couramment utilisés sur Arduino pour afficher des informations. Il est équipé d’un rétroéclairage LED et peut afficher deux lignes de 16 caractères. 

Chaque caractère est constitué d’un rectangle de pixels, et il est possible de contrôler chaque pixel individuellement pour créer des caractères personnalisés.

 

Pour utiliser l’écran LCD, vous devez installer la librairie LiquidCrystal.zip. Cette librairie contient un ensemble de fonctions qui simplifient l’écriture de votre code et l’utilisation de l’écran 16×2.

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup()
{
 lcd.begin(16, 2); 
}

void loop()
{
  lcd.setCursor(0,0);          
  lcd.print("Arduino Factory");    
  }

Projet : Radar de distance sur Arduino

L’objectif de ce projet est de créer un radar de recul pour votre véhicule, permettant de mesurer la distance entre votre voiture et un objet situé derrière vous lors du stationnement. Cette distance sera affichée en centimètres sur un écran LCD, et un buzzer émettra un son d’alerte si vous vous approchez trop près de l’objet.

Voici le matériel nécessaire pour réaliser ce projet :

  • Une carte Arduino Uno
  • Un écran LCD 16×2 à cristaux liquides (Liquid Crystal)
  • Un potentiomètre
  • Une résistance de 220Ω
  • Un capteur de distance (HC-SR04)
  • Un buzzer
  • Une quinzaine de fils de connexion

Dans le programme, la distance maximale à partir de laquelle le buzzer commence à sonner est de 15 centimètres. Vous pouvez bien sûr modifier cette valeur en fonction de vos préférences, par exemple, pour ajuster la distance d’alerte selon vos besoins :

#include <LiquidCrystal.h> //libraire pour l'écran LCD
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

int buzzer_pin = 6; // pin du buzzer
int cm = 0; // On initialise la valeur à 0

//fonction pour avoir la distance venant du capteur de distance
long readUltrasonicDistance(int triggerPin, int echoPin) {
    pinMode(triggerPin, OUTPUT);  
    digitalWrite(triggerPin, LOW);
    delayMicroseconds(2);
    digitalWrite(triggerPin, HIGH);
    delayMicroseconds(10);
    digitalWrite(triggerPin, LOW);
    pinMode(echoPin, INPUT);
    return pulseIn(echoPin, HIGH);
}
void setup() {
    lcd.begin(16, 2); // On initialise l'écran  
    pinMode(buzzer_pin, OUTPUT); //on met le buzzer en sortie
}

void loop() {
    // On écrit la distance sur l'écran LCD
    lcd.print("Distance: ");
    lcd.print(cm);
    lcd.print(" cm");
    delay(10);

    cm = 0.01723 * readUltrasonicDistance(10, 13); // On convertie la valeur en centimètre
    delay(100); 

    if (cm < 15){ // Si la voiture est à moins de 15 cm de l'objet on fait sonner le buzzer
        tone(buzzer_pin, 1000, 1000);
    }
    lcd.clear(); // On efface ce qui est écrit sur l'écran LCD
} 

Vous pouvez retrouver notre programme sur notre espace partagé.

Potentiometre

Un potentiomètre est une résistance à trois bornes, équipée d’un contact rotatif et d’un contact coulissant, formant ainsi un diviseur de tension. Il est constitué d’une résistance variable, dont la valeur change en fonction de la rotation du bouton, permettant de moduler la tension en conséquence.

Le potentiomètre est couramment utilisé dans des applications telles que les radiateurs, où il sert de rhéostat, ou encore dans les systèmes audios, pour ajuster le volume des haut-parleurs.

int Potentiometre; // Variable pour le composant potentiomètre 

void setup() {
  Serial.begin(9600); //Initialisation du moniteur série
  Serial.println("Voici la valeur du potentiometre :");
}

void loop() {
  Potentiometre = analogRead(A0); // On lit la valeur du potentiomètre
  Potentiometre=map(Potentiometre,0,1023,0,5); // Lit la valeur entre 0V et 5V.
  Serial.print("tension : ");
  Serial.println(Potentiometre);  // On affiche cette valeur
  delay(200); // Pause entre chaque valeur.
}

Module d'horloge

 

Le second composant indispensable à notre projet de réveil sur Arduino est le module d’horloge, qui permet de maintenir l’heure exacte, même lorsque le réveil est éteint.

La gestion du temps constitue un élément fondamental dans de nombreux projets Arduino, qu’il s’agisse de concevoir un réveil, un enregistreur de données ou tout autre dispositif nécessitant une synchronisation temporelle précise. 

Une fois la bibliothèque RTClib installée, vous pouvez procéder au téléversement du programme sur la carte Arduino :

#include "RTClib.h"
RTC_DS1307 rtc;
 
void setup () {
  Serial.begin(9600);

  while (! rtc.begin()) {
    Serial.println("Attente du module RTC...");
    delay(1000);
  }
  rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

}
 
void loop () {
    DateTime now = rtc.now();
    char heure[10];
    Serial.print("Horloge du module RTC : ");
    sprintf(heure, "%02d:%02d:%02d", now.hour(), now.minute(), now.second());
    Serial.println(heure);
     
    delay(1000);
}

Si vous souhaitez modifier la date et l’heure affichées par votre module RTC, on vous propose un programme permettant de le faire.

Projet Horloge

Nous allons maintenant concevoir une horloge sur Arduino. À l’aide d’un potentiomètre, vous pourrez ajuster facilement la luminosité de votre horloge. Ceci va vous permettre de pouvoir dormir sans lumière pendant la nuit et d’augmenter la luminosité lors de journée ensoleillée.

#include "RTClib.h"
#include <LiquidCrystal.h>

// Initialisation de l'écran LCD (broches RS, E, D4, D5, D6, D7)
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
RTC_DS1307 rtc;

void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2); // Initialisation de l'écran LCD : 16 colonnes, 2 lignes

  // Vérification de la connexion avec le module RTC
  while (!rtc.begin()) {
    Serial.println("Attente du module RTC...");
    delay(1000);
  }

  // Mise à l'heure du module RTC à la date/heure de compilation
  rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
}

void loop() {
  DateTime now = rtc.now();

  // Afficher la date sur la première ligne (format : DD/MM/YYYY)
  char date[11];
  sprintf(date, "%02d/%02d/%04d", now.day(), now.month(), now.year());
  lcd.setCursor(0, 0); // Positionner le curseur en haut à gauche
  lcd.print(date);

  // Afficher l'heure sur la deuxième ligne (format : HH:MM:SS)
  char heure[9];
  sprintf(heure, "%02d:%02d:%02d", now.hour(), now.minute(), now.second());
  lcd.setCursor(0, 1); // Positionner le curseur en bas à gauche
  lcd.print(heure);

  // Debug dans le moniteur série
  Serial.print("Date : ");
  Serial.println(date);
  Serial.print("Heure : ");
  Serial.println(heure);

  delay(1000); // Mise à jour toutes les secondes
}

Le programme de ce projet est disponible sur notre drive.

Capteur DHT11

Le DHT11, également connu sous le nom de “Digital Température Humidité 11”,
est un capteur qui fournit un signal numérique en sortie, codant les mesures en
temps réel de la température et de l’humidité.
Sa facilité de programmation et sa faible consommation d’énergie en font le
choix idéal pour notre projet de station météo.

Dans cet exemple, nous allons apprendre à afficher la température et l’humidité sur le moniteur série.
Assurez-vous d’avoir préalablement installé la bibliothèque du capteur de température pour faire
fonctionner le programme. 

Pour faire fonctionner le capteur DHT11, voici le programme qui affiche la température et l’humidité sur
le moniteur série dans Arduino IDE. Pour téléverser le programme sur votre carte, ouvrez Arduino IDE
puis copiez le code ci-dessous :

#include "DHT.h"

// Définition du type de capteur et de la broche de connexion
#define DHTPIN 2     // Broche connectée au DHT11
#define DHTTYPE DHT11 // Type de capteur : DHT11
DHT dht(DHTPIN, DHTTYPE); // Initialisation du capteur

void setup() {
  Serial.begin(9600); // Initialisation de la communication série
  Serial.println("Initialisation du capteur DHT11...");  
  dht.begin(); // Démarrer le capteur
}

void loop() {
  // Lecture de l'humidité
  float humidite = dht.readHumidity();

  // Lecture de la température en Celsius
  float temperature = dht.readTemperature();

  // Vérification d'erreurs dans la lecture
  if (isnan(humidite) || isnan(temperature)) {
    Serial.println("Erreur de lecture du capteur DHT11 !");
    return;
  }

  // Affichage des valeurs lues
  Serial.print("Humidite : ");
  Serial.print(humidite);
  Serial.print(" %\t");
  Serial.print("Temperature : ");
  Serial.print(temperature);
  Serial.println(" °C");

  delay(2000); // Attendre 2 secondes avant la prochaine lecture
}

Vous pouvez retrouver notre programme sur l’espace partagé.

Capteur TMP36

Le capteur de température TMP36 est un capteur qui génère un signal digital en sortie codant
une valeur de température mesurée en temps réel.

Ce capteur ne peut pas mesurer l’humidité, ce qui en fait un capteur moins polyvalent que le
DHT11 présenté précédemment.

Voici le programme permettant de faire fonctionner le capteur TMP36. Comme vous pouvez le
constater, il n’est pas nécessaire d’utiliser une bibliothèque pour le faire fonctionner :

int Capteur = 0 ; // Broche A0 où est connecté le capteur de température
void setup() {
Serial.begin(9600); // Initialiser le moniteur série
} 
void loop () {
  int lecture = analogRead(Capteur); // Lire la valeur du capteur
  float voltage = 5.0 /1024 * lecture ; // Transformer cette valeur en tension
  float temperature = voltage * 100 -50 ; // Converti tension en degrée celsius
  Serial.print("La temperature est : "); // Afficher la température
  Serial.print (temperature);
  Serial.println(" degrees");
  delay(500); // Pause entre chaque mesure
}

Afficheur 7 segments

afficheur 7 segments

Pour pouvoir réaliser notre projet de station météo, nous allons aborder un autre type
d’afficheur que l’écran LCD, l’afficheur à 7 segments. Celui-ci est spécialement conçu
pour afficher des chiffres.

Bien que cela puisse être extrêmement utile pour notre projet
de station météo, il convient de noter que ce type d’afficheur ne conviendra pas à tous
les projets, notamment ceux nécessitant l’affichage de texte.

Afficheur 7 segments simples

Nous allons maintenant examiner comment afficher un chiffre sur un afficheur 7 segments à cathode
commune :

// Déclarer les pins où sont branchés chaque segment
const int segment_A = 2;
const int segment_B = 3;
const int segment_DP = 4;
const int segment_C = 5;
const int segment_D = 6;
const int segment_E = 7;
const int segment_G = 8;
const int segment_F = 9;

void setup(){
  // On declare les segments comme des sorties pour pouvoir les contrôler
  pinMode(segment_A, OUTPUT);
  pinMode(segment_B, OUTPUT);
  pinMode(segment_DP, OUTPUT);
  pinMode(segment_C, OUTPUT);
  pinMode(segment_D, OUTPUT);
  pinMode(segment_E, OUTPUT);
  pinMode(segment_G, OUTPUT);
  pinMode(segment_F, OUTPUT);
}

void loop() {
  //.
  digitalWrite(segment_A, LOW);
  digitalWrite(segment_B, LOW);
  digitalWrite(segment_DP, HIGH);
  digitalWrite(segment_C, LOW);
  digitalWrite(segment_D, LOW);
  digitalWrite(segment_E, LOW);
  digitalWrite(segment_G, LOW);
  digitalWrite(segment_F, LOW);
  delay(1000);
  
  //0
  digitalWrite(segment_A, HIGH);
  digitalWrite(segment_B, HIGH);
  digitalWrite(segment_DP, LOW);
  digitalWrite(segment_C, HIGH);
  digitalWrite(segment_D, HIGH);
  digitalWrite(segment_E, HIGH);
  digitalWrite(segment_G, LOW);
  digitalWrite(segment_F, HIGH);
  delay(1000);
  
  //1
  digitalWrite(segment_A, LOW);
  digitalWrite(segment_B, HIGH);
  digitalWrite(segment_DP, LOW);
  digitalWrite(segment_C, HIGH);
  digitalWrite(segment_D, LOW);
  digitalWrite(segment_E, LOW);
  digitalWrite(segment_G, LOW);
  digitalWrite(segment_F, LOW);
  delay(1000);
  
  //2
  digitalWrite(segment_A, HIGH);
  digitalWrite(segment_B, HIGH);
  digitalWrite(segment_DP, LOW);
  digitalWrite(segment_C, LOW);
  digitalWrite(segment_D, HIGH);
  digitalWrite(segment_E, HIGH);
  digitalWrite(segment_G, HIGH);
  digitalWrite(segment_F, LOW);
  delay(1000);
  
  //3
  digitalWrite(segment_A, HIGH);
  digitalWrite(segment_B, HIGH);
  digitalWrite(segment_DP, LOW);
  digitalWrite(segment_C, HIGH);
  digitalWrite(segment_D, HIGH);
  digitalWrite(segment_E, LOW);
  digitalWrite(segment_G, HIGH);
  digitalWrite(segment_F, LOW);
  delay(1000);
  
  //4
  digitalWrite(segment_A, LOW);
  digitalWrite(segment_B, HIGH);
  digitalWrite(segment_DP, LOW);
  digitalWrite(segment_C, HIGH);
  digitalWrite(segment_D, LOW);
  digitalWrite(segment_E, LOW);
  digitalWrite(segment_G, HIGH);
  digitalWrite(segment_F, HIGH);
  delay(1000);
  
  //5
  digitalWrite(segment_A, HIGH);
  digitalWrite(segment_B, LOW);
  digitalWrite(segment_DP, LOW);
  digitalWrite(segment_C, HIGH);
  digitalWrite(segment_D, HIGH);
  digitalWrite(segment_E, LOW);
  digitalWrite(segment_G, HIGH);
  digitalWrite(segment_F, HIGH);
  delay(1000);
  
  //6
  digitalWrite(segment_A, HIGH);
  digitalWrite(segment_B, LOW);
  digitalWrite(segment_DP, LOW);
  digitalWrite(segment_C, HIGH);
  digitalWrite(segment_D, HIGH);
  digitalWrite(segment_E, HIGH);
  digitalWrite(segment_G, HIGH);
  digitalWrite(segment_F, HIGH);
  delay(1000);
  
  //7
  digitalWrite(segment_A, HIGH);
  digitalWrite(segment_B, HIGH);
  digitalWrite(segment_DP, LOW);
  digitalWrite(segment_C, HIGH);
  digitalWrite(segment_D, LOW);
  digitalWrite(segment_E, LOW);
  digitalWrite(segment_G, LOW);
  digitalWrite(segment_F, LOW);
  delay(1000);
  
  //8
  digitalWrite(segment_A, HIGH);
  digitalWrite(segment_B, HIGH);
  digitalWrite(segment_DP, LOW);
  digitalWrite(segment_C, HIGH);
  digitalWrite(segment_D, HIGH);
  digitalWrite(segment_E, HIGH);
  digitalWrite(segment_G, HIGH);
  digitalWrite(segment_F, HIGH);
  delay(1000);
  
  //9
  digitalWrite(segment_A, HIGH);
  digitalWrite(segment_B, HIGH);
  digitalWrite(segment_DP, LOW);
  digitalWrite(segment_C, HIGH);
  digitalWrite(segment_D, HIGH);
  digitalWrite(segment_E, LOW);
  digitalWrite(segment_G, HIGH);
  digitalWrite(segment_F, HIGH);
  delay(1000);
}

Pour contrôler un afficheur à 7 segments simple, vous pouvez retrouver le programme sur notre drive.

4 afficheurs 7 segments en chaine

Dans le cadre de notre projet de station météo, nous avons besoin d’afficher plusieurs chiffres
simultanément. Pour ce faire, nous allons utiliser une configuration en chaîne de plusieurs afficheurs 7
segments. Chaque afficheur sera responsable de l’affichage d’un chiffre spécifique.

Voici un exemple illustrant cette configuration :

// Déclarer les différents segments
int Segment_A=7;
int Segment_B=8;
int Segment_C=2;
int Segment_D=3;
int Segment_E=4;
int Segment_F=6;
int Segment_G=5;

// Pin permettant de contrôler les différents affichages
int Afficheur_1=10;
int Afficheur_2=11;
int Afficheur_3=12;
int Afficheur_4=13;

// Déclarer les chiffres à afficher
int X[]={4,3,2,1};

void setup(){ 
  // Déclare les segments et les afficheurs en sortie 
  pinMode(Segment_C,OUTPUT);
  pinMode(Segment_D,OUTPUT);
  pinMode(Segment_E,OUTPUT);
  pinMode(Segment_G,OUTPUT);
  pinMode(Segment_F,OUTPUT);
  pinMode(Segment_A,OUTPUT);
  pinMode(Segment_B,OUTPUT);
  pinMode(Afficheur_1,OUTPUT);
  pinMode(Afficheur_2,OUTPUT);
  pinMode(Afficheur_3,OUTPUT);
  pinMode(Afficheur_4,OUTPUT);
}

void loop(){
  // Commencer par effacer les valeurs sur chaque afficheur
  digitalWrite(Afficheur_1,LOW);
  digitalWrite(Afficheur_2,LOW);
  digitalWrite(Afficheur_3,LOW);
  digitalWrite(Afficheur_4,LOW);
  
  
  static int Selection_Afficheur=0; // Cette variable permet de passer d'un afficheur à un autre
  
  if (Selection_Afficheur==4){ // Si la variable a parcourue tous les afficheurs alors on revient à 0
    Selection_Afficheur=0;}
  
  if(Selection_Afficheur==0){ // 4ème afficheur
    digitalWrite(Afficheur_4,HIGH);}
  
  else if(Selection_Afficheur==1){ // 3ème afficheur
    digitalWrite(Afficheur_3,HIGH);}
  
  else if(Selection_Afficheur==2){ // 2ème afficheur
    digitalWrite(Afficheur_2,HIGH);}
  
  else if(Selection_Afficheur==3){ // 1er afficheur
    digitalWrite(Afficheur_1,HIGH);}
// Eteindre tous les segments
  digitalWrite(Segment_C,LOW);
  digitalWrite(Segment_D,LOW);
  digitalWrite(Segment_E,LOW);
  digitalWrite(Segment_G,LOW);
  digitalWrite(Segment_F,LOW);
  digitalWrite(Segment_A,LOW);
  digitalWrite(Segment_B,LOW);
  digitalWrite(Segment_E,HIGH);
  
  // Allumer les différents segments en fonction des liaisons entre les afficheurs 
  if(X[Selection_Afficheur]==1||X[Selection_Afficheur]==4){ 
    digitalWrite(Segment_A,HIGH);}
  
  if(X[Selection_Afficheur]==5||X[Selection_Afficheur]==6){ 
    digitalWrite(Segment_B,HIGH);}
  
  if(X[Selection_Afficheur]==2){ 
    digitalWrite(Segment_C,HIGH);}
  
  if(X[Selection_Afficheur]==1||X[Selection_Afficheur]==4||X[Selection_Afficheur]==7){ 
    digitalWrite(Segment_D,HIGH);}
  
  if(X[Selection_Afficheur]==0||X[Selection_Afficheur]==2||X[Selection_Afficheur]==6||X[Selection_Afficheur]==8){ 
    digitalWrite(Segment_E,LOW);}
  
  if(X[Selection_Afficheur]==1||X[Selection_Afficheur]==2||X[Selection_Afficheur]==3||X[Selection_Afficheur]==7){ 
    digitalWrite(Segment_F,HIGH);}
  
  if(X[Selection_Afficheur]==0||X[Selection_Afficheur]==1||X[Selection_Afficheur]==7){ 
    
    digitalWrite(Segment_G,HIGH);}
  // Après avoir allumé un afficheur on passe au suivant en augmentant la variable « Selection Afficheur »
  Selection_Afficheur++;
  delay(20);
}

Le programme de ce projet est disponible sur notre drive.

Station météo sur Arduino

Nous avons développé plusieurs stations météo, chacune offrant ses propres fonctionnalités et
caractéristiques. Chaque station météo est équipée de capteurs de température et d’un afficheur que
l’on a abordé précédemment.

Maintenant, il est temps pour vous de vous immerger dans le projet de la station météo et de
commencer à collecter et à afficher vos propres données météorologiques. Préparez-vous à explorer le
monde fascinant de la météorologie grâce à votre stations météo !

Ecran LCD et capteur TMP36

L’un des premiers exemples de station météo utilise un écran LCD et le capteur TMP36. Dans ce cas,
seule la température peut être affichée, car le capteur TMP36 ne mesure pas l’humidité :

#include <LiquidCrystal.h> // Inclure la librairie pour l'écran LCD
// Indiquer à la librairie où est connecté l'écran
LiquidCrystal lcd(11, 12, 6, 5, 4, 3); 
int Capteur = 0 ; // Broche A0 où est connecté le capteur de température

void setup() {
  lcd.begin(16, 2);  // Initialiser la bonne taille de l'écran LCD
}

void loop() {
  int lecture = analogRead(Capteur); // Lire la valeur du capteur
  float voltage = 5.0 /1024 * lecture ; // Transformer cette valeur en tension
  // Transformer cette tension en température en degré
  float temperature = voltage * 100 -50 ; 
  
  lcd.setCursor(0, 0); // Placer le curseur au début de la 1ère ligne
  lcd.print("Temperature"); // Ecrire sur la 1ère ligne la température
  lcd.setCursor(12, 0); 
  lcd.print(temperature); // Donner la valeur de la température
}

Afficheur 7 segments et Capteur TMP36

Voici un exemple de station météo qui utilise un afficheur 7 segments et le capteur TMP36. Ce projet
vous permettra d’afficher la température sans tenir compte de l’humidité. Vous pouvez afficher toutes
les valeurs positives allant de 0 à plus de 100 degrés :

// Déclaration des broches pour les segments
int Segment_A = 7;
int Segment_B = 8;
int Segment_C = 2;
int Segment_D = 3;
int Segment_E = 4;
int Segment_F = 6;
int Segment_G = 5;

// Pin de contrôle des afficheurs
int Afficheur_1 = 10;
int Afficheur_2 = 11;
int Afficheur_3 = 12;
int Afficheur_4 = 13;

int Capteur = A0; // Broche où le TMP36 est connecté

// Tableau pour les segments pour chaque chiffre (0-9)
const int digits[10][7] = {
  {1, 1, 1, 1, 1, 1, 0}, // 0
  {0, 1, 1, 0, 0, 0, 0}, // 1
  {1, 1, 0, 1, 1, 0, 1}, // 2
  {1, 1, 1, 1, 0, 0, 1}, // 3
  {0, 1, 1, 0, 0, 1, 1}, // 4
  {1, 0, 1, 1, 0, 1, 1}, // 5
  {1, 0, 1, 1, 1, 1, 1}, // 6
  {1, 1, 1, 0, 0, 0, 0}, // 7
  {1, 1, 1, 1, 1, 1, 1}, // 8
  {1, 1, 1, 1, 0, 1, 1}  // 9
};

void setup() {
  // Initialisation des broches
  pinMode(Segment_A, OUTPUT);
  pinMode(Segment_B, OUTPUT);
  pinMode(Segment_C, OUTPUT);
  pinMode(Segment_D, OUTPUT);
  pinMode(Segment_E, OUTPUT);
  pinMode(Segment_F, OUTPUT);
  pinMode(Segment_G, OUTPUT);
  
  pinMode(Afficheur_1, OUTPUT);
  pinMode(Afficheur_2, OUTPUT);
  pinMode(Afficheur_3, OUTPUT);
  pinMode(Afficheur_4, OUTPUT);
  
  Serial.begin(9600);
}

void loop() {
  // Lecture du capteur TMP36
  int lecture = analogRead(Capteur);
  float voltage = (5.0 / 1024.0) * lecture; // Conversion en volts
  float temperature = (voltage - 0.5) * 100; // Conversion en °C
  
  // Conversion en entier et extraction des chiffres
  int temp = (int)temperature; // Partie entière de la température
  int premier_digit = (temp / 1000) % 10;
  int deuxieme_digit = (temp / 100) % 10;
  int troisieme_digit = (temp / 10) % 10;
  int quatrieme_digit = temp % 10;

  int chiffres[4] = {premier_digit, deuxieme_digit, troisieme_digit, quatrieme_digit};

  static int Selection_Afficheur = 0;

  // Éteindre tous les afficheurs
  digitalWrite(Afficheur_1, LOW);
  digitalWrite(Afficheur_2, LOW);
  digitalWrite(Afficheur_3, LOW);
  digitalWrite(Afficheur_4, LOW);

  // Sélectionner l'afficheur à activer
  if (Selection_Afficheur == 0) digitalWrite(Afficheur_1, HIGH);
  if (Selection_Afficheur == 1) digitalWrite(Afficheur_2, HIGH);
  if (Selection_Afficheur == 2) digitalWrite(Afficheur_3, HIGH);
  if (Selection_Afficheur == 3) digitalWrite(Afficheur_4, HIGH);

  // Afficher le chiffre correspondant
  int chiffre = chiffres[Selection_Afficheur];
  for (int i = 0; i < 7; i++) {
    digitalWrite(Segment_A + i, digits[chiffre][i]);
  }

  // Passer à l'afficheur suivant
  Selection_Afficheur = (Selection_Afficheur + 1) % 4;

  delay(5); // Rafraîchissement rapide pour éviter le scintillement
}

Le programme de ce projet est disponible sur notre drive.

Ecran LCD et capteur DHT11

Cet exemple de station météo est l’un des plus complets, car il permet d’afficher à la fois l’humidité et la
température, qu’elles soient positives ou négatives :

Le programme de ce projet est disponible sur notre drive.

Afficheur 7 segments et capteur DHT11

Ce projet de station météo utilise l’afficheur 7 segments et le capteur de température DHT11.
Cependant, avec ce projet, vous pouvez uniquement afficher la température et non l’humidité, car
l’afficheur 7 segments ne permet pas d’afficher plusieurs valeurs simultanément :

#include <dht_nonblocking.h> // Inclure la librairie du capteur
#define DHT_SENSOR_TYPE DHT_TYPE_11 // Définir que l'on a le DHT11 car la libraire fonctionne pour plusieurs capteurs de température
static const int capteur_temperature = 9; // Définir où est branché le capteur de température
DHT_nonblocking dht_sensor( capteur_temperature, DHT_SENSOR_TYPE ); // Initialiser la librairie avec la bonne broche et le bon type de capteur

// Déclarer les différents segments
int Segment_A=7;
int Segment_B=8;
int Segment_C=2;
int Segment_D=3;
int Segment_E=4;
int Segment_F=6;
int Segment_G=5;

// Pin permettant de contrôler les différents affichages
int Afficheur_1=10;
int Afficheur_2=11;
int Afficheur_3=12;
int Afficheur_4=13;

// Déclarer les chiffres à afficher
int premier_digit;
int deuxieme_digit;
int troisieme_digit;
int quatrieme_digit;

void setup(){ 
  // Déclarer les segments et les afficheurs en sortie 
  pinMode(Segment_C,OUTPUT);
  pinMode(Segment_D,OUTPUT);
  pinMode(Segment_E,OUTPUT);
  pinMode(Segment_G,OUTPUT);
  pinMode(Segment_F,OUTPUT);
  pinMode(Segment_A,OUTPUT);
  pinMode(Segment_B,OUTPUT);
  pinMode(Afficheur_1,OUTPUT);
  pinMode(Afficheur_2,OUTPUT);
  pinMode(Afficheur_3,OUTPUT);
  pinMode(Afficheur_4,OUTPUT);
  static bool measure_environment( float *temperature, float *humidite ){ // Créer une fonction pour récupérer la valeur 
  static unsigned long pause_entre_mesure = millis( ); // Définir le temps avec lequel on va faire les mesures
  if( millis( ) - pause_entre_mesure > 3000ul ) { // Calculer la mesure toute les 4 secondes
    if( dht_sensor.measure( temperature, humidite ) == true ){ // Prendre la nouvelle valeur si elle a évolué
      pause_entre_mesure = millis( );
      return( true );
    }
  }
  return( false );
}

void loop(){
  // Commencer par effacer les valeurs sur chaque afficheur
  digitalWrite(Afficheur_1,LOW);
  digitalWrite(Afficheur_2,LOW);
  digitalWrite(Afficheur_3,LOW);
  digitalWrite(Afficheur_4,LOW);
  
  float temperature; // Déclarer une variable pour récupérer la valeur de la température
  float humidite; // Déclarer une variable pour récupérer la valeur de l’humidité

  if( measure_environment( &temperature, &humidite ) == true ) { // Si les valeurs ont changés
    premier_digit= temperature / 1000 ; // Chiffre le plus à gauche du 7 segments 
    deuxieme_digit= temperature /100 ; // Chiffre corresponds à la centaine
    troisieme_digit = temperature /10; // Récupérer le nombre des dizaines de la température
    quatrieme_digit = (int) temperature %10; // Récupérer le plus petit nombre de la température
    quatrieme_digit +=1;
    int X[]={quatrieme_digit,troisieme_digit,deuxieme_digit,premier_digit};
  }
    
  static int Selection_Afficheur=0; // Cette variable permet de passer d'un afficheur à un autre
  
  if (Selection_Afficheur==4){ // Si la variable a parcourue tous les afficheurs alors on revient à 0
    Selection_Afficheur=0;}
  
  if(Selection_Afficheur==0){ // 4ème afficheur
    digitalWrite(Afficheur_4,HIGH);}
  
  else if(Selection_Afficheur==1){ // 3ème afficheur
    digitalWrite(Afficheur_3,HIGH);}
  
  else if(Selection_Afficheur==2){ // 2ème afficheur
    digitalWrite(Afficheur_2,HIGH);}
  
  else if(Selection_Afficheur==3){ // 1er afficheur
    digitalWrite(Afficheur_1,HIGH);}
// Eteindre tous les segments
  digitalWrite(Segment_C,LOW);
  digitalWrite(Segment_D,LOW);
  digitalWrite(Segment_E,LOW);
  digitalWrite(Segment_G,LOW);
  digitalWrite(Segment_F,LOW);
  digitalWrite(Segment_A,LOW);
  digitalWrite(Segment_B,LOW);
  digitalWrite(Segment_E,HIGH);
  
  // Allumer les différents segments en fonction des liaisons entre les afficheurs 
  if(X[Selection_Afficheur]==1||X[Selection_Afficheur]==4){ 
    digitalWrite(Segment_A,HIGH);}
  
  if(X[Selection_Afficheur]==5||X[Selection_Afficheur]==6){ 
    digitalWrite(Segment_B,HIGH);}
  
  if(X[Selection_Afficheur]==2){ 
    digitalWrite(Segment_C,HIGH);}
  
  if(X[Selection_Afficheur]==1||X[Selection_Afficheur]==4||X[Selection_Afficheur]==7){ 
    digitalWrite(Segment_D,HIGH);}
  
  if(X[Selection_Afficheur]==0||X[Selection_Afficheur]==2||X[Selection_Afficheur]==6||X[Selection_Afficheur]==8){ 
    digitalWrite(Segment_E,LOW);}
  
  if(X[Selection_Afficheur]==1||X[Selection_Afficheur]==2||X[Selection_Afficheur]==3||X[Selection_Afficheur]==7){ 
    digitalWrite(Segment_F,HIGH);}
  
  if(X[Selection_Afficheur]==0||X[Selection_Afficheur]==1||X[Selection_Afficheur]==7){ 
    
    digitalWrite(Segment_G,HIGH);}
  // Après avoir allumé un afficheur on passe au suivant en augmentant la variable « Selection Afficheur »
  Selection_Afficheur++;
  delay(20);
}

Le programme de ce projet est disponible sur notre drive.

SPI

Le Serial Peripheral Interface (SPI) est un protocole de communication série synchrone
largement utilisé dans les microcontrôleurs et les systèmes embarqués. Sur les cartes
Arduino, il permet une communication rapide et efficace avec divers périphériques
externes tels que des capteurs, des mémoires, ou des modules de communication sans fil.
Ce protocole est particulièrement apprécié pour sa simplicité, sa rapidité et sa flexibilité.

Ecriture SPI

Arduino facilite l’utilisation du protocole SPI grâce à sa bibliothèque intégrée SPI.h. Cette bibliothèque
permet d’abstraire la complexité de la communication SPI, rendant son utilisation simple et directe.
Voici un exemple de base illustrant comment utiliser cette bibliothèque pour établir une communication
avec un périphérique SPI :

#include <SPI.h>
void setup() {
// Initialisation de la communication SPI
SPI.begin();
// Configuration de la broche SS comme sortie
pinMode(10, OUTPUT);
}
void loop() {
// Activation de l'esclave en mettant SS à LOW
digitalWrite(10, LOW);
// Envoi d'un octet de données au périphérique SPI
byte dataSent = 0x42;
byte dataReceived = SPI.transfer(dataSent);
// Désactivation de l'esclave en mettant SS à HIGH
digitalWrite(10, HIGH);
// Attendre avant de refaire une transmission
delay(1000);
}

Le programme suivant permet d’envoyer l’octet 42 via la liaison SPI.

Lecture SPI

Si vous souhaitez lire les données transmises sur le bus SPI de la carte Arduino, voici le programme :

#include <SPI.h>
// Définir la broche SS (Slave Select)
const int slaveSelectPin = 10;
void setup() {
// Initialiser la communication série pour afficher les résultats
Serial.begin(9600);
// Configurer la broche SS comme sortie
pinMode(slaveSelectPin, OUTPUT);
// Initialiser la communication SPI
SPI.begin();
// Optionnel : Configurer les paramètres SPI
 // Diviser l'horloge par 16 (1 MHz pour une horloge à 16 MHz)
SPI.setClockDivider(SPI_CLOCK_DIV16);
SPI.setDataMode(SPI_MODE0); // Mode SPI 0
SPI.setBitOrder(MSBFIRST); // Ordre des bits : MSB en premier
}
void loop() {
// Activer l'esclave en mettant SS à LOW
digitalWrite(slaveSelectPin, LOW);
// Envoyer une requête de lecture au périphérique SPI
byte requestByte = 0x00; // Exemple de requête (peut varier selon le 
périphérique)
byte receivedValue = SPI.transfer(requestByte);
// Désactiver l'esclave en mettant SS à HIGH
digitalWrite(slaveSelectPin, HIGH);
// Afficher la valeur reçue dans le moniteur série
Serial.print("Valeur reçue : ");
Serial.println(receivedValue);
// Attendre avant de refaire une lecture
delay(1000);
}

Vous pouvez retrouver ce programme dans notre espace partagé.

RFID

Le RFID (Radio Frequency Identification) est une technologie qui permet l’identification à
distance d’un objet ou d’une personne via une carte ou un badge contenant une puce. En
intégrant un module RFID à votre Arduino, vous pouvez programmer un système qui ne
déverrouille la porte que lorsque la carte RFID autorisée est présentée. Ce type de sécurité
est particulièrement utile car il empêche toute tentative d’entrée non autorisée en
nécessitant un badge spécifique pour l’accès

Afficher les informations de la carte

Pour lire la carte quand elle est détectée par le module RFID, voici le programme suivant :

#include <SPI.h> 
#include <MFRC522.h>
#define Reset_PIN   9     // Pin pour configurer le reset du rfid
#define Liaison_SPI    10    // Pin pour la liaison SPI

MFRC522 mfrc522(Liaison_SPI, Reset_PIN);   
MFRC522::MIFARE_Key key;

void setup() {
  Serial.begin(9600);  // Initialisation la connexion avec le moniteur série
  while (!Serial);     // Ttant que le moniteur série est ouvert on ne fait rien
  SPI.begin();         // Initialisation de la liaison SPI
  mfrc522.PCD_Init();  // Initialisation de la carte rfid.
  Serial.println(F("Approchez votre carte du lecteur !"));
}

void loop() {
  // On regarde s'il y a de nouvelles cartes 
  if ( ! mfrc522.PICC_IsNewCardPresent() || ! mfrc522.PICC_ReadCardSerial() ) {
    delay(50);
    return;
  }
  // La nouvelle carte est maintenant sélectionnée
  Serial.print(F("Lecture de la carte UID:"));
  for (byte i = 0; i < mfrc522.uid.size; i++) {
    Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
    Serial.print(mfrc522.uid.uidByte[i], HEX);
  } 
  Serial.println();
  delay(2000);
}

Vous pouvez retrouver le programme dans notre espace partagé.

Le Rfid : Changer numéro UID carte

#include <SPI.h>
#include <MFRC522.h>

#define RST_PIN   9     // Pin pour configurer le reset du rfid
#define SS_PIN    10   // Pin pour la liaison SPI

MFRC522 mfrc522(SS_PIN, RST_PIN);   

/* On crée un nouveau UID */
#define NEW_UID {0xDE, 0xAD, 0xBE, 0xEF}

MFRC522::MIFARE_Key key;

void setup() {
  Serial.begin(9600);  // On initialise la connexion avec le moniteur série
  while (!Serial);     // On en fait rien tan que le moniteur série est ouvert
  SPI.begin();         // Initialisation de la liaison SPI.
  mfrc522.PCD_Init();  // Initialisation de la carte rfid.
  Serial.println(F("Approchez votre carte du lecteur !"));
  
  // On choisit ici les chiffres hexadécimaux du numéro UID.
  for (byte i = 0; i < 6; i++) {
    key.keyByte[i] = 0xFF;
  }
}

void loop() {
  
   // On regarde s'il y a des nouvelles cartes 
  if ( ! mfrc522.PICC_IsNewCardPresent() || ! mfrc522.PICC_ReadCardSerial() ) {
    delay(50);
    return;
  }
  
   // La nouvelle carte est maintenant sélectionnée.
  
    Serial.print(F("Lecture de la carte UID:"));
  for (byte i = 0; i < mfrc522.uid.size; i++) {
    Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
    Serial.print(mfrc522.uid.uidByte[i], HEX);
  } 
  Serial.println();

  // On ajoute le nouvel UID
  byte newUid[] = NEW_UID;
  if ( mfrc522.MIFARE_SetUid(newUid, (byte)4, true) ) {
    Serial.println(F("On écrit sur la nouvelle carte."));
  }
  

  mfrc522.PICC_HaltA();
  if ( ! mfrc522.PICC_IsNewCardPresent() || ! mfrc522.PICC_ReadCardSerial() ) {
    return;
  }
  
  Serial.println(F("Voici le nouveau UID"));
  mfrc522.PICC_DumpToSerial(&(mfrc522.uid));
  
  delay(2000);
}

Vous pouvez retrouver notre programme sur notre espace partagé

Digicode

Le digicode constitue un composant renforçant la sécurité de votre domicile. En l’intégrant à votre
système Arduino, vous pouvez exiger que l’utilisateur saisisse un code PIN valide après avoir utilisé le
badge RFID. Ce système de double authentification (RFID + code) renforce la sécurité de l’accès à votre
domicile, car même si une personne parvient à se procurer votre carte RFID, elle ne pourra pas pénétrer
sans connaître le code.

Librairie du Digicode

La bibliothèque keypad vous permettra d’utiliser et de faire fonctionner n’importe quelle matrice de
boutons.
Pour commencer, vous devez d’abord télécharger la bibliothèque.

Afficher les chiffres appuyés sur la console Arduino

Attention, pour la carte Arduino R4, il sera nécessaire d’ajouter des résistances de pull-up ou pull-down
afin de ne peut avoir de valeur flottante. Ceci n’est pas nécessaire sur la carte Arduino R3.

Ensuite, vous devez téléverser le code suivant afin que le moniteur série puisse identifier la touche sur
laquelle vous avez appuyé :

#include <Keypad.h>
const byte Ligne = 4; //quatre ligne sur le digicode
const byte Colonne = 4; //quatre colonne sur le digicode
//On définit maintenant les symboles correspondant à chaque bouton
char hexaBouton[Ligne][Colonne] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'} };
byte Ligne_Pins[Ligne] = {9, 8, 7, 6}; // On connecte la ligne du digicode 
byte Colonne_Pins[Colonne] = {5, 4, 3, 2}; // On connecte la colonne du digicode

//On initialise la librairie avec nos paramètres (la taille de la matrice et symboles)
Keypad mon_keypad = Keypad( makeKeymap(hexaBouton), Ligne_Pins, Colonne_Pins, Ligne, Colonne); 

void setup(){
  Serial.begin(9600);
}
void loop(){
// On demande à la librairie le chiffre tapé.
  char keypad_matrix = mon_keypad.getKey(); 
  if (keypad_matrix){
    Serial.println(keypad_matrix);
  }
}

Projet : Sécurisez votre porte d’entrée

Nous allons maintenant réaliser deux projets qui intègrent les deux composants que nous avons
étudiés : le RFID et le digicode. Ensemble, ces technologies vous offriront une solution de sécurité
avancée pour protéger votre maison, le tout en utilisant votre carte Arduino.

Coffre-fort avec un digicode

Si vous souhaitez sécuriser vos objets précieux dans un coffre-fort, ce projet est fait pour vous. Nous
allons utiliser un digicode pour verrouiller l’accès à votre coffre à l’aide d’un code à 4 chiffres.

Pour simuler ce projet, nous avons ajouté une LED qui s’allume en rouge pour indiquer que le coffre est
fermé. Dès que vous saisissez correctement le code “1234”, la LED passe au vert pour simuler
l’ouverture du coffre. Un système simple et efficace pour protéger ce qui compte le plus !

#include <Keypad.h>

const byte Ligne = 4; // Quatre lignes sur le digicode
const byte Colonne = 4; // Quatre colonnes sur le digicode

// Définir les symboles correspondant à chaque bouton
char hexaBouton[Ligne][Colonne] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

byte Ligne_Pins[Ligne] = {9, 8, 7, 6}; // Pins des lignes du digicode
byte Colonne_Pins[Colonne] = {5, 4, 3, 2}; // Pins des colonnes du digicode

Keypad mon_keypad = Keypad(makeKeymap(hexaBouton), Ligne_Pins, Colonne_Pins, Ligne, Colonne); 

// Définir les pins des LEDs
const int LED_Verte = 10;
const int LED_Rouge = 11;

// Définir le mot de passe
const String motDePasse = "1234";
String saisie = "";

void setup() {
  Serial.begin(9600);

  // Configurer les LEDs comme sorties
  pinMode(LED_Verte, OUTPUT);
  pinMode(LED_Rouge, OUTPUT);

  // Initialiser les LEDs à éteint
  digitalWrite(LED_Verte, LOW);
  digitalWrite(LED_Rouge, HIGH); // La LED rouge est allumée au départ
}

void loop() {
  // Récupérer le chiffre tapé sur le digicode
  char keypad_matrix = mon_keypad.getKey(); 

  if (keypad_matrix) {
    Serial.println(keypad_matrix); // Afficher la touche dans le moniteur série
    
    // Ajouter la touche à la saisie
    saisie += keypad_matrix;

    // Si la saisie est égale au mot de passe
    if (saisie == motDePasse) {
      Serial.println("Mot de passe correct !");
      digitalWrite(LED_Verte, HIGH); // Allumer la LED verte
      digitalWrite(LED_Rouge, LOW);  // Éteindre la LED rouge
      saisie = ""; // Réinitialiser la saisie
    }
    // Si la saisie dépasse la longueur du mot de passe
    else if (saisie.length() > motDePasse.length()) {
      Serial.println("Mot de passe incorrect !");
      saisie = ""; // Réinitialiser la saisie
      digitalWrite(LED_Verte, LOW); // Éteindre la LED verte
      digitalWrite(LED_Rouge, HIGH); // Allumer la LED rouge
    }
  }
}

Voici le programme pour faire fonctionner votre porte sécurisée. Vous pouvez changer le code « 1234 »
parce que vous souhaitez. Le projet actuel ne fonctionne qu’avec la carte Arduino UNO R3 dû à la
librairie du digicode (Keypad.h) qui n’est pas mis à jour pour la nouvelle carte Arduino UNO R4.

Sécurisez votre porte d’entrée avec un badge RFID

Dans ce deuxième projet, nous allons vous montrer comment sécuriser votre porte d’entrée à l’aide d’un
badge RFID. Vous pourrez ainsi ouvrir et fermer la porte en utilisant des badges spécifiques. Pour simuler
ce système, nous utiliserons deux LEDs : une rouge pour indiquer que la porte est fermée, et une verte
qui s’allume lorsque le badge scanné correspond à celui enregistré dans le programme, vous permettant
ainsi d’ouvrir la porte en toute sécurité :

#include <SPI.h> 
#include <MFRC522.h>

#define Reset_PIN   9     // Pin pour configurer le reset du RFID
#define Liaison_SPI    10    // Pin pour la liaison SPI
#define LED_Rouge_PIN 8    // Pin pour la LED rouge
#define LED_Verte_PIN 7    // Pin pour la LED verte

MFRC522 mfrc522(Liaison_SPI, Reset_PIN);   
MFRC522::MIFARE_Key key;

// UID du badge à comparer
byte UID_Comparaison[] = {0xAA, 0xBB, 0xCC, 0xDD};

void setup() {
  Serial.begin(9600);  // Initialisation de la connexion avec le moniteur série
  while (!Serial);     // Attente que le moniteur série soit ouvert
  SPI.begin();         // Initialisation de la liaison SPI
  mfrc522.PCD_Init();  // Initialisation de la carte RFID
  
  // Initialisation des LEDs
  pinMode(LED_Rouge_PIN, OUTPUT);
  pinMode(LED_Verte_PIN, OUTPUT);
  
  // Éteindre les LEDs au départ
  digitalWrite(LED_Rouge_PIN, HIGH);
  digitalWrite(LED_Verte_PIN, LOW);
  
  Serial.println(F("Approchez votre carte du lecteur !"));
}

void loop() {
  // On vérifie s'il y a une nouvelle carte
  if (!mfrc522.PICC_IsNewCardPresent() || !mfrc522.PICC_ReadCardSerial()) {
    delay(50);
    return;
  }

  // Lire et afficher l'UID de la carte
  Serial.print(F("Lecture de la carte UID:"));
  byte carteUID[mfrc522.uid.size];
  for (byte i = 0; i < mfrc522.uid.size; i++) {
    carteUID[i] = mfrc522.uid.uidByte[i];
    Serial.print(carteUID[i] < 0x10 ? " 0" : " ");
    Serial.print(carteUID[i], HEX);
  }
  Serial.println();

  // Comparer l'UID lu avec celui spécifié
  if (compareUID(carteUID, UID_Comparaison, sizeof(UID_Comparaison))) {
    Serial.println("Badge reconnu !");

    // Éteindre la LED rouge et allumer la LED verte
    digitalWrite(LED_Rouge_PIN, LOW); // Éteindre la LED rouge
    digitalWrite(LED_Verte_PIN, HIGH); // Allumer la LED verte
  } else {
    Serial.println("Badge inconnu !");

    // Éteindre la LED verte et allumer la LED rouge
    digitalWrite(LED_Rouge_PIN, HIGH); // Allumer la LED rouge
    digitalWrite(LED_Verte_PIN, LOW);  // Éteindre la LED verte
  }
  
  delay(2000); // Attente avant de pouvoir scanner une nouvelle carte
}

// Fonction pour comparer deux UID
bool compareUID(byte* uid1, byte* uid2, byte len) {
  for (byte i = 0; i < len; i++) {
    if (uid1[i] != uid2[i]) {
      return false; // Les UID sont différents
    }
  }
  return true; // Les UID sont égaux
}

Voici le programme pour faire fonctionner votre porte sécurisée.

Servomoteur

Un servomoteur est un moteur conçu pour maintenir une position précise, définie par l’utilisateur. Sa plage de rotation est limitée à un maximum de 180 degrés. Grâce à cette caractéristique, le servomoteur s’avère idéal pour des applications telles que l’ouverture de portes, de vannes, ou encore la direction d’un véhicule radiocommandé.

Cependant, le servomoteur n’est pas adapté aux applications nécessitant une rotation continue et rapide sur 360 degrés, comme la rotation des hélices d’un hélicoptère, le tractage d’un véhicule, ou l’entraînement d’une dynamo. Dans ces cas, un moteur à courant continu est préférable.

Coffre-fort avec un digicode

Le servomoteur fonctionne grâce à une bibliothèque qui simplifie son utilisation. Ci-dessous, vous
trouverez le circuit nécessaire à la réalisation des projets que nous allons aborder :

Voici le programme permettant de faire tourner le servomoteur de 0° à 180°, puis de revenir à sa
position initiale :

#include <Servo.h>

Servo monServomoteur;  // On créer un objet servomoteur
int pos = 0;    // variable pour stocker la position

void setup() {
  monServomoteur.attach(9);  // On attache le servomoteur à la broche 9
}

void loop() {
  for (pos = 0; pos <= 180; pos += 1) { // boucle de 0 à 180 degrés
    monServomoteur.write(pos);              // On indique le servomoteur la position
    delay(15);                       // On fait du 15 millisecondes
  }
  for (pos = 180; pos >= 0; pos -= 1) { // boucle de 180 à 0 degrés
    monServomoteur.write(pos);              // On indique le servomoteur la position
    delay(15);                       // On fait du 15 millisecondes
}
}

Voici un deuxième programme permettant de contrôler un servomoteur depuis votre moniteur série :

#include <Servo.h>
Servo monServomoteur;
int position_question;

void setup(){
Serial.begin(9600);
monServomoteur.attach(9);
Serial.println("-------------------------");
Serial.println("Donnez la position du Servomoteur entre 0 et 180 : ");
}

void loop() {
  if (Serial.available()) {
  Serial.println("-------------------------");
  Serial.print("Donnez la position du Servomoteur entre 0 et 180 : ");
  position_question = Serial.parseInt();
  Serial.println(position_question);
  }
if (position_question < 0) {
Serial.println("La valeur est inferieur a 0 donc 0 sera retenu");
position_question=0;
}

if (position_question > 180) {
  Serial.println("La valeur est superieur a 180 donc 180 sera retenu");
  position_question=180;
}
 monServomoteur.write(position_question);
}

Avec ce programme vous pouvez entrer un angle sur le moniteur série et le servomoteur va se mettre à
la position que souhaitez.

Moteur à courant continu

moteur dc

Les moteurs à courant continu, appelé aussi DC (Direct Current), est l’un des moteurs les plus utilisés
pour convertir de l’énergie électrique en énergie mécanique.
Les moteurs DC possèdent la particularité de fonctionner dans les 2 sens de rotation, en
fonction du sens du courant.

Un moteur à courant continu est réversible, c’est-à-dire que l’on peut l’utiliser pour
transformer de l’énergie électrique en énergie mécanique et inversement.

Rotation d’un moteur DC avec carte Moteur Shield

const int vitesseA = 3;
const int vitesseB = 11;

void setup() {
    pinMode(vitesseA,OUTPUT);
    pinMode(vitesseB,OUTPUT);
}
void loop() {
    // Moteur A
    digitalWrite(vitesseA,HIGH); // Allume le moteur
    delay(5000);
    digitalWrite(vitesseA,LOW); // On éteint le moteur
    
    //Moteur B
    digitalWrite(vitesseB,HIGH); // Allume le moteur
    delay(5000);
    digitalWrite(vitesseB,LOW); // On éteint le moteur
}

Vous pouvez retrouver ce programme dans notre espace partagé.

Variation de la vitesse d’un moteur DC avec la carte Motor Shield

const int input_voltage = 9;
const int nominal_voltage = 5;
const int MAX_SPEED = int(nominal_voltage * 255 / input_voltage);// On définit la vitesse maximale du moteur par la vitesse à la tension nominale de celui-ci.
const int vitesseA = 3;
const int vitesseB = 11;

void setup() {
    pinMode(vitesseA, OUTPUT);
    pinMode(vitesseB, OUTPUT);
}
void loop() {
    for (int i = 0; i < MAX_SPEED; i++) { // Croissance de la vitesse jusqu’à la vitesse maximal
        analogWrite(vitesseA, i); //Valeur de la vitesse pour le moteur A
        delay(100);
    }
    for (int i =MAX_SPEED ; i > 0; i--) { // Décroissance de la vitesse jusqu’à la vitesse maximal
        analogWrite(vitesseA, i);
        delay(100);
    }
    // Pareil pour le moteur B
    for (int i = 0; i < MAX_SPEED; i++) {
        analogWrite(vitesseB, i);
        delay(100);
    }
    for (int i =MAX_SPEED ; i > 0; i--) {
        analogWrite(vitesseB, i);
        delay(100);
    }
}

Vous pouvez retrouver ce programme sur notre espace partagé.

Télécommande infrarouge

Les télécommandes à infrarouge transmettent un signal que capte ensuite un récepteur infrarouge, lequel reçoit et traite ce dernier. Les télécommandes utilisées avec la plateforme Arduino fonctionnent de manière similaire à celle de votre téléviseur.

Le signal émis par la télécommande est codé sous forme de bits (0 ou 1), lesquels sont ensuite
interprétés et convertis en valeur hexadécimale par le récepteur infrarouge.

Chaque séquence hexadécimale correspond à l’appui sur un bouton spécifique de la télécommande.

Programme

Avant de procéder à la programmation de votre télécommande, il est nécessaire d’installer la bibliothèque IRRemoteControl, conçue pour faciliter l’interfaçage avec la télécommande.

#include "IRremote.h"
int receiver = 9; // Signal de la télécommande
IRrecv irrecv(receiver);
decode_results results;
void translateIR() // Fonction reliant le signal à la fonction associée
// describing Remote IR codes
{
switch(results.value)
{
case 0xFFA25D: Serial.println("POWER"); break;
case 0xFFE21D: Serial.println("FUNC/STOP"); break;
case 0xFF629D: Serial.println("VOL+"); break;
case 0xFF22DD: Serial.println("FAST BACK"); break;
case 0xFF02FD: Serial.println("PAUSE"); break;
case 0xFFC23D: Serial.println("FAST FORWARD"); break;
case 0xFFE01F: Serial.println("DOWN"); break;
case 0xFFA857: Serial.println("VOL-"); break;
case 0xFF906F: Serial.println("UP"); break;
case 0xFF9867: Serial.println("EQ"); break;
case 0xFFB04F: Serial.println("ST/REPT"); break;
case 0xFF6897: Serial.println("0"); break;
case 0xFF30CF: Serial.println("1"); break;
case 0xFF18E7: Serial.println("2"); break;
case 0xFF7A85: Serial.println("3"); break;
case 0xFF10EF: Serial.println("4"); break;
case 0xFF38C7: Serial.println("5"); break;
case 0xFF5AA5: Serial.println("6"); break;
case 0xFF42BD: Serial.println("7"); break;
case 0xFF4AB5: Serial.println("8"); break;
case 0xFF52AD: Serial.println("9"); break;
case 0xFFFFFFFF: Serial.println(" Répéter");break;
default:
Serial.println(" Autre bouton ");
}
delay(500); // Permet de laisser le temps de recevoir le prochain signal
}
void setup() // Fonction Setup qui s'exécute qu'une seule fois
{
Serial.begin(9600);
Serial.println("Démarrage du décodage");
irrecv.enableIRIn(); // On démarre le receveur
}
void loop() // Boucle qui s'exécute à l'infini
{
if (irrecv.decode(&results)) // Permet de savoir demande au capteur si on a reçu un signal
{
translateIR();
irrecv.resume(); // Permet de recevoir la valeur suivante
}
}

Vous pouvez télécharger notre programme sur l’espace partagé.

Projet Voiture Radiocommandé

Ce projet vise à concevoir une voiture télécommandée utilisant une carte Arduino associée à un moteur
à courant continu et un servomoteur. L’objectif est de créer un système permettant de contrôler la
vitesse, la direction et les feux de la voiture à l’aide d’une télécommande infrarouge.

#include "IRremote.h"
#include <Servo.h>
int receiver = 10; // Signal de la télécommande
IRrecv irrecv(receiver);
decode_results results;

Servo monServomoteur;  // On créer un objet servomoteur
int pos = 0;    // variable pour stocker la position du servomoteur
const int led_avant_gauche = 6;
const int led_avant_droit = 5;
const int led_arriere_gauche = 4;
const int led_arriere_droit = 7;
const int moteur = 3;  // Broche où le moteur est connecté (PWM)

void translateIR() { // Fonction reliant le signal à la fonction associée
switch(results.value) {
case 0xFFA25D: //POWER
digitalWrite(led_avant_gauche, HIGH);
digitalWrite(led_avant_droit, HIGH);
digitalWrite(led_arriere_gauche, HIGH);
digitalWrite(led_arriere_droit, HIGH);
Serial.println("POWER"); break;

case 0xFFE21D: // FUNC/STOP
digitalWrite(led_avant_gauche, LOW);
digitalWrite(led_avant_droit, LOW);
digitalWrite(led_arriere_gauche, LOW);
digitalWrite(led_arriere_droit, LOW);
analogWrite(moteur, 0);
Serial.println("FUNC/STOP"); break;

case 0xFF629D: //VOL+
analogWrite(moteur, 255);  // Applique la vitesse (0 à 255)
Serial.println("VOL+"); break;

case 0xFF22DD: //FAST BACK
monServomoteur.write(180); 
Serial.println("FAST BACK"); break;

case 0xFFC23D: //FAST FORWARD
monServomoteur.write(0);
Serial.println("FAST FORWARD"); break;

case 0xFFA857: //VOL -
analogWrite(moteur, 0);  
Serial.println("VOL-"); break;

case 0xFFFFFFFF: Serial.println(" Répéter");break;
default:
Serial.println(" Autre bouton ");
}
delay(500); // Permet de laisser le temps de recevoir le prochain signal
}
void setup() { // Fonction Setup qui s'exécute qu'une seule fois
Serial.begin(9600);
Serial.println("Démarrage du décodage");
irrecv.enableIRIn(); // On démarre le receveur
pinMode(led_avant_gauche, OUTPUT);
pinMode(led_avant_droit, OUTPUT);
pinMode(led_arriere_gauche, OUTPUT);
pinMode(led_arriere_droit, OUTPUT);
monServomoteur.attach(2);  // On attache le servomoteur à la broche 2
pinMode(moteur, OUTPUT);
}

void loop() { // Boucle qui s'exécute à l'infini
if (irrecv.decode(&results)) { // Permet de savoir demande au capteur si on a reçu un signal
translateIR();
irrecv.resume(); // Permet de recevoir la valeur suivante
}
}

Vous pouvez retrouver le programme de la voiture radiocommandée sur notre drive.

Projet : Réaliser votre lampe intelligente

L’objectif de ce projet est de concevoir une lampe intelligente capable de s’allumer automatiquement
lorsque le niveau de luminosité dans la pièce descend en dessous d’un certain seuil. Grâce à une
photorésistance, nous allons mesurer l’intensité lumineuse ambiante. Lorsque cette intensité devient
trop faible, un relais sera activé pour allumer la lampe, assurant ainsi un éclairage optimal à tout
moment.


Plus besoin de chercher l’interrupteur dans le noir ! La lampe s’allume automatiquement dès qu’il fait
trop sombre. La lampe ne s’allume que lorsque c’est nécessaire, ce qui permet de réduire la
consommation d’énergie.

Voici le programme permettant d’allumer votre lampe à l’aide du relais. Vous pouvez ajuster le seuil de
luminosité en fonction de vos préférences, ce qui rend ce projet parfaitement adaptable à tout type
d’environnement :

int valeur_photoresistance;
int broche_relais=13;

void setup() {
  Serial.begin(9600);
  pinMode(broche_relais, OUTPUT);
}
 
void loop() {
  valeur_photoresistance = analogRead(A0);   // La photorésistance est branché sur la borne analogique A0
  Serial.println("Voici la valeur de la photoresistance :"); 
  Serial.println(valeur_photoresistance); 
  if (valeur_photoresistance < 50) { // Seuil que vous pouvez modifier si besoin
    digitalWrite(broche_relais, HIGH);
  };
  else {
    digitalWrite(broche_relais, LOW);
  };
  delay(100);
}

Le Wifi sur Arduino

Le Wi-Fi sur Arduino permet d’ajouter une connectivité sans fil à vos projets. Grâce à cette
fonctionnalité, vous pouvez contrôler votre circuit à distance, transmettre des informations sur votre
réseau et même intégrer des solutions de domotique pour gérer votre maison via votre téléphone.

Il existe plusieurs façons d’ajouter le Wi-Fi à votre carte Arduino : soit en utilisant un module externe,
comme l’ESP8266, pour connecter votre carte au réseau, soit en optant pour une carte équipée
directement du module, comme la carte Arduino UNO R4 Wi-Fi, que nous avons présentée en début de
ce livre.

Scanner les réseaux disponibles

Ce projet permet de scanner les réseaux Wi-Fi disponibles à proximité avec une carte Arduino UNO.
L’objectif est de détecter et de lister les réseaux Wi-Fi, en affichant des informations telles que le nom
du réseau (SSID), la puissance du signal (RSSI) et le type de sécurité

#include <WiFiS3.h>

void setup() {
  //Initialize serial and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  // check for the WiFi module:
  if (WiFi.status() == WL_NO_MODULE) {
    Serial.println("Communication with WiFi module failed!");
    // don't continue
    while (true);
  }

  String fv = WiFi.firmwareVersion();
  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
    Serial.println("Please upgrade the firmware");
  }
}

void loop() {
  byte mac[6];
  // scan for existing networks:
  Serial.println("Scanning available networks...");
  listNetworks();
  WiFi.macAddress(mac);
  Serial.println();
  Serial.print("Your MAC Address is: ");
  printMacAddress(mac);
  delay(10000);
}

void listNetworks() {
  // scan for nearby networks:
  Serial.println("** Scan Networks **");
  int numSsid = WiFi.scanNetworks();
  if (numSsid == -1) {
    Serial.println("Couldn't get a WiFi connection");
    while (true);
  }

  // print the list of networks seen:
  Serial.print("number of available networks:");
  Serial.println(numSsid);

  // print the network number and name for each network found:
  for (int thisNet = 0; thisNet < numSsid; thisNet++) {
    Serial.print(thisNet);
    Serial.print(") ");
    Serial.print(WiFi.SSID(thisNet));
    Serial.print(" Signal: ");
    Serial.print(WiFi.RSSI(thisNet));
    Serial.print(" dBm");
    Serial.print(" Encryption: ");
    printEncryptionType(WiFi.encryptionType(thisNet));
  }
}

void printEncryptionType(int thisType) {
  // read the encryption type and print out the name:
  switch (thisType) {
    case ENC_TYPE_WEP:
      Serial.println("WEP");
      break;
    case ENC_TYPE_WPA:
      Serial.println("WPA");
      break;
    case ENC_TYPE_WPA2:
      Serial.println("WPA2");
      break;
    case ENC_TYPE_WPA3:
      Serial.print("WPA3");
      break;   
    case ENC_TYPE_NONE:
      Serial.println("None");
      break;
    case ENC_TYPE_AUTO:
      Serial.println("Auto");
      break;
    case ENC_TYPE_UNKNOWN:
    default:
      Serial.println("Unknown");
      break;
  }
}

void printMacAddress(byte mac[]) {
  for (int i = 0; i < 6; i++) {
    if (i > 0) {
      Serial.print(":");
    }
    if (mac[i] < 16) {
      Serial.print("0");
    }
    Serial.print(mac[i], HEX);
  }
  Serial.println();
}

Le programme pour la carte Arduino Uno R4 Wifi est disponible sur notre espace de stockage partagé.

Connecter la carte Arduino au wifi

Si vous souhaitez partager à distance les données collectées par vos capteurs, il peut être très
intéressant de connecter votre carte Arduino au réseau Wi-Fi de votre maison. Cela vous permettra
d’accéder aux informations en temps réel, où que vous soyez.

Pour réaliser cette connexion, il est essentiel de connaître à la fois le mot de passe de votre réseau Wi-Fi
et le nom du réseau, également appelé SSID. Une fois ces informations en main, vous pourrez configurer
votre Arduino pour envoyer les données de vos capteurs directement sur le cloud ou à votre appareil,
facilitant ainsi le suivi et l’analyse des mesures.

#include <WiFiS3.h>

///////please enter your sensitive data in the Secret tab/arduino_secrets.h
char ssid[] = "TP-Link_factory";        // your network SSID (name)
char pass[] = "mdp";    // your network password (use for WPA, or use as key for WEP)
int status = WL_IDLE_STATUS;     // the WiFi radio's status

void setup() {
  //Initialize serial and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  // check for the WiFi module:
  if (WiFi.status() == WL_NO_MODULE) {
    Serial.println("Communication with WiFi module failed!");
    // don't continue
    while (true);
  }

  String fv = WiFi.firmwareVersion();
  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
    Serial.println("Please upgrade the firmware");
  }

  // attempt to connect to WiFi network:
  while (status != WL_CONNECTED) {
    Serial.print("Attempting to connect to WPA SSID: ");
    Serial.println(ssid);
    // Connect to WPA/WPA2 network:
    status = WiFi.begin(ssid, pass);

    // wait 10 seconds for connection:
    delay(10000);
  }

  // you're connected now, so print out the data:
  Serial.print("You're connected to the network");
  printCurrentNet();
  printWifiData();

}

void loop() {
  // check the network connection once every 10 seconds:
  delay(10000);
  printCurrentNet();
}

void printWifiData() {
  // print your board's IP address:
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  
  Serial.println(ip);

  // print your MAC address:
  byte mac[6];
  WiFi.macAddress(mac);
  Serial.print("MAC address: ");
  printMacAddress(mac);
}

void printCurrentNet() {
  // print the SSID of the network you're attached to:
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());

  // print the MAC address of the router you're attached to:
  byte bssid[6];
  WiFi.BSSID(bssid);
  Serial.print("BSSID: ");
  printMacAddress(bssid);

  // print the received signal strength:
  long rssi = WiFi.RSSI();
  Serial.print("signal strength (RSSI):");
  Serial.println(rssi);

  // print the encryption type:
  byte encryption = WiFi.encryptionType();
  Serial.print("Encryption Type:");
  Serial.println(encryption, HEX);
  Serial.println();
}

void printMacAddress(byte mac[]) {
  for (int i = 0; i < 6; i++) {
    if (i > 0) {
      Serial.print(":");
    }
    if (mac[i] < 16) {
      Serial.print("0");
    }
    Serial.print(mac[i], HEX);
  }
  Serial.println();
}

Vous retrouverez le programme pour la carte Arduino Uno R4 Wifi dans notre espace de stockage partagé.

Contrôler votre projet depuis votre site web

Un projet particulièrement intéressant avec le Wi-Fi sur la carte Arduino UNO consiste à héberger une
page web directement depuis celle-ci. Cela vous permettra de vous connecter à votre carte et d’interagir
avec elle de manière intuitive. Sur cette page web, vous pourrez créer un tableau de bord regroupant
tous vos capteurs, mais également intégrer des boutons pour contrôler des appareils, comme allumer
des lampes ou ajuster la tension de votre maison.

#include "WiFiS3.h"

///////please enter your sensitive data in the Secret tab/arduino_secrets.h
char ssid[] = "Arduino_factory";        // your network SSID (name)
char pass[] = "votremdp";        // your network password (use for WPA, or use as key for WEP)
int keyIndex = 0;                 // your network key index number (needed only for WEP)

int led =  LED_BUILTIN;
int status = WL_IDLE_STATUS;
WiFiServer server(80);

void setup() {
  //Initialize serial and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
  Serial.println("Access Point Web Server");

  pinMode(led, OUTPUT);      // set the LED pin mode

  // check for the WiFi module:
  if (WiFi.status() == WL_NO_MODULE) {
    Serial.println("Communication with WiFi module failed!");
    // don't continue
    while (true);
  }

  String fv = WiFi.firmwareVersion();
  if (fv < WIFI_FIRMWARE_LATEST_VERSION) {
    Serial.println("Please upgrade the firmware");
  }

  // by default the local IP address will be 192.168.4.1
  // you can override it with the following:
  WiFi.config(IPAddress(192,48,56,2));

  // print the network name (SSID);
  Serial.print("Creating access point named: ");
  Serial.println(ssid);

  // Create open network. Change this line if you want to create an WEP network:
  status = WiFi.beginAP(ssid, pass);
  if (status != WL_AP_LISTENING) {
    Serial.println("Creating access point failed");
    // don't continue
    while (true);
  }

  // wait 10 seconds for connection:
  delay(10000);

  // start the web server on port 80
  server.begin();

  // you're connected now, so print out the status
  printWiFiStatus();
}

void loop() {
  
  // compare the previous status to the current status
  if (status != WiFi.status()) {
    // it has changed update the variable
    status = WiFi.status();

    if (status == WL_AP_CONNECTED) {
      // a device has connected to the AP
      Serial.println("Device connected to AP");
    } else {
      // a device has disconnected from the AP, and we are back in listening mode
      Serial.println("Device disconnected from AP");
    }
  }
  
  WiFiClient client = server.available();   // listen for incoming clients

  if (client) {                             // if you get a client,
    Serial.println("new client");           // print a message out the serial port
    String currentLine = "";                // make a String to hold incoming data from the client
    while (client.connected()) {            // loop while the client's connected
      delayMicroseconds(10);                // This is required for the Arduino Nano RP2040 Connect - otherwise it will loop so fast that SPI will never be served.
      if (client.available()) {             // if there's bytes to read from the client,
        char c = client.read();             // read a byte, then
        Serial.write(c);                    // print it out to the serial monitor
        if (c == '\n') {                    // if the byte is a newline character

          // if the current line is blank, you got two newline characters in a row.
          // that's the end of the client HTTP request, so send a response:
          if (currentLine.length() == 0) {
            // HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK)
            // and a content-type so the client knows what's coming, then a blank line:
            client.println("HTTP/1.1 200 OK");
            client.println("Content-type:text/html");
            client.println();

            // the content of the HTTP response follows the header:
            client.print("<p style=\"font-size:7vw;\">Click <a href=\"/H\">here</a> turn the LED on<br></p>");
            client.print("<p style=\"font-size:7vw;\">Click <a href=\"/L\">here</a> turn the LED off<br></p>");

            // The HTTP response ends with another blank line:
            client.println();
            // break out of the while loop:
            break;
          }
          else {      // if you got a newline, then clear currentLine:
            currentLine = "";
          }
        }
        else if (c != '\r') {    // if you got anything else but a carriage return character,
          currentLine += c;      // add it to the end of the currentLine
        }

        // Check to see if the client request was "GET /H" or "GET /L":
        if (currentLine.endsWith("GET /H")) {
          digitalWrite(led, HIGH);               // GET /H turns the LED on
        }
        if (currentLine.endsWith("GET /L")) {
          digitalWrite(led, LOW);                // GET /L turns the LED off
        }
      }
    }
    // close the connection:
    client.stop();
    Serial.println("client disconnected");
  }
}

void printWiFiStatus() {
  // print the SSID of the network you're attached to:
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());

  // print your WiFi shield's IP address:
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);

  // print where to go in a browser:
  Serial.print("To see this page in action, open a browser to http://");
  Serial.println(ip);

}

Le programme permettant d’installer un serveur web sur votre carte Arduino est disponible en téléchargement à l’adresse suivante : programme.

Oscillateur numérique

Lors de la mise en place de circuits avec Arduino, il est impératif de vérifier que les tensions sont
correctes. De plus, les connexions incorrectes peuvent causer des dysfonctionnements. En utilisant un
multimètre pour tester la continuité, vous pouvez vérifier que les connexions sont bien établies et qu’il
n’y a pas de coupures dans les fils.

L’informatique a permis la miniaturisation des oscilloscopes. Certains
modèles affichent directement les résultats sur un ordinateur, ce qui
les rend encore plus compacts et moins chers.

Ce type d’oscilloscope est particulièrement adapté aux projets Arduino, car il allie faible coût et qualité
suffisante pour des applications de base. Si vous recherchez un oscilloscope à prix modéré, performant
et idéal pour débuter, ce modèle constitue un excellent choix.

Voici le pilote à installer si vous avez acheté l’analyseur Az-Delivery.