Des ensembles pour débuter

Afin de s’approprier Arduino et un peu d’électronique, il peut être payant de se procurer un ensemble de démarrage contenant plusieurs pièces. Voici une brève description de trois ensembles différents.

Ensemble de démarrage officiel de Arduino

Cet ensemble est le plus dispendieux des trois que nous avons testés. Voici les pièces de l’ensemble officiel d’Arduino pour démarrer. Un «bloc» de montage reliant la platine et la carte Arduino est à assembler (style MDF), ce qui permet de réaliser les circuits plus facilement.

Le livre (en anglais, mais disponible en français) est très bien fait pour expliquer les bases de l’électronique ainsi que pour la programmation. Des petites décorations rendent les projets plus attirants pour celles et ceux qui laisse place à leur créativité.Décorations de projets Il manque peut être quelques capteurs pour pouvoir profiter de cet ensemble dans une classe de science et technologie.

Ensemble SunFounder Super Kit V2.0

Cet ensemble, moins cher que celui ci-haut, ne contient pas le microcontrôleur, il faut donc ajouter un 35$ à son prix pour fin de comparaison. La liste de pièce est intéressante, bien qu’on a peut être trop de pièces destinées à l’affichage pour l’utilisation en classe de science et technologie. Les câbles Dupont sont par contre plus efficaces que les fils standard de l’ensemble Arduino. Une boite de rangement en plastique, non présente dans l’ensemble Arduino, est appréciée pour faciliter le classement des pièces électroniques.

Le livre (en anglais) contient 19 projets bien détaillés où, contrairement à l’ensemble officiel, on doit se rendre sur leur site pour trouver les programmes (et ils en profitent pour afficher de la publicité sur leur produits). Le code est cependant bien commenté, ce qui aide à sa compréhension.

Ensemble Robotlinking Uno

Ce dernier ensemble est le moins coûteux des trois analysés ici, ce qui peut s’expliquer en partie par l’absence de manuel (la version achetée ne contenait pas le CD non plus). La liste de pièces (qui varie selon la version de l’ensemble acheté) est assez complète pour une appropriation d’Arduino. Un accent particulier est mis sur l’affichage ainsi que sur la communication avec une télécommande.

 

Conclusion

Pour ce qui est des pièces, les trois ensembles (bien que différents) sont adéquats pour une appropriation de la technologie Arduino.

Le livre de l’ensemble officiel est le meilleur selon nous. Par contre, à l’aide de cette autoformation (qui s,améliorera dans les prochains mois), vous pouvez vous passer du livre.

Capteur humidité et température ambiante

Le capteur DHT11 permet de prendre avec la même sonde la température ainsi que le taux d’humidité ambiant.

dht11.resized

Pour l’utiliser nous devons inclure une librairie dans notre programme. Vous pouvez télécharger au bas de la présente page celle que nous avons utilisée.

Montage avec entrée analogique

montage_dht11

 

Schéma entrée analogique

schema_dht3

 

Montage entrée numérique

La sonde DHT11 peut être utilisée en numérique également (lecture plus rapide), on peut changer l’entrée A0 pour une entrée numérique (disons 8). Il faudra changer le programme ci-dessous en conséquence.

Programme

Le programme affiche dans le moniteur série la température et l’humidité.

Note : Blockly@rduino ne peut pas être utilisé ici. La version d’avril 2016 de Blockly@rduino permet de programmer cette sonde (ajouter les blocs Grove). Voici à quoi ça pourrait ressembler (version xml) : 

humidite_temperature_v2

#include <dht.h>
#define dht_apin A0 // Capteur connecté à A0 pour analogique
// #define dht_apin 8 // Capteur connecté à 8 pour numérique
dht DHT;
 
void setup(){
 Serial.begin(9600);
 delay(500);//On donne du temps pour démarrer
 Serial.println("DHT11 capteur Humidite & temperature \n\n");
 delay(1000);//Attendre avant de lire les capteurs
}
void loop(){
 DHT.read11(dht_apin);
 Serial.print("Humidite = ");
 Serial.print(DHT.humidity);
 Serial.print("% ");
 Serial.print("temperature = ");
 Serial.print(DHT.temperature); 
 Serial.println("C ");
 delay(5000);//Attendre 5s avant la prochaine lecture
 //Le plus rapide serait de 2s
}

Exemples de données

DHT11 capteur Humidite & temperature

