Projet Prototypage Chloé, Louly, Eloïse
Cours Arduino - Vendredi 7 février 2025
Introduction :
Raspberry Pi : petit ordinateur très puissant piloté par un microprocesseur qui ne fait que calculer, toutes les autres caractéristiques de l’ordinateur se trouvent autour avec système d’exploitation implanté à l’intérieur
→ Calculs : intelligence artificielle, musiques, console de jeu,
Arduino : Carte programmable pilotée par un microcontrôleur (petit ordinateur dans une petite puce) qui contient de la rame, du rome, des processeurs, des entrées/des sorties
Board de développement + IDE (logiciel) + Bibliothèque de fonctions (accéder aux fonctionnalités)
→ Automatisation de signaux numériques et analogiques (alimenter des led, des capteurs)
Numérique :
- 1/ état haut 5V
- 2/ état bas 0V
Composant du base de l'arduino :
> LED : resistance très faible donc ajouter une resistance en série
> Resistance : limitation du courant --> Intensité = U/R (si la resistance ≈ 0 alors l'intensité est à l'infini --> la LED grille)
> Condensateurs : pile qui compense les variations de courants
> Potentiomètre : composant qui permet l'interaction arduino/utilisateur, sert à ajuster une valeur de résistance manuellement
> Transistors : interrupteur qu'on peut piloter avec la carte arduino à des tensions supérieures à celle à laquelle l'arduino fonctionne
> Régulateur : composant qui stabilise la tension d'alimentation fournie à la carte
Téléchargement du code :
> Indiquer la carte téléchargée : Arduino AVR Boards --> Arduino Uno
> Sélectionner le port de l'arduino --> COM3 Arduino Uno 
Changer la vitesse de clignotement :
> modifier la valeur dans : delay(xxx)
Faire clignoter une LED classique :
Code :
Résultat :
Fonctionnement du bouton en arduino :
Un bouton est un composant électronique utilisé pour déclencher une action lorsqu'il est pressé
Un bouton a 2 états :
> Appuyé (HIGH ou 1) --> Le circuit est fermé, un signal électrique passe
> Relâché (LOW ou 0) --> Le circuit est ouvert, aucun signal ne passe
Un bouton a au minimum 2 broches :
> Une broche connectée à une entrée numérique d’Arduino
> Une broche connectée à la masse (GND), souvent avec une résistance pull-up ou pull-down
Faire afficher bouton presser
Code :
Fonctionnement du potentiomètre :
Un potentiomètre est une résistance variable avec trois broches :
> Broche 1 (VCC / +5V) → Alimentation positive.
> Broche 2 (Sortie / Curseur - Signal) → Donne une tension variable entre 0V et 5V.
> Broche 3 (GND / Masse) → Alimentation négative.
Lorsque le bouton du potentiomètre est tourné --> la résistance interne change --> le tension en sortie est modifiée
Faire fonctionner un potentiomètre :
Code :
Résultat :
Variation de la tension
Fonctionnement d'un capteur I2C :
Un capteur I2C est un capteur qui utilise le protocole I2C pour communiquer avec un microcontrôleur ou un ordinateur. C'est une manière simple et efficace de connecter plusieurs capteurs en utilisant seulement 2 fils
Notre capteur : Grove - Sunlight Sensor)
Documentation : https://wiki.seeedstudio.com/Grove-I2C_High_Accuracy_Temp%26Humi_Sensor-SHT35/
> Ouvrir le code test : File>Examples>Grove_Sunlight_Sensor>SI1151
Résultat :
Après passage de fils de couleurs devant le capteur.
Test 1 de fonctionnement du capteur I2C :
Demande à ChatGPT : "Peux-tu modifier le code ci-dessous pour que dès que la luminosité est supérieure à 10, la lampe LED s'allume:
#include "Si115X.h"
Si115X si1151;
/**
* Setup for configuration
*/
void setup()
{
Serial.begin(115200);
if (!si1151.Begin()) {
Serial.println("Si1151 is not ready!");
while (1) {
delay(1000);
Serial.print(".");
};
}
else {
Serial.println("Si1151 is ready!");
}
}
/**
* Loops and reads data from registers
*/
void loop()
{
Serial.print("IR: ");
Serial.println(si1151.ReadIR());
Serial.print("Visible: ");
Serial.println(si1151.ReadVisible());
delay(500);
}"
Code :
Explication des modifications :
1. Ajout de #define LED_PIN 3 pour définir la broche de la LED.
2. Initialisation de pinMode(LED_PIN, OUTPUT) dans setup().
3. Lecture de la luminosité visible avec si1151.ReadVisible().
4. Condition if (visibleLight > 10) pour allumer ou éteindre la LED
Résultat :
Test 2 de fonctionnement du capteur I2C :
Demande à ChatGPT : "Quand c'est supérieur à 15 je veux allumer ma LED rouge et quand c'est inférieur à 15 je veux allumer la lampe bleu. Modifie le Code et donne le montage:
Réponse: D'accord ! Voici le code modifié pour :
> Allumer la LED rouge si la luminosité *est supérieure à 15
> Allumer la LED bleue si la luminosité *est inférieure ou égale à 15
Montage
Matériel nécessaire :
- *Arduino avec Grove Base Shield*
- *Capteur de lumière Si1151* (déjà branché sur le port I2C du Grove Shield)
- *LED rouge* (branchée sur *D3*)
- *LED bleue* (branchée sur *D4*)
- *2 résistances de 220Ω*
- *Fils de connexion*
Schéma de câblage :
1. *Capteur Si1151*
- Déjà connecté au port *I2C* du *Grove Base Shield* (pas besoin de modification).
2. *LED Rouge*
- *Anode (+) → D3*
- *Cathode (-) → GND (via résistance 220Ω)*
3. *LED Bleue*
- *Anode (+) → D4* "
Code :
cpp
#include "Si115X.h"
Si115X si1151;
#define LED_ROUGE 3 // Broche de la LED rouge
#define LED_BLEUE 4 // Broche de la LED bleue
#define SEUIL_LUMIERE 15 // Seuil de luminosité pour le changement
void setup() {
Serial.begin(115200);
pinMode(LED_ROUGE, OUTPUT);
pinMode(LED_BLEUE, OUTPUT);
if (!si1151.Begin()) {
Serial.println("Si1151 n'est pas prêt !");
while (1) {
delay(1000);
Serial.print(".");
};
}
else {
Serial.println("Si1151 est prêt !");
}
}
void loop() {
int visibleLight = si1151.ReadVisible(); // Lire la valeur de la lumière visible
Serial.print("Lumière visible : ");
Serial.println(visibleLight);
if (visibleLight > SEUIL_LUMIERE) {
digitalWrite(LED_ROUGE, HIGH); // Allume LED rouge
digitalWrite(LED_BLEUE, LOW); // Éteint LED bleue
} else {
digitalWrite(LED_ROUGE, LOW); // Éteint LED rouge
digitalWrite(LED_BLEUE, HIGH); // Allume LED bleue
}
delay(500);
}
Explication du Code :
1. On définit les broches des *LEDs rouge et bleue*.
2. Dans la *loop(), on lit la luminosité du capteur **Si1151*.
3. Si la valeur est *> 15, la **LED rouge* s'allume et la *LED bleue* s'éteint.
4. Si la valeur est *≤ 15, la **LED bleue* s'allume et la *LED rouge* s'éteint.
5. Le code se met à jour *toutes les 500ms*.
Fonctionnement du cerveau-moteur :
Un contrôleur de moteur est un composant électronique qui permet de contrôler avec précision le mouvement d'un moteur en recevant des commandes d'un microcontrôleur/ordinateur et en ajustant la tension et le courant envoyés au moteur
Envoi d'un signal PWM : signal périodique sur lequel on fait varier la durée de l'impulsion par une alternance rapide entre un état "haut" (tension maximale) et un état "bas" (tension nulle)
Demande à ChatGPT : Comment faire fonctionner un cerveau moteur FS90MG via une arduino. Donne moi le montage et le code associé?
Réponse: Pour faire fonctionner un *servomoteur FS90MG* avec un *Arduino*, voici ce dont tu as besoin :
Matériel nécessaire :
- 1x Arduino (Uno, Mega, etc.)
- 1x Servomoteur *FS90MG*
- 1x Résistance de 330Ω (optionnel pour protéger le signal)
- 3x Câbles de connexion
Schéma de câblage :
Le servomoteur *FS90MG* a *trois fils* :
- *Rouge (VCC)* → *5V* de l'Arduino
- *Marron ou Noir (GND)* → *GND* de l'Arduino
- *Orange (Signal)* → *Broche D9* de l'Arduino
⚠ *Remarque importante :* Si le moteur force trop, il est préférable d’utiliser une alimentation externe 5V (et relier les GND ensemble).
Code :
On utilise la bibliothèque *Servo.h* pour contrôler le moteur.
cpp
#include <Servo.h>
Servo monServo; // Création d'un objet Servo
void setup() {
monServo.attach(9); // Connecté à la broche D9
}
void loop() {
monServo.write(0); // Position à 0°
delay(1000); // Attendre 1 seconde
monServo.write(90); // Position à 90°
delay(1000);
monServo.write(180); // Position à 180°
delay(1000);
}
Explication du code :
1. **monServo.attach(9);** → Indique que le moteur est connecté sur la broche *D9*.
2. **monServo.write(angle);** → Permet de définir un angle entre *0° et 180°*.
3. **Les délais (delay(1000);)** permettent d’observer chaque changement d’angle.
Résultat :
Test de fonctionnement du cerveau moteur :
Demande à ChatGPT : "Comment faire tourner un cerveau moteur FS90MG. A chaque rotation une LED s'allume (soit rouge soit vert). Peux tu me donner le code et le montage associé sur arduino uno?
Matériel nécessaire :
- 1 Arduino Uno
- 1 servo moteur FS90MG
- 2 résistances (220 ohms)
- 1 LED rouge
- 1 LED verte
- Câblage (fils mâle-mâle)
Schéma de montage :
1. Connecte la broche de signal du servo (généralement orange) à la broche *D9* de l’Arduino.
2. Branche la broche de puissance (rouge) du servo à *5V* et la masse (noire) à *GND*.
3. Connecte les LED :
- LED rouge :
- Anode (longue patte) à *D3* via une résistance de 220 ohms
- Cathode à *GND*
- LED verte :
- Anode (longue patte) à *D4* via une résistance de 220 ohms
- Cathode à *GND* "
Code :
cpp
#include <Servo.h>
Servo monServo;
const int ledRouge = 3;
const int ledVerte = 4;
int position = 0; // Position initiale du servo
bool ledState = false; // État LED : false = rouge, true = verte
void setup() {
monServo.attach(9); // Connecte le servo sur la broche 9
pinMode(ledRouge, OUTPUT);
pinMode(ledVerte, OUTPUT);
digitalWrite(ledRouge, LOW);
digitalWrite(ledVerte, LOW);
Serial.begin(9600);
}
void loop() {
// Déplace le servo entre 0° et 180°
position = (position == 0) ? 180 : 0;
monServo.write(position);
// Alterne les LEDs
if (ledState) {
digitalWrite(ledRouge, LOW);
digitalWrite(ledVerte, HIGH);
} else {
digitalWrite(ledRouge, HIGH);
digitalWrite(ledVerte, LOW);
}
ledState = !ledState; // Inverse l'état
Serial.print("Servo à la position : ");
Serial.println(position);
delay(1000); // Pause d'une seconde entre les rotations
}
Explications du code :
- Le servo oscille entre 0° et 180°.
- À chaque mouvement, l'état des LEDs alterne : rouge, puis vert.
- Le délai de 1000 ms permet une rotation claire et un changement visible des LEDs.
Résultat :
Alternance LED rouge / LED verte selon la rotation du cerveau moteur
