Éric Sauvé, CP en science et technologie à la CS de Laval, nous partage quelques-uns de ces projets documentés.

Merci du partage!

 

M. Patrice Boutin, commission scolaire des Navigateurs, nous partage ces documents en lien avec un projet de bras hydraulique où Arduino est intégré pour contrôler l’électro-aimant.

À noter que son projet, bien que vécu durant l’année scolaire 2017-2018, n’est pas encore clé en main. Patrice veut l’améliorer cette année (contrôler la direction du bras avec des moteurs, changer l’approche pédagogique, etc).

Par contre, les documents présents dans son dossier peuvent aider à se créer son propre projet.

Répertoire Google Disque partagé

Merci Patrice pour le partage et bonne chance pour la suite!

Claude Elmoznino nous propose sur son site des fiches (voir dans le menu – Exercices de base) permettant de réaliser une activité d’initiation à Arduino.

• Exercices de base
• Fiche 1
  • Fiche 1 théorie
• Fiche 2
  • Fiche 2 théorie

Fouiller un peu, il peut y avoir des ajouts!

Merci Claude pour le partage!

Mise à jour février 2021 

Voici des documents et formations en lien avec le simulateur Tinkercad.

• Premiers pas avec Arduino et Tinkercad
  • Voir cette section de l’autoformation à propos de Tinkercad Circuits.
  • Vous utilisez un Chromebook, voir cette section.

Nouveau projet de Claude Elmoznino.

«Le robot chenillette évite des obstacles. Les pièces de ce robot, disponibles gratuitement  pour téléchargement ont été réalisées avec une imprimante 3D.  Le circuit principal est un module Arduino doté du module supplémentaire ( L293N ), pour le fonctionnement des moteurs.  Le code de programmation est lui aussi téléchargeable gratuitement. Cette façon de réaliser des robots peu motiver les élèves et abaisse considérablement le coût final.»

Lire la suie sur le site de Claude Elmoznino, concepteur de ce projet. Naviguer dans le menu horizontal pour trouver d’autres documents en lien avec ce projet (Composantes, Pièces 3D, Code du projet).

Merci Claude pour le partage!

 

Le robot

Jean-François Garneau et Pierre Lachance ont préparé ce robot/bolide (non parfait) pour un atelier d’initiation à Arduino lors du colloque de l’AESTQ 2017. Les participants repartent avec le robot (prix coûtant).

Le but est ici d’avoir un robot préassemblé à 70% afin d’avoir du temps pour terminer les connexions et d’initier à sa programmation.

Le châssis est à imprimer à l’aide d’une imprimante 3D, voici le fichier STL utilisé. Ce châssis peut être imprimé sur des imprimantes qui ont une surface d’impression réduite (10 cm x 10 cm).

Montage

Matériel 

Châssis imprimé (fichier stl) Sur Tinkercad Dossier Inventor Carte Arduino Uno + fil USB Blindage capteurs Pont en H Capteurs de ligne (2) Bloc piles 3,7V avec 2 piles Interrupteur

Fiche mâle 2 moteurs + 2 roues 1 roue avant + essieu 10 fils Dupont F-F Vis et boulons Fils conducteurs (2 x ~25cm)

Capteur de ligne : Vous avez 2 capteurs de ligne dans votre matériel, vous pouvez en installer qu’un seul pour l’atelier. Utiliser les 3 broches numériques 8 où S = signal, V = alimentation 5V, G = mise à la terre.

Attention!!! Soyez rigoureux sur la gestion des bornes + et – de la pile.

Voici à quoi ressembleront les connexions de votre robot (sans les capteurs).

Programmation

On s’initie à la programmation de notre robot. Avec des élèves, à vous de voir ce que vous donnez ou non comme fichier de départ.

1. Vérifier la connexion de votre carte Arduino (Vidéo : Connexion à la carte Arduino Uno)
2. Utiliser Blockly@rduino pour ouvrir ce fichier ou ArduBlockly avec ce fichier
   1. Fichier ino (pour les programmeurs en mode texte!)
3. Ajuster les fonctions (avance, recule, etc.) pour être en mesure de faire réaliser ceci à votre robot :
   1. Avancer et reculer en ligne droite
   2. Tourner à droite, à gauche (environ 90°)
   3. Arrêter à la ligne (utilisation du capteur de ligne)
      1. La calibration du capteur de ligne se fait avec la vis sur le capteur. Plus facile à calibrer sans la roue (plus près du sol). La DEL rouge du capteur allume lorsque que la lecture est 0.
4. Avez-vous une idée de comment faire suivre une ligne à votre robot?

Liste du matériel pour le bolide

• Carte Arduino Uno r3 + fil USB  lot de 5 à 24$,  lot de 10 à 48$
• Blindage capteurs 1,50$
• Pont en H ici à ~ 2$
• Moteurs + roues lot 16 = 2,25$ pour 1 moteur et 1 roue
  • Support à moteur (optionnel) lot 15 à 12$
  • Boulons et écrous (optionnel) lot de 10 (M3 30mm) pour 2$ et lot 160 multiples pour 4$