Humidite = 18.00% temperature = 25.00C 
Humidite = 17.00% temperature = 25.00C 
Humidite = 17.00% temperature = 25.00C 
Humidite = 19.00% temperature = 25.00C 
Humidite = 32.00% temperature = 27.00C  (expiré sur le capteur)
Humidite = 40.00% temperature = 28.00C 
Humidite = 42.00% temperature = 29.00C 
Humidite = 44.00% temperature = 28.00C

Librairie nécessaire

Détecteur d’obstacle

Pour un robot bolide, détecter un obstacle peut être intéressant (un mur par exemple). Le détecteur utilisé est celui-ci (voir aussi cette page) :

detecteur_obstacle

  • GND : Mise à la terre
  • + : 5V
  • OUT : signal de sortie (0 ou 1)
  • EN : non utilisé
  • On doit ajuster les potentiomètres pour optimiser la lecture
  • La distance de détection n’est pas très grande (~ 10 cm)

Montage

montage_detecteur_obstacle2

Schéma

schema_detecteur_obstacle2

 

Programme

On allume la DEL verte (sortie 5) s’il n’y a pas d’obstacle (entrée 9 à HIGH), on allume la DEL rouge (sortie 7) si obstacle.

blockly_detecteur_obstacle

void setup()
{
 pinMode(9, INPUT);
 pinMode(7, OUTPUT);
 pinMode(5, OUTPUT);
}
void loop()
{
 if (digitalRead(9) == LOW) {
 digitalWrite(7, HIGH);
 digitalWrite(5, LOW);
} else {
 digitalWrite(7, LOW);
 digitalWrite(5, HIGH);
}
}

Vidéo présentant le résultat

 

Détecteur de ligne

Un capteur intéressant pour les robots «bolides» est le détecteur de ligne (intensité lumière réfléchie). Voici à quoi ressemble celui fourni dans l’ensemble de 24 capteurs que nous nous sommes procurés (cliquer pour agrandir) :

IR_senseur_ligne_cote

Suggestion : Pour suivre une ligne, deux de ces capteurs (gauche, droit) devraient faire partie de votre robot (voir cette page en anglais)

Défi : Faire allumer une DEL selon l’intensité de lumière réfléchie.

Un peu de théorie

Un détecteur de ligne envoie de la lumière (avec DEL) vers une surface, une résistance photo-dépendante (LDR) mesure la quantité de lumière réfléchie. Voir le schéma ci-dessous.

principe_detecteur_ligne2

Plus il y a de lumière réfléchie, moins la résistance photo-dépendant est grande, donc la DDP de sortie (A0) sera moindre.

Sous-défi (pour 2e cycle secondaire)

Il est possible d’analyser ce circuit et de trouver la relation entre la DDP du signal de sortie et la valeur de la résistance LDR (U=R*I, Réq = R1 + R2).

Montage

montage_detecteur_ligne

Schéma électrique

schema_detecteur_ligne2

Programmation

Nous faisons allumer ici la DEL verte pour signaler que le programme tourne. La DEL jaune allume sur une couleur pâle (A0 < 50), la DEL rouge allume sur une couleur foncée (A0 > 650). Version XML.

detecteur_ligne_v2

 

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

  pinMode(A0, INPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
}


void loop()
{
  Serial.print("Sortie du capteur :");
  Serial.println(analogRead(A0));
  delay(1000);
  digitalWrite(5, HIGH);
  if (analogRead(A0) <= 50) {
    digitalWrite(6, HIGH);
    digitalWrite(7, LOW);

  } else if (analogRead(A0) >= 650) {
    digitalWrite(7, HIGH);
    digitalWrite(6, LOW);
  }

}

Note : Le potentiomètre sur le capteur sert à améliorer la sensibilité. À utiliser pour avoir de meilleurs résultats.

Une vidéo du petit projet :

 

Intensité lumineuse et distance

Une photorésistance peut être utilisée pour tenter de modéliser l’effet de la distance sur l’intensité lumineuse d’une source.

intensite_lumineuse2

 

Schéma électrique

schema_intensite_lumineuse2

 

Programme (version XML)

intensite_lumineuse_distance_v2

 

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

  pinMode(A0, INPUT);
}


void loop()
{
  Serial.print("Intensité lumineuse :");
  Serial.println(analogRead(A0));

}

Prise de données

Voici un schéma de l’expérience où nous avons utilisé la photoréristance pour modéliser le lien entre l’intensité lumineuse d’une source (ici une ampoule de 25 W) et la distance (ici nous avons utilisé les tuiles du plancher comme unité de mesure).

