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) 

https://www.arduino.cc/

→ 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 : 

Devoir pour le lundi 3 mars - 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 

Projet final - Prototypage

Définition du Projet

• Besoin : Créer une veilleuse ou une lampe d'ambiance originale et personnalisée, combinant l'artisanat (crochet) et la technologie (impression 3D, Arduino). Le besoin est à la fois esthétique (objet décoratif) et fonctionnel (source de lumière).

• Utilisateurs :

• Principal : Personnes recherchant une veilleuse originale, une lampe d'ambiance personnalisée ou un cadeau unique.

• Secondaire : Passionnés de crochet, d'impression 3D et d'électronique souhaitant réaliser un projet créatif et accessible.

• Fonctionnalité Principale : Le pingouin en crochet repose sur un socle imprimé en 3D qui émet des lumières colorées et changeantes, créant une ambiance agréable.

• Fonctionnalités Secondaires :

• Variation des couleurs et des effets lumineux (fondu, clignotement, arc-en-ciel).

• Possibilité de changer de mode d'éclairage (par exemple, avec un bouton).

• Réaction de la lumière au son (optionnel).

Réflexions sur la Problématique et Veille sur l'Existant

• Problématique : Comment combiner de manière harmonieuse le crochet (un art traditionnel) et l'impression 3D (une technologie moderne) pour créer un objet à la fois esthétique et fonctionnel ? Comment intégrer l'électronique (Arduino, LED) de manière discrète et efficace ?

• Veille sur l'Existant :

• Veilleuses et Lampes d'Ambiance : Analyser les différents types de veilleuses et de lampes d'ambiance disponibles sur le marché (matériaux, design, fonctionnalités).

• Projets DIY Combinant Crochet et Impression 3D : Rechercher des projets similaires sur internet (Pinterest, Instructables, Thingiverse) pour s'inspirer des idées et des techniques utilisées.

• Tutoriels Arduino et LED RGB : Consulter des tutoriels en ligne pour apprendre à contrôler les LED RGB avec un Arduino et créer des effets lumineux variés.

• Exemple de Ressource : Arduino Project Hub (rechercher "RGB LED control")

Lean Canvas

Voici un exemple de Lean Canvas pour structurer le projet :

Choix Techniques

• Arduino Nano : Choix idéal pour sa petite taille et son faible coût.

• LED RGB : Permet de créer une grande variété de couleurs et d'effets lumineux.

• Tinkercad : Logiciel de CAO simple et gratuit pour la conception 3D du socle.

• Cura : Logiciel de slicing gratuit et performant pour la préparation de l'impression 3D.

• Crochet : Technique artisanale maîtrisée par votre camarade pour la création du pingouin.

Gestion de Projet

• Minimum Viable Product (MVP) :
  
  

• Socle imprimé en 3D avec une LED RGB et un Arduino Nano.

• Code Arduino de base pour faire varier les couleurs de la LED.

• Pingouin en crochet simple.

• Planification et Répartition des Tâches :
  
  

Croquis, Dimensions

• Croquis : Réaliser un croquis du pingouin et du socle pour visualiser le projet et définir les dimensions approximatives.

• Dimensions :

• Pingouin : Hauteur : 15-20 cm, Largeur : 8-10 cm

• Socle : Diamètre : 10-12 cm, Hauteur : 5-7 cm (ces dimensions sont données à titre indicatif et peuvent être ajustées en fonction du design)

Liste du Matériel

• Arduino Nano

• LED RGB (1-3)

• Résistances (220Ω, 3 par LED)

• Fils de connexion

• Filament pour imprimante 3D

• Laine pour le crochet

• Crochet

• Câble USB pour alimenter l'Arduino

• Alimentation USB (chargeur de téléphone par exemple)

Fichiers de Conception et Étapes de Création des Fichiers / Code

• Fichiers de Conception :

• Fichier STL du socle (exporté depuis Tinkercad)

• Fichier de code Arduino (.ino)

• Étapes de Création des Fichiers :

• Tinkercad : Captures d'écran des différentes étapes de la conception du socle (création de la base, ajout des cavités pour les LED, etc.).

• Arduino IDE : Captures d'écran du code Arduino, avec des commentaires expliquant chaque partie.

Photos et Analyse des Tests, Essais, Erreurs

• Photos : Prendre des photos des différents tests réalisés (par exemple, tests de couleurs des LED, tests de diffusion de la lumière à travers le socle).

• Analyse : Décrire les problèmes rencontrés lors des tests et les solutions apportées.

• Exemple : "La lumière des LED était trop directe et éblouissante. J'ai ajouté une couche de papier calque à l'intérieur du socle pour diffuser la lumière de manière plus uniforme."

Photos des Étapes de Réalisation du Prototype, Paramètres des Machines

• Photos : Prendre des photos des différentes étapes de la réalisation du prototype (impression du socle, câblage des LED, crochet du pingouin).

• Paramètres des Machines :

• Imprimante 3D : Marque, modèle, température d'impression, vitesse d'impression, remplissage, type de filament.

• Logiciel de Slicing : Cura (ou autre), paramètres utilisés (hauteur de couche, etc.).

Photos de l'Objet Final

• Photos : Prendre des photos de l'objet final sous différents angles et dans différentes conditions d'éclairage.

• Qualité : S'assurer que les photos sont de bonne qualité et mettent en valeur le projet.

Réflexions de Pistes d'Amélioration ou d'Évolution du Projet

• Améliorations :

• Ajouter un capteur de lumière pour que la veilleuse s'allume automatiquement dans l'obscurité.

• Utiliser un capteur de son pour faire varier la lumière en fonction du bruit ambiant.

• Intégrer un module Bluetooth pour contrôler les couleurs depuis un smartphone.

• Évolutions :

• Créer d'autres animaux en crochet avec des socles lumineux personnalisés.

• Développer une application mobile pour contrôler les veilleuses à distance.

Sources des Tutoriels, Inspirations, Ressources Utilisées

• À insérer au fil de la documentation :

• Liens vers les tutoriels Arduino utilisés pour contrôler les LED RGB.

• Liens vers des projets similaires sur internet (Pinterest, Instructables, Thingiverse).

• Références aux livres ou articles utilisés pour apprendre le crochet.

• Site internet d'Arduino