• Bloc piles + piles (les 3.7 V sont longue durée : 1 chargeur  avec 6 piles à  13$ + 1 bloc à 1$
  • Autres piles
    • Bloc 4 piles AA : lot de 5 pour 4,16$ (excellent pour alimenter les moteurs
    • Bloc 6 piles AA (pour obtenir 9V) : 1,20$ (peut remplacer la pile 9V, et sera plus durable)
• Interrupteur lot 20 pour 3$
• Fiche mâle alimentation lot 10 pour 6$
• Capteur de ligne 5$ pour 6
• Roues 100 pour 22$
• Essieux 2,5” 0,50$ pour 2
• Peut être intéressant
  • Capteurs distance (lot 10) à 0,90$ l’unité
  • Capteur de son 5 pour 6$
  • Ensemble plus complet à 25$ (contient un châssis)
  • Chargeur à pile 3,7V à 4$

 

Arduino au primaire, est-ce possible? C’est ce que nous tenterons de déterminer avec ce projet de robot «roue de fortune» pour le primaire.

But : travailler les statistiques/probabilités au 3e cycle du primaire, en plus d’intégrer un peu de programmation, de la conception technologique (support, roue) et des circuits électriques.

Matériel

Voici une liste de matériel suggéré.

• Carte Arduino Uno lot de 10 à 68$  (besoin 1 carte par robot)
• Transistor lot de 10 à 8$ (besoin 1 transistor par robot)
• Moteur DC lot de 10 à 4,88$ (besoin 1 moteur par robot)
• Adapteur 9V lot de 10 à 4,20$ (pour alimenter la carte Arduino, besoin 1 adapteur par robot)
• Bloc pile AA x2 lot de 10 à 2,50$ (pour alimenter le moteur 3V)
• Fils Dupont F-M lot de 40 à 2,37$ (besoin de 3 fils par robot)

On peut ajouter à ce matériel un capteur (intensité lumineuse) afin d’ajouter un peu de complexité à notre robot (car sans capteur, ce n’est pas tout à fait un robot).

Montage

On veut que le robot fasse tourner une roue de fortune (à construire par les élèves selon les spécifications de l’enseignant) durant une durée prise au hasard.

Voici le circuit électrique :

Programmation

L’enseignant pourra donner les fichiers ci-dessous afin d’aider les élèves à démarrer leur programme. On peut aussi ne rien donner aux élèves et leur faire vivre un projet de programmation plus complet. À voir selon l’intention pédagogique.

• Version mBlock
• Versio Blockly@rduino

Note : Ce projet se vivra durant l’année scolaire 2017-2018 à la commission scolaire des Navigateurs. Nous documenterons davantage le projet durant l’année.

Étienne Roy, CS Beauce-Etchemin, a produit cette tâche (très complète pour initier les élèves à l’électronique Arduino) pour le cours de science et technologie ST et ATS.

Version 2016-2017 des documents.

En résumé, on ajoute des éléments électroniques/Arduino à un circuit/montage d’une décoration d’halloween. Ce qui ajoute au projet en électricité un peu de programmation, de capteurs, etc.

Merci Étienne pour le partage!

Arduino permet de réaliser plusieurs types de projets, nous décrivons ici (avec l’aide de Jean-François Garneau) comment utiliser une carte dérivée d’Arduino du nom de NodeMCU pour se créer un système contrôlé par wifi.

Attention! Ce projet n'est pas à faire programmer de zéro par les élèves (à moins qu'ils soient avancés en programmation), car on doit programmer en mode Arduino (texte), non pas en blocs. On peut leur (élèves 2e cycle du secondaire) demander de jouer (copier/coller/modifier) dans le programme par contre pour l'ajuster/améliorer...

Matériel

Voici le matériel de base pour se créer un petit bolide tout simple qui est téléguidé par wifi.

• Nodemcu à 10$
• Fil usb mini (exemple) 1m est suffisant
• Bloc pile pour alimenter les moteurs
• Adapteur 9V pour alimenter la carte
• Moteurs

Avec un peu d’imagination on peut contrôler plusieurs types de systèmes.

Montage

Voici le schéma pour connecter les moteurs et les sources de courant.

Photo d’un prototype dérivé de notre robot labyrinthe.

Avec ce châssis.

Programmation

Note : On ne peut pas programmer la carte NodeMCU avec Blockly@rduino.

La carte NodeMCU n’est pas reconnue par défaut par l’Arduino IDE. Voici comment l’ajouter.

Il faut se rendre sur ce site pour avoir la dernière version du lien à insérer dans les préférences du logiciel Arduino IDE. Ce lien ressemble à ceci (il doit toujours être présent dans les préférences pour que la carte soit accessible) :

http://arduino.esp8266.com/stable/package_esp8266com_index.json

Coller ce lien dans le menu «préférences – URL de gestionnaire de cartes supplémentaires». Enregistrer les préférences.

Par la suite, dans le menu «Outils – Type de carte – Gestionnaire de cartes», rechercher ESP8266 et installer la carte proposée. Voir l’image animée ci-dessous pour les détails.

Le programme

Note : Des librairies (voir le programme pour leurs noms) seront à ajouter à votre logiciel Arduino IDE, voir la vidéo ci-dessous pour le tutoriel.

 

Voici le programme, inspiré des liens dans le haut du script, qu’a fait Jean-François Garneau (CSDPS):

/* Inspiré de http://arduino-er.blogspot.ca/2016/05/nodemcuesp8266-implement.html
ainsi que http://arduino-er.blogspot.ca/2016/05/nodemcuesp8266-act-as-ap-access-point_3.html
*/

/* adresse à insérer dans le navigateur après être connecté au bolide
 * 192.168.4.1
 */
// include libraries, voir tutoriel https://www.youtube.com/watch?v=poAKFeqIaYI
#include <ESP8266WiFi.h>
#include <WiFiClient.h> 
#include <ESP8266WebServer.h>
//les éléments à modifier au besoin
int vitesse = 1023; // valeur entre 1 et 1023 pour la vitesse du moteur
const char *ssid = "bolide01"; //nom du réseau wifi du bolide
const char *password = "bolide01";//mot de passe pour accéder au bolide
 
// configure server
ESP8266WebServer server(80);

//Construction de la page Web. Changer le titre de la page web ci-dessous (nom du bolide), à vous de mettre ça beau!

const char *form = "<center><form action='/'>"
"<h1 style='font-size:5em'>Bolide 01</h1><br><br>"
"<br><br><br><button name='dir' style='font-size:3em;padding:1em' type='submit' value='4'>Avance</button><br><br><br>"
"<button name='dir' style='font-size:3em;padding:1em;margin-right:2em' type='submit' value='1'>Gauche</button>"
"<button name='dir' style='font-size:3em;padding:1em' type='submit' value='2'>Droite</button><br><br><br><br>"
"<button name='dir' style='font-size:3em;padding:1em' type='submit' value='3'>Recule</button><br><br><p>"
"<button name='dir' style='font-size:3em;padding:1em' type='submit' value='5'>Arret</button>"
"</form></center>";
 
void stop(void)
{
 analogWrite(5, 0);
 analogWrite(4, 0);
}
 
void forward(void)
{
 analogWrite(5, vitesse);
 analogWrite(4, vitesse);
 digitalWrite(0, HIGH);
 digitalWrite(2, HIGH);
}
 
void backward(void)
{
 analogWrite(5, vitesse);
 analogWrite(4, vitesse);
 digitalWrite(0, LOW);
 digitalWrite(2, LOW);
}
 
void left(void)
{
 analogWrite(5, vitesse);
 analogWrite(4, vitesse);
 digitalWrite(0, LOW);
 digitalWrite(2, HIGH);
}
 
void right(void)
{
 analogWrite(5, vitesse);
 analogWrite(4, vitesse);
 digitalWrite(0, HIGH);
 digitalWrite(2, LOW);
}
 
void handle_form()
{
 // only move if we submitted the form
 if (server.arg("dir"))
 {
 // get the value of request argument "dir"
 int direction = server.arg("dir").toInt();
 
 // chose direction
 switch (direction)
 {
 case 1:
 left();
 break;
 case 2:
 right();
 break;
 case 3:
 backward();
 break;
 case 4:
 forward();
 break;
 case 5:
 stop();
 break;
 }
 
 // move for 300ms, gives chip time to update wifi also
 delay(300);
 }
 
 // in all cases send the response 200ms
 server.send(1, "text/html", form);
}
 
void setup()
{
 delay(200);
 Serial.begin(9600);
 Serial.println();

 WiFi.softAP(ssid, password);

 IPAddress apip = WiFi.softAPIP();
 Serial.print("visit: \n");
 Serial.println(apip);
 
 // set up the callback for http server
 server.on("/", handle_form);
 
 // start the webserver
 server.begin();
 
 pinMode(5, OUTPUT); // 1,2EN aka D1 pwm left
 pinMode(4, OUTPUT); // 3,4EN aka D2 pwm right
 pinMode(0, OUTPUT); // 1A,2A aka D3
 pinMode(2, OUTPUT); // 3A,4A aka D4
}
 
void loop()
{
 // check for client connections
 server.handleClient();
}

 

Utilisation du robot

Le programme est téléversé dans la carte, vous pouvez donc allumer les sources de courant pour le démarrer. Le bolide devient donc une borne d’accès wifi avec le nom bolidexx et mot de passe bolidexx (à modifier pour chaque robot de votre classe). Connectez vous à votre bolide et rendez-vous à l’adresse 192.168.4.1 dans un navigateur. Une page Web avec des boutons «Avance, recule, gauche, droite, arrêt» seront présent et contrôleront votre robot.

Amusez-vous!

Plus loin?

Le programme ci-haut peut être modifié pour mieux répondre à vos besoins. Par exemple on pourrait faire avancer seulement pendant un certain temps le robot lorsqu’on clique sur le bouton «avance» pour lui faire parcourir une courte distance à chaque clic. On pourrait ajouter des DEL à notre robot et les contrôler (allumer, éteindre, clignoter…) aussi par wifi. Des capteurs pourraient être ajouter. Bien des défis pour vos classes!

Mme Annick Lambert, conseillère pédagogique à la CS de Portneuf, a produit ces documents d’initiation à la robotique Arduino (Blockly@rduino, Circuits.io, Arduino IDE, etc) pour des élèves de 4e secondaire.

 

Les documents

Le robot utilisé dans ce projet avec les élèves est le suivant. Le courageux enseignant qui se lancera dans cette tâche est Mathieu Robitaille. Photos et notes à venir…

Merci beaucoup pour le partage!

 

 

Un autre projet que M. Claude Elmoznino rend disponible sur son site.

Description tiré du site :

«Le robot suit une ligne noire sur fond clair ou un fond de couleur blanche. Les pièces de ce robot, disponibles gratuitement  pour téléchargement ont été réalisées avec une imprimante 3D.  Le circuit principal est un module Arduino sans module supplémentaire afin de simplifier la conception. Parce qu’on utilise pas de module supplémentaire, la propulsion est assurée par deux servos moteurs.  Le code de programmation est lui aussi téléchargeable gratuitement. Le coût pour la réalisation du projet est d’environ  20$ CAN.»

Merci Claude pour le partage!

Bon Arduino!

Note aux débutants : La présente documentation a pour but d’inspirer, non pas d’être copiée-collée sans comprendre le programme et les circuits. Car le copier-coller en Arduino ne fonctionne pas nécessairement.

La technologie Arduino permet de réaliser plusieurs types de robots. Mais un bolide reste un bolide, on aime le voir rouler et interagir avec son environnement. Nous proposons ici un bolide qui peut être acheté en «kit» (celui que nous avons utilisé).

Note : Nous avons une liste de pièces nécessaires pour créer un ensemble de formation pour les enseignants (autre que l’ensemble de démarrage Arduino) qui permettrait de s’approprier la robotique Arduino tout en construisant (et améliorant) un robot.

Montage

L’assemblage du robot n’est pas très compliqué, voici les quelques étapes pour obtenir ce robot.

Voici le matériel de notre ensemble (cliquer sur les images pour agrandir). Retirer le protecteur collant des pièces de plastique. À noter que nous ajoutons à ce matériel une pile 9V et un connecteur pour alimenter la carte UNO.

 

Étape 1 : Souder des fils (nous récupérons les fils réseau pour ce genre de connexion) sur les moteurs et utiliser de la colle chaude pour solidifier le tout. Puis boulonner les moteurs à l’aide des pièces fournies.

Étape 2 : Installer le bloc pile et la roue avant du robot comme dans l’image ci-dessous.

Étape 3 : Souder l’interrupteur au bloc pile (qui alimentent les moteurs).

Étape 4 : Assembler la carte Arduino UNO et son blindage fourni. Le blindage facilite les connexions vers des capteurs, les moteurs, etc.

Étape 5 : Assembler le servomoteur et le radar. Des petites vis fournies permettent de fixer le tout.

La base du support du servomoteur peut être fixée de diverses façons (vis, colle, gommette…). On obtient le support (blanc ici) en découpant une des pièces fournies avec le servomoteur. Nous l’avons collé avec de la colle chaude (pour pouvoir démonter au besoin).

Le capteur à ultrason (radar) peut être fixé à l’aide d’un élastique comme ci-dessous.

Pour finalement pouvoir monter le tout sur le châssis du robot (pour augmenter la solidité de cette pièce, un peu de colle chaude fera l’affaire).

Étape 6 : Nous pouvons maintenant connecter les moteurs au pont en H (L298N). Voici les connexions à réaliser.

Pour connecter les broches IN1, IN2,IN3,IN4 du pont en H, nous avons utilisé des fils Dupont femelles. À noter également que nous avons relié la mise à la terre de la carte UNO à celui du pont en H.

Étape 7 : Connecter le capteur ultrason à la carte UNO comme ci-dessous.

Pont en H	Fils	UNO
Vcc	Orange	V
Trig	Jaune	9
Echo	Vert	8
Gnd	Bleu	G

Étape 8 : Connecter le servomoteur (qui servira à orienter le capteur ultrason dans un projet de programmation plus complexe) à la carte UNO comme ci-dessous.

Fils du servomoteurs	UNO
Brun	G
Rouge	V
Orange	S (11)

 

 

Programmation

La programmation peut être comme celle du robot labyrinthe déjà documenté. Voici à quoi ressemble notre programmation de base (le capteur ultrason mesure la distance, si la distance est supérieure à 25 cm le robot avance, sinon il recule et tourne).

 

Version XML (importable dans http://recitmst.qc.ca/blockly@rduino/).

Le code Arduino est le suivant :

float cm;
int lecture_echo;

void Avance() {
  digitalWrite(7, LOW);
  digitalWrite(6, HIGH);
  digitalWrite(5, HIGH);
  digitalWrite(4, LOW);
}

void Recule() {
  digitalWrite(7, HIGH);
  digitalWrite(6, LOW);
  digitalWrite(5, LOW);
  digitalWrite(4, HIGH);
}

void TourneGauche() {
  digitalWrite(7, HIGH);
  digitalWrite(6, LOW);
  digitalWrite(5, HIGH);
  digitalWrite(4, LOW);
}

void TourneDroite() {
  digitalWrite(7, LOW);
  digitalWrite(6, HIGH);
  digitalWrite(5, LOW);
  digitalWrite(4, HIGH);
}

void Arrete() {
  digitalWrite(7, LOW);
  digitalWrite(6, LOW);
  digitalWrite(5, LOW);
  digitalWrite(4, LOW);
}


void setup() {
  Serial.begin(9600);
  pinMode(9, OUTPUT);
  pinMode(8, INPUT);
    digitalWrite(9, LOW);
  cm = (float)(0);
  lecture_echo = (int)(0);

  pinMode(7, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(4, OUTPUT);
}

void loop() {
    digitalWrite(9, HIGH);
    delay(10);
    digitalWrite(9, LOW);
    lecture_echo = (int)(pulseIn(8,HIGH));
    cm = (float)(lecture_echo / 58);
    Serial.print(cm);
    delay(10);
    if (cm > 25) {
      Avance();

    } else {
      Arrete();
      delay(1000);
      Recule();
      delay(1000);
      TourneGauche();
      delay(300);
      Arrete();
      delay(1000);

    }

}

 

Suite du projet

À ce robot nous pouvons ajouter divers capteurs (intensité lumineuse, son, couleur, position en fonction du temps…) ainsi que d’autres moteurs (bras, treuil, etc.) afin de le rendre plus complet. En ce faisant par contre, nous complexifions la programmation. À vous de voir jusqu’où vous désirez aller avec ce robot.

Claude Elmoznino nous propose un robot Arduino qui peut suivre la lumière.

La documentation se trouve sur son site Web https://robotticblog.wordpress.com/le-robot-qui-suit-la-lumiere/

Merci Claude pour le partage!

Dans ce projet (en développement), nous voulons recueillir des données météo avec notre carte Arduino UNO. Nous avons les capteurs suivants : BMP180 (pression atmosphérique et température), DHT11 (ou DHT22 pour les températures sous 0°C) (humidité relative et température), intensité lumineuse. Nous écrivons les données sur une carte SD.

Note : Il est possible d’ajouter des capteurs, comme une sonde de pluie, anémomètre, orientation du vent (boussole). Mais à chaque sonde ajoutée, le projet se complique légèrement. Mais on peut comparer plus de données (investigation scientifique).

Note aux débutants : La présente documentation a pour but d’inspirer, non pas d’être copiée-collée sans comprendre le programme et les circuits. Car le copier-coller en Arduino ne fonctionne pas nécessairement.

Le matériel

Voici la liste du matériel utilisé dans le projet. Voir ce document pour des liens vers des suggestions d’achat.

• Carte Arduino UNO
• Blindage carte SD
• Blindage platine d’expérimentation
• Piles 3,7 V + bloc piles
• Interrupteur
• Fiche mâle 9 V
• Capteur : BMP180, DHT11 ou DHT22 (mesure de température moins bonne que BMP180), intensité lumineuse
• DEL rouge
• Panneaux solaires (Ne pas utiliser avec les piles 3,7 V au Lithium ion, risque de surcharge et d’explosion)
• Cabane d’oiseau (pour accueillir le matériel) réalisée par ma fille

Photo du matériel de base (cliquer sur image pour agrandir).

Le montage

Voici les connexions pour les capteurs. Voir les différentes pages en lien avec les capteurs traités individuellement pour plus de détails.

Capteur BMP180	Carte UNO
VIN	3,3V
GND	GND
SCL	SCL ou A5
SDA	SDA ou A4

Capteur DHT11	Carte UNO
VCC	5V
Data	D 3
GND	GND

Intensité lumineuse	Carte UNO
–	GND
S	A0
centre	5V

 

La programmation

Note : Voir au bas de la page pour télécharger les trois libriairies nécessaires pour faire fonctionner le programme ci-dessous.

Nous avons «assemblé» les programmes déjà documentés pour la gestion des diverses sondes. Voici notre version en test (3 juin 2016).

/*Projet station météo de base
Voir les liens pour plus de détails sur chaque partie du projet
Écrire des données sur une carte SD

Pression atmosphérique

Capteur humidité et température ambiante

Intensité lumineuse et distance


RÉCIT MST 2016, version du 3 juin 2016
*/

//Capteur BMP180 - pression et température
#include <Wire.h>
#include <BMP180.h>
// création objet
BMP180 barometer;

//Capteur DHT11 - humidité relative et température
#include <dht.h>
#define dht_apin 3 // Capteur connecté à la borne numérique 3 
dht DHT;

//Carte SD et horloge
#include <SPI.h>
#include <SD.h>
File fichierSD;
#include "RTClib.h"
RTC_DS1307 rtc;

//Capteur intensité lumineuse. ATTENTION, plus la valeur du capteur est grande, moins l'intensité lumineuse est grande.
#define int_lum A0 

#define del_rouge 4
#define duree 600000 //durée entre les mesures en ms, ici 10 min

void setup()
{
 // Démarrage de la communication avec le moniteur série
 Serial.begin(57600);
 
 //Pour le capteur DHT11===============================
 pinMode(dht_apin, INPUT);

 //Pour capteur intensité lumineuse
 pinMode(int_lum, INPUT);

 //Pour DEL rouge
 pinMode(del_rouge,OUTPUT);
 
 //Initialisation de l'instance de la carte SD===================
 if(!SD.begin(10)) { //pour la broche utilisée par votre carte voir http://www.worldofgz.com/electronique/ecrire-et-lire-des-donnees-sur-une-carte-sd/
 Serial.println(F("Initialisation impossible !"));
 digitalWrite(del_rouge,HIGH);//DEL rouge pour problème
 return;
 }
 else {
 Serial.println(F("Initialisation OK"));
 }

 delay(500);//On donne du temps pour démarrer
 // Démarrage de la communication I2C avec le capteur BMP180===============
 Wire.begin();
 
 // on démarre la fonction de lecture du baromètre
 barometer = BMP180();
 // vérification si le capteur est présent et fonctionnel
 if(barometer.EnsureConnected())
 {
 Serial.println("Connection au BMP180 OK."); // Envoyer sur le moniteur série
 // Lorsque connecté, on réinitialise (reset) le capteur
 barometer.SoftReset();
 // On initialise le capteur
 barometer.Initialize();
 }
 else
 { 
 Serial.println("Pas de capteur.");
 digitalWrite(del_rouge,HIGH);//DEL rouge pour problème
 }
}

void loop()
{

 // Lecture des capteurs.
 long currentPressure = barometer.GetPressure();
 float currentTemperature = barometer.GetTemperature();
 DHT.read11(dht_apin);
 moniteur();//on envoie les données sur moniteur série pour vérifier si ça fonctionne
 
 //Écrire sur carte SD
 //Ouverture du fichier
 fichierSD = SD.open("meteo.txt", FILE_WRITE);
 
 //Test pour écriture
 if(fichierSD) {
 Serial.println(F("Ecriture en cours"));
 //Ecriture : 
 maintenant();//fonction qui écrit la date et heure de la prise de donnée
 fichierSD.print(',');//séparateur
 fichierSD.print(currentPressure);
 fichierSD.print(',');//séparateur
 fichierSD.print(currentTemperature);
 fichierSD.print(',');//séparateur
 fichierSD.print(DHT.humidity);
 fichierSD.print(',');//séparateur
 fichierSD.print(DHT.temperature); 
 fichierSD.print(',');//séparateur
 fichierSD.println(analogRead(int_lum));
 fichierSD.close();
 }
 else {
 digitalWrite(del_rouge,HIGH);//DEL rouge pour problème
 }
 
 delay(duree); // Attendre «duree» avant prochaine lecture.
 
}

//Fonction qui écrit la date et l'heure dans le fichierSD===
void maintenant() {
 DateTime now = rtc.now();
 
 fichierSD.print(now.year(), DEC);
 fichierSD.print('/');
 fichierSD.print(now.month(), DEC);
 fichierSD.print('/');
 fichierSD.print(now.day(), DEC);
 fichierSD.print(' ');
 fichierSD.print(now.hour(), DEC);
 fichierSD.print(':');
 fichierSD.print(now.minute(), DEC);
 fichierSD.print(':');
 fichierSD.print(now.second(), DEC);
}

//Fonction pour envoyer données sur moniteur série, test
void moniteur(){
 // Lecture des capteurs.
 long currentPressure = barometer.GetPressure();
 float currentTemperature = barometer.GetTemperature();
 DHT.read11(dht_apin);
 
 // Envoyer la pression au moniteur série
 Serial.print("Pression: ");
 Serial.print(currentPressure);
 Serial.print(" Pa");
 
 // Envoyer la température au moniteur série
 Serial.print("\tTemperature: "); // \t fait une tabulation
 Serial.print(currentTemperature);
 Serial.print("°C");
 
 //Sonde DHT11

 Serial.print("\tHumidité = ");
 Serial.print(DHT.humidity);
 Serial.print("% ");
 Serial.print("\tTempérature 2 = ");//deux capteurs nous donne une température
 Serial.print(DHT.temperature); 
 Serial.print("°C ");
 
 //sonde intensité lumineuse
 Serial.print("\tIntensité lumineuse = ");
 Serial.print(analogRead(int_lum));
 
 Serial.println(); // Démarrer une nouvelle ligne.
}

Librairies nécessaires pour faire fonctionner le programme ci-haut.

Le capteur BMP180 nous permet de mesurer la pression atmosphérique et la température ambiante. De plus, la librairie nécessaire à son utilisation calcule l’altitude également.

Note: Ce calcul n’est pas très pertinent pour une station météo (qui ne bouge pas), car la pression atmosphérique varie continuellement. Donc le calcul n’est bon que pour une courte période de temps après avoir inséré la valeur de pression atmosphérique de votre localité.

Montage

ATTENTION! Le capteur fonctionne sur le 3,3V, NE PAS brancher sur le 5V!

Voici les connexions à réaliser.

Capteur	Carte UNO
VIN	3,3V
GND	GND
SCL	SCL ou A5
SDA	SDA ou A4

À noter que l’on peut connecter les broches SCL et SDA à deux endroits différents sur la carte.

Programmation

La librairie utilisée peut être télécharger au bas de la page (Il en existe d’autres, à vous de voir).

Le code de base pour lire la pression, l’altitude et la température est le suivant (code présent dans le répertoire «BMP180_Example» du fichier compressé de la librairie ci-haut) :

 

#include <Wire.h> //Permet la communication I2C https://www.arduino.cc/en/Reference/Wire
#include <BMP180.h> //librairie pour le capteur

// création objet
BMP180 barometer;
// Utilisation du LED sur la carte pour indiquer si capteur OK
int indicatorLed = 13;

// Pression atmosphérique au niveau de la mer, voir météo locale pour cette donnée
float seaLevelPressure = 102100;

void setup()
{
 // Démarrage de la communication avec le moniteur série
 Serial.begin(9600);
 // Démarrage de la communication I2C avec le capteur
 Wire.begin();
 // initialisation de la DEL.
 pinMode(indicatorLed, OUTPUT);
 // on démarre la fonction
 barometer = BMP180();
 // vérification si le capteur est présent et fonctionnel
 if(barometer.EnsureConnected())
 {
 Serial.println("Connexion au BMP180 OK."); // Envoyer sur le moniteur série
 digitalWrite(indicatorLed, HIGH); // Allumer la DEL
 
 // Lorsque connecté, on réinitialise (reset) le capteur
 barometer.SoftReset();
 // On initialise le capteur
 barometer.Initialize();
 }
 else
 { 
 Serial.println("Pas de capteur.");
 digitalWrite(indicatorLed, LOW); // Ferme la DEL
 }
}

void loop()
{
 if(barometer.IsConnected)
 {
 // Mesure de la pression en Pascal.
 long currentPressure = barometer.GetPressure();
 
 // Envoyer la pression au moniteur série
 Serial.print("Pression: ");
 Serial.print(currentPressure);
 Serial.print(" Pa");
 
 // Caclule de l'altitude (en mètre), nécessite la pression au niveau de la mer de votre position
 float altitude = barometer.GetAltitude(seaLevelPressure);
 
 // Envoyer l'altitude au moniteur série
 Serial.print("\tAltitude: ");
 Serial.print(altitude);
 Serial.print(" m");
 
 // Mesurer la température (°C)
 float currentTemperature = barometer.GetTemperature();
 
 // Envoyer la température au moniteur série
 Serial.print("\tTempérature: ");
 Serial.print(currentTemperature);
 Serial.print("°C");
 
 Serial.println(); // Démarrer une nouvelle ligne.
 delay(1000); // Attendre 1 s avant prochaine lecture.
 }
}

Vérifier les données

Des données de notre position.

Le site http://fr-ca.topographic-map.com/ permet d’avoir l’altitude de votre position. Vous pourrez alors vérifier si les calculs de l’altitude sont corrects.

Des applications mobiles peuvent vous aider à valider les données recueillies (baromètre, altitude) par votre montage.

Librairie BMP180

L’analyse du mouvement d’un bolide offre plusieurs possibilités d’apprentissages pour le 2e cycle du secondaire. Dans la présente page, nous vous proposons un plan pour faire construire des robots qui ont pour but d’écrire sur une carte mémoire la position du bolide en fonction du temps.

Note aux débutants : La présente documentation a pour but d’inspirer, non pas d’être copiée-collée sans comprendre le programme et les circuits. Car le copier-coller en Arduino ne fonctionne pas nécessairement.

PFEQ

Ce projet peut être construit par des élèves du 1er ou 2e cycle du secondaire (projet technologique) et exploité (données) en 4e secondaire, science et technologie (ATS) ainsi qu’en mathématique (TS).

En ajoutant un accéléromètre pour avoir les valeurs d’accélération instantanée (en x, y, z), le bolide devient intéressant pour le cours de physique 5e secondaire (les analyses du mouvement sur un plan incliné, F=ma, etc.). On peut travailler le frottement également en attachant une masse (faire varier la surface de contact, la masse, etc.) derrière le bolide pour avoir une autre valeur d’accélération.

Mise à jour 19 avril : Voir ce fichier GeoGebra pour une analyse de données recueillies avec le bolide. Ce fichier contient des calculs pour trouver l’accélération (physique 5e secondaire).

Construction

Attention! Afin d’éviter des bris (suite à la manipulation fréquente des pièces) voir ces conseils.

Comme pour la plupart des projets avec Arduino, nous avons besoin de matériel électronique ainsi que d’autres pièces comme des roues, un châssis, etc. Voici la liste que nous vous proposons.

Matériel

Note : Les liens ci-dessous sont à titre indicatif, d’autres fournisseurs peuvent avoir de meilleurs prix.

1. Roues (elles doivent être insérées dans l’encodeur)
2. Essieux (on peut les couper à la bonne longueur)
3. Rondelles (optionnelles : elles serviront à diminuer le frottement entre les roues et le châssis)
4. Bloc piles avec interrupteur (permet de démarrer la saisie avec son interrupteur, mais les piles doivent être chargée, voir cet article pour l’alimentation d’une carte Arduino)
   1. Autre choix : pile 9V et ce connecteur
   2. Autre choix : 2 piles 3.7 V (chargeur et piles, bloc, piles)
5. Blindage pour acquisition des données
6. Module Arduino
7. Encodeur (c’est ce qui nous permet de mesurer la distance parcourue)
8. Châssis (plusieurs types de matériaux peuvent être utilisés ici, nous vous suggérons ceci. Si vous avez une imprimante 3D, imprimez!)
9. Total : environ 25$ (si on en fait une dizaine)

Notre montage utilise ici une demi-descente de gouttière comme châssis. Peu dispendieux, suffisamment solide, peut être facilement percé, ce châssis répond à nos critères (besoins pour le présent robot).

Le dessous du bolide contient le capteur boulonné au châssis. Nous avons retiré la roue pour ne garder que les rayons qui passent entre l’émetteur et le récepteur infrarouge (5 interruptions par tour de roue).

On peut également utiliser une roue ( 0,20$ par roue) comme l’image ci-dessous pour augmenter le nombre d’obstacles (interruptions) par tour de roue. Des tests seront à réaliser pour valider si la précision est meilleure.

Schéma électrique

Le schéma électrique est assez simple, nous utilisons le blindage «data logging» présenté/documenté dans cet article pour inscrire les données sur une carte SD. Le capteur utilisé est nommé «speed sensor», il nous permet de compter le nombre de fois qu’un objet passe entre son émetteur infrarouge et son récepteur.

Note : Nous utilisons ici la sortie A0 (connectée à la broche numérique 2 de l’Arduino) sur le capteur, car la sortie D0 (numérique) ne fonctionne pas correctement(nous cherchons pourquoi).

Capteur

Le capteur envoie un signal lorsque passe un obstacle entre son émetteur et son récepteur infrarouge qui est compté grâce à la fnct_compter (voir https://www.arduino.cc/en/Reference/AttachInterrupt ). On affiche sur le moniteur série le nombre d’interruptions total à toutes les secondes. Voici le code (merci à Jean-François Garneau pour son aide) :

int compteur = 0 ;

void setup() {
 attachInterrupt(0, fnct_compter, RISING ); // broche numérique 2
 Serial.begin(9600); 
}

void fnct_compter() { //on ajoute +1 à chaque interruption envoyée par le capteur
 compteur++;
}

void loop() {
 Serial.println( compteur );
delay(1000);
}

 

Calcul distance

Pour connaître la distance parcourue par le bolide il faut trouver la formule qui permettra de la calculer. Les variables sont la circonférence de la roue, nombre d’obstacles (interruption du capteur) par tour de roue. À vous de jouer!

Programmation

Nous avons maintenant tous les morceaux pour programmer notre robot à entrer des données de position en fonction du temps. Voici notre programme commenté (si vous avez des questions, n’hésitez pas à nous contacter à pierres@recitmst.qc.ca) :

 

/*Exemple de code pour prendre des données et les écrire sur une carte SD 
RÉCIT MST 2016, version du 21 avril 2016
Inspiration http://www.worldofgz.com/electronique/ecrire-et-lire-des-donnees-sur-une-carte-sd/
http://tiptopboards.free.fr/arduino_forum/viewtopic.php?f=5&t=68
http://forum.arduino.cc/index.php?topic=107367.0
*/
#include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include "RTClib.h"

RTC_DS1307 rtc;

File fichierSD;

int initial;
int compteur = 0 ;
unsigned long time;
double duree;
float distance;

void setup() {
 Serial.begin(9600);
 pinMode(6,OUTPUT);
 pinMode(5,OUTPUT);
 initial=1;
//Pour la carte SD=======================================
 //Initialisation de l'instance
 if(!SD.begin(10)) {//10 pour notre carte, peut etre different
 Serial.println(F("Initialisation impossible !"));
 initial=0;
 return;
 }
 Serial.println(F("Initialisation OK"));
//Fin carte SD====================================================

//Pour l'horloge===============================================
 #ifdef AVR
 Wire.begin();
 #else
 Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino Due
 #endif
 rtc.begin();

 if (! rtc.isrunning()) {
 Serial.println("RTC ne fonctionne PAS!");
 // La ligne qui suit ajuste le RTC à la date et time du moment de compilation(si connectee a ordinateur)
 rtc.adjust(DateTime(__DATE__, __TIME__));
 }
//Fin horloge======================================================

//Pour le capteur ===============================================
 pinMode(2, INPUT_PULLUP);//broche numérique 2 sur Arduino
 attachInterrupt(digitalPinToInterrupt(2), fnct, CHANGE);
 
//Fin capteur

}

void loop() {
 time = millis(); //pour augmenter la précision des données (si nécessaire)
 DateTime now = rtc.now();
 distance = compteur*0.136425648; //formule pour notre bolide donne distance en cm, à vous de trouver la vôtre ;-)
 duree = time/1000.0;
//On envoie dans le moniteur série l'info écrite, pour vérifier si tout fonctionne
 /* Serial.print(now.year(), DEC);
 Serial.print('/');
 Serial.print(now.month(), DEC);
 Serial.print('/');
 Serial.print(now.day(), DEC);
 Serial.print(' ');
 Serial.print(now.hour(), DEC);
 Serial.print(':');
 Serial.print(now.minute(), DEC);
 Serial.print(':');
 Serial.print(now.second(), DEC);
 Serial.print(';');
 Serial.print(duree);//On inscrit la durée depuis le début du programme
 Serial.print(";");
 Serial.println(distance);
*/
//On nomme le fichier selon la date, donc toutes les donnees prises le meme jour dans un seul fichier==========
 char datafile[13];
 int jour=now.day();
 int mois = now.month();
 int annee= now.year(); 
 sprintf(datafile,"%02d%02d%04d.csv",jour,mois,annee); // %d pour un int, 2 pour 2 chiffres
 datafile[13]='\0';
//Fin nommer fichier===============================================

//Ouverture du fichier==============================================
 fichierSD = SD.open(datafile, FILE_WRITE);
 

 //Test pour écriture
 if(fichierSD && initial==1) {

 Serial.println(F("Ecriture en cours"));
 digitalWrite(6,HIGH);//DEL verte pour OK
 //Ecriture
 maintenant();//fonction qui écrit la date et heure de la prise de donnée
 fichierSD.print(',');//séparateur = , pour importation simple dans Geogebra voir https://www.geogebra.org/m/3230177
 fichierSD.print(duree,3);//On inscrit la durée depuis le début du programme. print(val,NOMBRE_DECIMAL)
 fichierSD.print(",");
 fichierSD.println(distance);//distance en cm
 fichierSD.close();
 }
 else { analogWrite(5,255);//DEL rouge pour problème
 
 }
 //Fermeture du fichier avec une ligne de plus============
 
 delay(10);//on laisse respirer le robot, mais on prend le plus de données possible.
}

//Fonction qui écrit la date et l'heure dans le fichierSD===
void maintenant() {
 DateTime now = rtc.now();
 
 fichierSD.print(now.year(), DEC);
 fichierSD.print('/');
 fichierSD.print(now.month(), DEC);
 fichierSD.print('/');
 fichierSD.print(now.day(), DEC);
 fichierSD.print(' ');
 fichierSD.print(now.hour(), DEC);
 fichierSD.print(':');
 fichierSD.print(now.minute(), DEC);
 fichierSD.print(':');
 fichierSD.print(now.second(), DEC);
}

//Fonction pour le capteur===================================
void fnct() {
 compteur++;
}

 

 

Bonne saisie de données!

Arduino peut récupérer des données à l’aide de capteurs (humidité, température, intensité lumineuse, etc.). Il est intéressant d’avoir les données dans le moniteur série, mais si on veut pouvoir prendre des données sans être connecté à un ordinateur, nous aurons besoin d’un blindage nommé «data logging shield». Ce blindage (carte supplémentaire qui se connecte directement sur la carte Arduino) permet d’écrire des données sur une carte SD, donc de pouvoir créer un montage autonome. Une horloge interne, alimentée par une pile, permet de garder l’heure.

Gestion de l’horloge

Afin de lier les données du capteur à l’heure de la mesure, le blindage utilisé nous offre la possibilité d’utiliser une horloge interne. Voir les liens suivants pour plus de détails :

• http://tiptopboards.free.fr/arduino_forum/viewtopic.php?f=5&t=68
• http://www.worldofgz.com/electronique/gerez-lheure-date-arduino-rtc/

En résumé, nous avons besoin de télécharger la librairie RTClib (voir au bas de la présente page), et de se faire un petit code (pris dans un lien ci-haut) comme celui-ci :

 

//Mise à l'heure RTC http://www.worldofgz.com/electronique/gerez-lheure-date-arduino-rtc/

#include <Wire.h>
#include "RTClib.h"
RTC_DS1307 RTC; //Classe RTC_DS1307
void setup () {
 Serial.begin(57600); //Démarrage de la communication
 Wire.begin(); //Démarrage de la librairie wire.h
 RTC.begin(); //Démarrage de la librairie RTClib.h
 
 //Si RTC ne fonctionne pas
 if (! RTC.isrunning()) {
 Serial.println("RTC ne fonctionne pas !");
 
 //Met à l'heure à date à laquelle le sketch est compilé
 RTC.adjust(DateTime(__DATE__, __TIME__)); 
 //Cela fonctionne également :
 //RTC.adjust(DateTime("Dec 5 2012","12:00:00")); 
 //RTC.adjust(DateTime(2014, 1, 21, 3, 0, 0));
 }
 }
void loop() {
 //Affichage de l'heure
 DateTime now = RTC.now();
 Serial.print(now.day(), DEC);
 Serial.print('/');
 Serial.print(now.month(), DEC);
 Serial.print('/');
 Serial.print(now.year(), DEC); 
 Serial.print(' ');
 Serial.print(now.hour(), DEC);
 Serial.print(':');
 Serial.print(now.minute(), DEC);
 Serial.print(':');
 Serial.print(now.second(), DEC);
 Serial.println();
 delay(3000);
}

Ouvrir le moniteur série pour visualiser les données.

Gestion de la carte SD

Maintenant qu’on peut gérer l’heure, voyons comment inscrire nos données sur la carte SD.

Les détails dans les liens suivants:

• http://www.worldofgz.com/electronique/ecrire-et-lire-des-donnees-sur-une-carte-sd/
• http://tiptopboards.free.fr/arduino_forum/viewtopic.php?f=5&t=68

En résumé, nous devons avoir des données à inscrire, voici le montage utilisé (un capteur d’intensité lumineuse sur l’entrée analogique A0).

Ensuite, pour le programme, nous devons inclure deux librairies (déjà présente dans l’IDE d’Arduino), soit SPI.h et SD.h. Ensuite, après l’activation de la communication, nous devons ouvrir le fichier, écrire une ligne dans le fichier, fermer le fichier. Voici le code exemple :

/* Lien vers le code http://www.worldofgz.com/electronique/ecrire-et-lire-des-donnees-sur-une-carte-sd/
Essais écriture carte SD 
Gloup - 05/05/2015
www.worldofgz.com
*/
#include <SPI.h>
#include <SD.h>

File fichierSD;
int sensorValue;
void setup() {
 Serial.begin(57600);
 
 //Initialisation de l'instance
 if(!SD.begin(10)) {
 Serial.println(F("Initialisation impossible !"));
 return;
 }
 Serial.println(F("Initialisation OK"));
}
void loop() {
 sensorValue = analogRead(A0);
 Serial.println(sensorValue);
 
 //Ouverture du fichier
 fichierSD = SD.open("analog.txt", FILE_WRITE);
 
 //Test pour écriture
 if(fichierSD) {
 Serial.println(F("Ecriture en cours"));
 //Ecriture
 fichierSD.println(sensorValue);
 fichierSD.close();
 }
 
 delay(1000);
}

Un fichier analog.txt est créé sur la carte, et les valeurs d’intensité lumineuse y sont inscrites tant que le montage est alimenté.

Création d’un fichier CSV

Le format CSV est intéressant, car il peut être ouvert facilement dans un tableur pour créer des graphiques, etc. Voici le code (commenté et expliqué plus bas) que nous utilisons pour notre premier fichier CSV contenant des données datées.

/*Exemple de code pour prendre des données et les écrire sur une carte SD 
RÉCIT MST 2016
Inspiration http://www.worldofgz.com/electronique/ecrire-et-lire-des-donnees-sur-une-carte-sd/
http://tiptopboards.free.fr/arduino_forum/viewtopic.php?f=5&t=68
http://forum.arduino.cc/index.php?topic=107367.0
*/
#include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include "RTClib.h"

RTC_DS1307 rtc;

File fichierSD;
int sensorValue;

void setup() {
 Serial.begin(9600);
//Pour la carte SD=====================
 //Initialisation de l'instance
 if(!SD.begin(10)) {//10 pour notre carte, peut etre different
 Serial.println(F("Initialisation impossible !"));
 return;
 }
 Serial.println(F("Initialisation OK"));
//Fin carte SD==========================

//Pour l'horloge=========================
 #ifdef AVR
 Wire.begin();
 #else
 Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino Due
 #endif
 rtc.begin();

 if (! rtc.isrunning()) {
 Serial.println("RTC ne fonctionne PAS!");
 // La ligne qui suit ajuste le RTC à la date et time du moment de compilation(si connectee a ordinateur)
 rtc.adjust(DateTime(__DATE__, __TIME__));
 }
//Fin horloge=============================
}

void loop() {
 sensorValue = analogRead(A0);//Le capteur est ici en A0
 
 DateTime now = rtc.now();

//On envoie dans le moniteur série l'info écrite
 Serial.print(now.year(), DEC);
 Serial.print('/');
 Serial.print(now.month(), DEC);
 Serial.print('/');
 Serial.print(now.day(), DEC);
 Serial.print(' ');
 Serial.print(now.hour(), DEC);
 Serial.print(':');
 Serial.print(now.minute(), DEC);
 Serial.print(':');
 Serial.print(now.second(), DEC);
 Serial.print(";");
 Serial.println(sensorValue);

//On nomme le fichier selon la date, donc toutes les donnees prises le meme jour dans un seul fichier==========
 char datafile[13]; //tableau de 13 espaces pour le nom
 int jour=now.day();
 int mois = now.month();
 int annee= now.year(); 
 sprintf(datafile,"%02d%02d%04d.csv",jour,mois,annee); // %d pour un int 
 datafile[13]='\0';//à mettre pour fermer convenablement le fichier
//Fin nommer fichier==================

//Ouverture du fichier==========================
 fichierSD = SD.open(datafile, FILE_WRITE);
 
 //Test pour écriture
 if(fichierSD) {
 Serial.println(F("Ecriture en cours"));
 //Ecriture
 maintenant();
 fichierSD.print(";");
 fichierSD.println(sensorValue);
 fichierSD.close();
 }
 //Fermeture du fichier avec une ligne de plus============
 
 delay(1000);//durée en ms entre les mesures 
}

//Fonction qui écrit la date et l'heure dans le fichierSD
void maintenant() {
 DateTime now = rtc.now();
 
 fichierSD.print(now.year(), DEC);
 fichierSD.print('/');
 fichierSD.print(now.month(), DEC);
 fichierSD.print('/');
 fichierSD.print(now.day(), DEC);
 fichierSD.print(' ');
 fichierSD.print(now.hour(), DEC);
 fichierSD.print(':');
 fichierSD.print(now.minute(), DEC);
 fichierSD.print(':');
 fichierSD.print(now.second(), DEC);
}

 

Explication du code

À l’aide des commentaires présents dans le code, vous pouvez remarquer que nous utilisons un petit bout de code pour nommer le fichier selon la date (jour+mois+année), ce qui simplifiera la récupération des données après plusieurs utilisations de votre robot.

Ensuite, nous avons créé une fonction (maintenant) pour écrire la date+heure dans le fichier, ça rend le code plus lisible.

Selon le projet, vous pouvez ajuster le temps entre 2 mesures, ainsi que les données mises dans le fichier (on sépare les données avec des points-virgules « ; » ).

 

À vous de jouer pour créer votre robot saisie de donnée autonome!

 

Librairie nécessaire

Celles et ceux qui ont fait (ou vu) des projets de robotique (Lego ou autres) ont sûrement remarqué que les défis sont souvent des labyrinthes où le robot doit se déplacer en évitant des obstacles.

Dans le présent projet, nous construisons un tel robot à peu de frais (moins de 25$, donc l’élève pourrait même garder son robot).

Attention! Le but ici n’est pas de faire de la compétition de robotique comme on voit avec les robots Lego (NXT, EV3). Mais bien d’apprendre comment ça se passe au niveau des circuits. Il sera relativement difficile de programmer notre robot pour qu’il circule dans un labyrinthe. Par contre, l’élève pourra «voir» au coeur du robot, ce qui est riche en apprentissages.

Note aux débutants : La présente documentation a pour but d’inspirer, non pas d’être copiée-collée sans comprendre le programme et les circuits. Car le copier-coller en Arduino ne fonctionne pas nécessairement.

Les pièces

Pour réaliser notre robot de base, nous aurons besoin des pièces suivantes (les liens sont à titre d’exemple, d’autres fournisseurs peuvent avoir de meilleurs prix).

• Carte Arduino UNO (il y a des cartes à moins de 6$ avec fil USB)
• H-bridge (le modèle L298N fait l’affaire)
• Support à piles (les piles 3,7 V sont adéquates pour la plupart des projets Arduino. Voir cet article pour l’alimentation d’une carte Arduino)
• Moteurs et roues (on a ici à faire 2 petites soudures sur les moteurs)
• Capteurs (peut être ce qu’on veut, ex.: ultrason, intensité lumineuse, etc).
• Fils (Fils Dupont sont très utiles dans des projets Arduino)
• Blindage + platine d’expérimentation (optionnel mais utile pour les connexions multiples sans soudures)

Le châssis

Attention! Afin d’éviter des bris (suite à la manipulation fréquente des pièces) voir ces conseils.

Avec un peu d’imagination, on peut utiliser plusieurs types de châssis. De l’impression 3D (si vous avez accès à une imprimante 3D, la conception par ordinateur du châssis est une tâche intéressante en science et technologie) à l’utilisation de gouttières en PVC, plusieurs matériaux pourront servir à assembler votre robot.

Voici des exemples de châssis qui ont chacun leurs forces et faiblesses.

Une descente de gouttière divisée en deux (devrait être renforcée, car un peu trop souple).

Une descente de gouttière complète.

Un bouchon de 4″.

Un bouchon de 4″ avec les moteurs à l’extérieur (Jean-François Garneau).

Une morceau de plancher flottant (Jean François Garneau).

Châssis imprimé avec une imprimante 3D (Jean-François Garneau).

Attention! Les connexions électriques (image ci-dessous) sur les moteurs sont fragiles. Pour éviter des problèmes, un renforcement (avec colle chaude ou autres moyens) est nécessaire avant de débuter ses manipulations/expérimentations.

De plus, pour que le robot se déplace en ligne droite, des ajustements seront nécessaires (roues parallèles, le frottement, etc.).

Montage

Le montage pour les moteurs nécessite le pont en H et une alimentation.

Voici la description des connexions dans le schéma ci-dessous (vous aurez à ajuster les sorties selon votre montage).

Carte Arduino	Pont en H
GND	GND
Sortie 3 ~	ENB (optionnel)
Sortie 4	IND
Sortie 5	INC
Sortie 6	INB
Sortie 7	INA
Sortie 9 ~	ENA (optionnel)

Le pont en H utilisé ici peut contrôler la vitesse de rotation des moteurs à l’aide des broches ENA et ENB (optionnel dans le tableau ci-haut). Pour débuter, nous vous suggérons de ne pas les utiliser (avoir toujours le maximum de courant dans les moteurs), ceci simplifie un peu le projet.

À noter également  la mise à la terre à connecter sur la carte Arduino (protection du circuit).

 

La programmation

Inspiration :

• http://www.apprendre-en-ligne.net/info/robotique/DdR.pdf
• http://www.wikidebrouillard.org/index.php/Arduino_:_Le_cahier_de_programmation

C’est ici que ça devient intéressant pour la résolution de problème. Car on doit faire des tests pour trouver la bonne orientation des moteurs selon le ce qu’on envoie comme signal dans les sorties 4,5,6 et 7 (les «IN» sur le pont en H).

Voici un exemple pour faire tourner les roues. Le tout est d’observer dans quel sens les roues tournent avec cette programmation et d’ajuster au besoin.

void setup()
{
 pinMode(5, OUTPUT);
 pinMode(6, OUTPUT);
 pinMode(7, OUTPUT);
 pinMode(8, OUTPUT);

}
void loop()
{
 //moteur A
 digitalWrite(7, HIGH);//INA
 digitalWrite(6, LOW);//INB
 //Moteur B
 digitalWrite(5, HIGH);//INC
 digitalWrite(4, LOW);//IND
}

Un peu de théorie, capteur de distance

Un des capteurs intéressants pour ce type de bolide est le capteur de distance. Voir cet article pour les détails de son utilisation.

Bolide et distance

Nous voici prêts pour programmer un robot qui avance tant qu’il y a au moins 25 cm d’espace devant lui. Voici une vidéo présentant le résultat.

Le programme en Blockly@rduino est ici (version xml compressée pouvant être importée).

Le programme en mode texte :

int lecture_echo;
int cm;

//On peut créer des fonctions comme ci-dessous de façon à simplifier la programmation dans la boucle loop
void Avance() { 
  digitalWrite(7, HIGH);
  digitalWrite(6, LOW);
  digitalWrite(5, LOW);
  digitalWrite(4, HIGH);
}

void Recule() {
  digitalWrite(7, LOW);
  digitalWrite(6, HIGH);
  digitalWrite(5, HIGH);
  digitalWrite(4, LOW);
}

void TourneGauche() {
  digitalWrite(7, LOW);
  digitalWrite(6, HIGH);
  digitalWrite(5, LOW);
  digitalWrite(4, HIGH);
}

void TourneDroite() {
  digitalWrite(7, HIGH);
  digitalWrite(6, LOW);
  digitalWrite(5, HIGH);
  digitalWrite(4, LOW);
}

void Arrete() {
  digitalWrite(7, LOW);
  digitalWrite(6, LOW);
  digitalWrite(5, LOW);
  digitalWrite(4, LOW);
}

void setup() //
{
  pinMode(11, OUTPUT);
  digitalWrite(11, LOW);

  pinMode(7, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(10, INPUT);
  Serial.begin(9600);

}


void loop()
{
  //on lit la distance devant le robot
  digitalWrite(11, HIGH);
  delay(10);
  digitalWrite(11, LOW);
  lecture_echo = pulseIn(10,HIGH);
  ;
  cm = lecture_echo / 58;
  Serial.print(cm);
  delay(10);//on donne un peu de temps au robot pour respirer ;-)
  if (cm > 25) { //si chemin libre
    Avance();

  } else { //si obstacle
    Arrete();
    delay(1000);
    Recule();
    delay(1000);
    TourneGauche();
    delay(300);
    Arrete();
    delay(1000);

  }

}

Note : En cours de tests (avril 2016)... nous ajouterons/ajusterons le document selon les résultats.
Mise à jour du 11 avril : amélioration du code, voir au bas de l'article.

Note aux débutants : La présente documentation a pour but d’inspirer, non pas d’être copiée-collée sans comprendre le programme et les circuits. Car le copier-coller en Arduino ne fonctionne pas nécessairement.

Le présent projet en est un de domotique. Nous désirons faire pousser des fines herbes sans avoir à les arroser soi-même. Pour ce faire, notre robot mesurera l’humidité du sol avec une sonde comme celle présentée ici, puis à l’aide d’une mini pompe, Arduino arrosera lorsque le sol sera sec.

Pièces

• Carte Arduino Uno
• Pompe submersible (Ultra-quiet Mini DC12V Brushless Water Pump Submersible Modèle #DC30A-1230)
• Tuyau (5/16  » interne)
• Transistor IRF520
• Blocs piles (au moins 7 V pour la carte Arduino, 4 piles AA fait l’affaire pour la pompe. Voir cet article pour l’alimentation d’une carte Arduino)
  • Piles 3,7 V (chargeur et piles, bloc, piles)
• Résistors (10 kOhms et 220 ohms)
• Clous (pour la sonde d’humidité)
• Diode (protection du circuit contre le moteur)
• Réservoir
• Boitier couvre circuit
• Bac à fleurs
• Fils, attaches, etc.
• Total électronique: environ 13$
• Total matériaux : 10$

Un peu de théorie

Le transistor sert ici d’interrupteur pour la pompe (utilisant plus de 5V). La carte Arduino (utilisant 5V) ne fait qu’ouvrir ou fermer cet interrupteur selon les conditions programmées.

La diode (pièce polarisée), ne laissant passer du courant que dans un sens, protège le circuit contre un retour de courant produit par le moteur de la pompe.

 

Montage électrique

Une DEL (avec une résistance en série d’au moins 220 ohms) peut être ajoutée au circuit afin d’informer l’utilisateur que le circuit est fonctionnel. À vous de voir où la brancher.

Installation

Attention! Afin d’éviter des bris (suite à la manipulation fréquente des pièces) voir ces conseils.

Note : Nous avons utilisé des plats récupérés comme réservoir et comme recouvre circuits/piles. Nous avons placé le réservoir à l’intérieur du bac, car nous désirons pouvoir transporter facilement le montage.

Programme de base

Version XML

 

void setup()
{
 pinMode(A0, INPUT);//le capteur est sur l'entrée A0
 pinMode(8, OUTPUT);//sortie vers la pompe
 Serial.begin(9600);//on veut pouvoir vérifier la valeur du capteur à l'écran
}
void loop()
{
 digitalWrite(8, LOW);
 Serial.println(analogRead(A0));
 if (analogRead(A0) < 780) { //faire vos tests pour trouver votre valeur
 digitalWrite(8, HIGH);
delay(3000);//on pompe 3 s
 digitalWrite(8, LOW);
 }
delay(200000);//on prend une mesure à toutes les 200 s
}

Améliorations

On peut améliorer notre montage en ajoutant un capteur dans le réservoir afin d’être informé (par une DEL par exemple) qu’il n’y a plus d’eau.

Expérimentation : Des tests plus poussés pourraient nous permettre de trouver la façon la plus efficace d’arroser le sol (nombre et position des trous dans le tuyau, position du tuyau dans le bac, nombre de secondes à arroser, etc.).

Un interrupteur pourrait également être installé sur le couvre circuit pour activer le système.

Version 2 du programme

Après quelques tests, voici une version plus efficace de notre programme de contrôle de l’arrosage de nos fines herbes.

Fonctions

Nous avons créé trois fonctions, niveau, humidité et pompe.

La fonction niveau et humidité utilisent le capteur d’humidité présenté ici. Cette nouvelle version du code nous permet d’économiser de l’énergie (piles), car nous n’envoyons du courant que pour la mesure et non pas toujours.

Pour la fonction niveau (alimenté par la broche 3), nous vérifions qu’il y a de l’eau dans le réservoir  (A0 < 100 si pas d’eau entre les clous), pour la fonction humidité (alimenté par la broche 10) nous voulons arroser lorsque le capteur nous donne une lecture de A1 < 780. Voici les blocs Blockly@rduino :

La troisième fonction, pompe, démarre la pompe pour une durée de 3,5 s et attend 15 minutes avant de relancer les tests (pour que l’eau pénètre dans le sol et atteigne la sonde).

Le code (version XML pour Blockly@rduino) qui s’exécute en boucle commence par vérifier le niveau du réservoir. S’il n’y a pas d’eau, on allume une DEL rouge pour le signaler. S’il y a de l’eau, on mesure l’humidité du sol, on arrose selon la condition, sinon on attend à la prochaine mesure (ici 30 minutes).

 

Version Arduino commentée du code version 2

/* Arroseur automatique par RÉCIT MST 2016
Pousse basilic pousse

Des fonctions démarrent les mesures de niveau d'eau et d'humidité du sol. On envoie du courant
seulement le temps de la lecture pour économiser les piles.
analogWrite donne de meilleurs résultats que digitalWrite pour les sondes.
*/

int manque_eau;
int sec;
void setup()
{
 pinMode(A0, INPUT);//sonde humidité du sol
 pinMode(A1, INPUT);//sonde niveau d'eau
 pinMode(3, OUTPUT);//sonde niveau eau
 pinMode(8, OUTPUT);//pompe
 pinMode(9, OUTPUT);//DEL rouge
 pinMode(10, OUTPUT);//sonde humidité du sol
 Serial.begin(9600);
 manque_eau=0;
 sec=0;
}

void loop() //code qui tourne en boucle====================
{
 niveau();//on vérifie le niveau d'eau
 
 if (manque_eau==1) {
 analogWrite(9, 255);//allume DEL rouge
 }
 else { //ne manque pas d'eau
 analogWrite(9, 0);//eteint DEL rouge
 digitalWrite(8, LOW);//pompe off

 //On teste si assez humide, sinon on arrose 3s
 humidite();//vérifier humidite sol
 if (sec==1) {
 pompe();//on pompe pour 3,5 s
 }
 else { delay(1800000);//mesure aux 30 min 
 }
 } //fin si il y a de l'eau
 
}//fin loop

//Les fonctions ======================================================================
void niveau() {
 //test niveau eau=======================
 analogWrite(3, 255);//on démarre le courant dans la sonde niveau d'eau
 delay(1000);//on donne un peu de temps au circuit
 Serial.println(analogRead(A1));
 if (analogRead(A1) < 100) {
 manque_eau=1;
 }
 else { manque_eau=0; }
 delay(100);
 analogWrite(3, 0);//on arrête le courant dans la sonde, économie d'énergie 
 delay(100);

//fin test niveau=======================
}
//Fonction qui teste l'humidite du sol
void humidite() {
 analogWrite(10,255);//on démarre le courant vers la sonde humidite
 delay(1000);//on donne 1s pour prendre la mesure
 Serial.print(analogRead(A0));
 Serial.print(" : ");
 if (analogRead(A0) < 780) {
 sec=1;
 }
 else {sec=0;}
 delay(100);
 analogWrite(10,0);//on arrête le courant dans la sonde, économie d'énergie
 delay(100);
}

//Fonction pour pomper de l'eau=============================
void pompe() {
 digitalWrite(8, HIGH);
 delay(3500);//durée du pompage
 digitalWrite(8, LOW);
 delay(900000);//on attend 15 minutes que l'eau pénètre dans le sol
}

Un des capteurs souvent utilisés en robotique est le radar. Pour un robot qui se déplace, pouvoir connaître la distance des objets devant lui est un avantage certain.

Simuler Arduino Uno dans Tinkercad Circuits c'est possible, voir la diapositive 11 de ce document. Aussi cette autoformation à propos de Tinkercad Circuits.

Avec Arduino, le capteur utilisé ici est le HC-SR04.

Note : En cherchant un peu sur le Web, vous trouverez plusieurs tutoriels qui expliquent le fonctionnement (avec plus de détails qu’ici) de ce capteur. 

Montage

La connexion est relativement simple :

Les broches «trig» et «echo» doivent être connectées sur une entrée/sortie numérique.

Calcul de la distance

Un des avantages pour le domaine de la mathématique, de la science et technologie de ce type de capteur est qu’il n’est pas «encapsulé», c’est-à-dire qu’il ne donne pas la mesure sans travail. En effet, nous devons comprendre le fonctionnement de ce capteur pour pouvoir «programmer» le calcul de la distance entre le capteur et l’objet.

Le capteur est activé en envoyant un signal à la broche «trig» (au moins 10 microsecondes). Par la suite, le capteur met la broche «echo» à «HIGH» (+ 5 V) pour une durée équivalant au temps qu’a pris le signal sonore pour se rendre à l’objet et revenir au capteur. C’est ce temps qui nous servira à calculer la distance de l’objet.

Les formules nécessaires.

• v=d/t
• Vitesse du son = 340 m/s ou 0.034 cm/µs

On vous laisse travailler un peu pour en arriver à programmer votre radar comme suit (source du petit programme) :

/* Utilisation du capteur Ultrason HC-SR04 */
//Source : http://www.locoduino.org/spip.php?article52
// définition des broches utilisées 
int trig = 11; //on peut utiliser n'importe quelle broche numérique
int echo = 10; 
//https://www.arduino.cc/en/Reference/Long
long lecture_echo; //durée de l'aller-retour du signal
long cm;

void setup() 
{ 
 pinMode(trig, OUTPUT); //sortie vers la broche trig pour démarrer le capteur
 digitalWrite(trig, LOW); 
 pinMode(echo, INPUT); //broche d'entrée pour l'echo
 Serial.begin(9600); //démarre la connexion avec le moniteur série
}
void loop() 
{ 
 digitalWrite(trig, HIGH); //on démarre le signal
 delayMicroseconds(10); // durée du signal trig de 10 microsecondes
 digitalWrite(trig, LOW); //On arrête le signal
 lecture_echo = pulseIn(echo, HIGH); //la durée de cette lecture est proportionnelle au temps d'aller-retour du signal
 cm = lecture_echo / 58; // comment on arrive à cette formule?
 Serial.print("Distance en cm : "); 
 Serial.println(cm); 
 delay(1000); //on attend 1 s avant la prochaine mesure
}

Question : Si on veut la mesure en mètre, quel serait le calcul?

On peut maintenant ajouter ce capteur à nos différents robot Arduino pour leur permettre de mesurer des distances.

Programmation Blockly@rduino

À tester et retester mais ça pourrait ressembler à ceci (version xml) :

Voici le fichier pour Ardublockly : radar_ardublockly.xml

mBlock (en ligne, télécharger) peut aussi être utilisé pour programmer Arduino Uno, voici une saisie d’écran du programme dans cet outil. À noter que mBlock fonctionne avec les chromebooks.