exp_intensite_distance

Les données brutes

0 1014
1 949
2 874
3 809
4 746
5 697
6 650
7 597
8 578
9 550
10 534
11 518
12 526

Calculons les Lux

Grâce à ce forum, nous pouvons transformer les données brutes (variation entre 0 et 1023) en mesure de Lux (lumen / m²).  Le code Arduino ressemble à ceci :

 photocellReading0 = analogRead(photocellPin0);// Lire la sortie A0
 float Vout0=photocellReading0*0.0048828125; // calcul DDP
 int lux0=500/(Res0*((5-Vout0)/Vout0)); // Calcul des Lux

Données en Lux

Distance Lux
0 5070
1 632
2 291
3 188
4 134
5 106
6 86
7 69
8 64
9 58
10 54
11 51

Les points (Geogebra)

courbe_intensite_ditance

Ce qui semble confirmer la théorie (1/r²).

Construire sa sonde d’humidité du sol

Une sonde n’est qu’un circuit qui laisse passer du courant selon le capteur utilisé (son, température, champ magnétique, etc).

Pour avoir une idée de l’humidité du sol (pot de fleur par exemple), on peut utiliser tout simplement la propriété électrolytique d’une solution (ici eau + terre). Si le sol est sec, le courant passera moins bien que si le sol est humide.

Inspiration : Ici et .

PFEQ

Mots-clés : électrolyte, circuit, mesure DDP, isolant, résistance, oxydation, univers vivant (besoins d’une plante).

Voici un montage pour mesurer cette conductibilité :

Capteur humidité - clous

À noter que nous utilisons ici 2 clous (galvaniser de préférence pour éviter une oxydation trop rapide), séparer d’environ 2 cm par un matériau isolant, sur lesquels nous avons ajouter un isolant afin d’aller prendre la mesure à une certaine profondeur dans la terre (l’humidité du sol varie en fonction de la profondeur). Voici une photo de notre sonde (au lieu du ruban, utiliser du silicone comme isolant pour une sonde plus durable) :

sonde_hum

Le code pour lire la valeur prise à la broche A0 et l’envoyer dans le port série est le suivant (version xml) :

humidite_sol

 

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

  pinMode(A0, INPUT);
}


void loop()
{
  Serial.print("Valeur humidité : ");
  Serial.println(analogRead(A0));

}

Le traitement de cette donnée (que nous aurons à «calibrer» pour trouver les valeurs «trop sec» et «adéquat») peut se faire de différente façon, mais dans l’exemple ci-dessous nous allumons une DEL de couleur différente selon le taux d’humidité du sol. On peut facilement modifier le tout pour faire démarrer une pompe à une valeur précise (voir ce défi).

Montage

montage_sonde_humidite

Schéma électrique

schema_sonde_humidite

Programmation

Fichier XML (à importer dans Blockly@rduino).

sonde_humidite_sol_del

Le code Arduino :

