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 de 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 servomoteur :

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

Demande à ChatGPT : "Comment faire tourner un servomoteur 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 

Cours Arduino - Lundi 3 mars 2025

Conception 3D sur le site TINKERCAD : 

Création d'un support pour téléphone

1/ Idée 

• Définition des dimensions et de la forme
• Inclinaison pour un bon angle de vue
• Large base pour assurer la stabilité
• Ajout d’une butée pour éviter que le téléphone glisse

2/ Modélisation 

• Création d'une base rectangulaire solide
• Ajout d’un plan incliné pour le support du téléphone
• Intégration de 2 butées pour maintenir les 2 base rectangulaire en place
• Perçage d'un trou décoratif en haut du rectangle pour alléger la structure

3/ Résultat 

Création d'un objet de notre choix pour le cours de vendredi 7 mars 

1/ Conception de la structure

• Base cylindrique pour représenter le corps du moulin
• Toit conique pour donner un aspect traditionnel
• Ajout d’une porte et de fenêtres circulaires 
• Petit cylindre sur le côté du toit pour rajouter les pales du moulin
  

2/ Ajout des pales du moulin

• Création d’un axe central avec un petit cercle
• Ajout de quatre pales symétriques en forme allongée
• Vérification de l’alignement et de la taille des pales pour un effet harmonieux
• Vérification des proportions entre le moulin et les pales.
• Création d'un bout pour fixer les pales sur le cylindre présent sur le toit. 

3/ Résultat 

Impression 3D via le logiciel PRUSASLICER

1/ Exportation

• Enregistrement des 2 modèles en format STL pour l’impression 3D
• Ouverture des 2 modèles sur le logiciel 
• Remplissage 20% 
• Rajout de supports pour supporter le cylindre présent sur le toit. 

2/ Résultats

Voici le résultat du support pour téléphone, que nous n'avons pas imprimé mais avec lequel nous avons pris en main le logiciel Prusaslicer :

Voici maintenant le résultat de notre moulin, réglé via le logiciel Prusaslicer puis imprimé sur une imprimante 3D Prusa :

Problèmes rencontrés & améliorations envisagées : 

Au moment de l'impression sur l'imprimante 3D PRUSA, les socles ne restaient pas fixés à la planche de support donc les impressions n'ont pas été abouties; le fil s'accumulaient au niveau du pistolet. Nous nous sommes rendus compte que nous n'avions pas configuré l'imprimante Prusa via le logiciel PrusaSlicer.

Voici les réglages que nous avons finalement utilisés :

Après plusieurs tentatives, nous avons finalement réussi à imprimer notre moulin.

Nous avons régalement mal modélisé le rayon du cercle portant les hélices. Il n'est pas parfaitement rond ce qui fait que la rotation n'est pas optimale. Néanmoins ce n'est pas un réel problème car il tourne malgré tout, ce qui était le but envisagé.

Pour finir, nous aurions préféré que le moulin soit plus "lisse". Nous saurons donc pour la prochaine fois que nous devrons réduire la hauteur de couche.