{
  Serial.begin(9600);

  pinMode(A0, INPUT);
  pinMode(7, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(5, OUTPUT);
}


void loop()
{
  Serial.print("Humidité : ");
  Serial.println(analogRead(A0));
  delay(2000);
  if (analogRead(A0) < 500) {
    digitalWrite(7, HIGH);
    digitalWrite(6, LOW);
    digitalWrite(5, LOW);

  } else if (analogRead(A0) >= 500 && analogRead(A0) <= 700) {
    digitalWrite(7, LOW);
    digitalWrite(6, HIGH);
    digitalWrite(5, LOW);
  } else if (analogRead(A0) > 700) {
    digitalWrite(7, LOW);
    digitalWrite(6, LOW);
    digitalWrite(5, HIGH);
  }

}

Photos du montage

IMG_20160223_102130.resized

IMG_20160223_110201.resized

Simuler et programmer

En science et technologie il est important de préparer nos expérimentations et nos manipulations en atelier. C’est pourquoi nous trouvons important d’avoir des outils qui permettent de vivre cette phase (préparation) en robotique Arduino également.

Cette vidéo présente les grande lignes de la démarche de simulation-programmation.

https://www.youtube.com/watch?v=rdEi8H3nWSQ

Simulateur : avant de connecter ses fils et composants dans ses circuits, schématiser (avec logiciel de dessin ou sur papier) son montage est une étape importante. Par la suite, on peut monter le tout sur l’application https://123d.circuits.io (Autodesk).

Voici un exemple : https://123d.circuits.io/circuits/1460171-bouton-on-off-sur-led

simuler_123d

Programmer : Lorsque le circuit virtuel est réalisé, on doit programmer la carte Arduino pour exécuter la tâche désirée. Pour ce faire, nous vous suggérons d’utiliser cette application de programmation graphique Blockly@rduino http://recitmst.qc.ca/blockly@rduino/?lang=fr (installée sur nos serveurs). Voici un exemple de code pour le circuit ci-haut :

programmer_blockly

Ce qui donne le code Arduino suivant :

void setup()
{
  pinMode(2, INPUT);
  pinMode(5, OUTPUT);
}
void loop()
{
  if (digitalRead(2) == HIGH) {
    digitalWrite(5, HIGH);
  } else {
    digitalWrite(5, LOW);
  }
}

Ce code peut être coller dans l’éditeur de code dans le simulateur 123D pour par la suite démarrer la simulation.

Télécharger le programme en format XML : Interrupteur_del.xml (pour pouvoir le charger dans Blockly@rduino).

Avec ces deux outils, https://123d.circuits.io et http://recitmst.qc.ca/blockly@rduino/?lang=fr, l’élève peut se préparer (même de la maison sans le matériel Arduino) efficacement au montage de son robot Arduino.

Pour démarrer son apprentissage

Arduino est un vaste sujet. Il peut être simple de s’y perdre, car en plus des aspects électroniques peu connus, la programmation est également un défi pour plusieurs.

Pour débuter nous vous suggérons de vous procurer un ensemble de démarrage. Nous en décrivons trois sur cette page.

Par la suite, suivre une formation d’initiation (en ligne ou dans votre milieu) est une stratégie gagnante.

Comme le dit le dicton, à plusieurs têtes on a plus d’idées (ou quelque chose comme ça), il serait payant de participer à un groupe de développement de tâches, de projets, avec le matériel Arduino.

Finalement, voici quelques documents pour vous inspirer :

Pourquoi Arduino en classe de science et technologie?

Le RÉCIT MST a appris au moins une chose au cours des dernières années, la robotique en classe est motivante pour les élèves. Les projets de robotique sont signifiants pour les élèves et à leur portée. C’est, entre autres, pourquoi nous tentons de trouver un moyen de profiter de la robotique dans les cours de science et technologie au secondaire.

Lego NXT/EV3 sont de très bons robots, mais pour les besoins du secondaire (électricité, système, etc) c’est plus difficile (pas impossible) de faire des liens avec le PFEQ. Le système Lego est relativement fermé, c’est-à-dire qu’il n’est pas conçu pour pouvoir fonctionner avec des appareil non Lego (des moteurs ou capteurs autres que ceux vendus par Lego).

Il nous fallait donc chercher un système qui nous permet de faire de la robotique (construire et programmer) et qui répond à quelques critères :

  1. Permet l’utilisation du matériel déjà présent dans nos classes;
  2. Permet le développement des compétences et des savoirs essentiels en lien avec l’électricité et autres concepts (voir ces pistes de liens avec le PFEQ);
  3. Est assez «ouvert» et souple pour saisir des données simplement (agir comme sonde) et répondre à plusieurs besoins;
  4. Tient compte des budgets disponibles.

Une technologie déjà présente dans certains milieux semble répondre à ces critères, elle se nomme Arduino. Peu coûteuse, ouverte (provient du monde du logiciel libre), puissante, Arduino a le mérite d’être très documentée et d’avoir une communauté solide.

Nous voyons par contre un défi de taille, rendre cette technologie la plus accessible possible pour les classes du secondaire. Car l’électronique n’est pas un sujet très bien maîtrisé par les enseignants de science et technologie. Pour relever ce défi, nous publions le présent site de documentation, nous offrons de la formation (autoformation et sur place) pour initier à cette technologie, et nous pouvons participer à du développement de projets dans votre milieu.

 

 

Bouts de code utiles

Programmer notre robot Arduino n’est pas si complexe. Nous mettons à votre disposition cet outil graphique pour ce faire : http://recitmst.qc.ca/blockly@rduino/?lang=fr

Après quelques programmes/codes, l’élève comprend assez rapidement que derrière ces briques (Blockly@rduino) il y a du «texte», du code. Il pourra même devenir plus compétent en mode texte!

Voici quelques bouts de code qui servent dans plusieurs projets Arduino.

Rappelons-nous qu’en programmant, l’élève doit structurer sa pensée de façon logique (le robot est bête) tout en utilisant ses compétences en mathématique.