Journal-d1-type
Préambule
Journal en cours....
Journal d'un type qui souhaite réaliser un colis avec un Arduino comme cerveau (pour le colis, pas pour le type, l'Arduino, oh)
Lundi 10 janvier 2011
Objectif du journal du type
L'idée est de formaliser la démarche parcourue par le type pour parvenir à faire fonctionner un colis "intelligent" sur la logique de Coliscience (voir Présentation_Coliscience) mais en se basant sur une carte Arduino comme "cerveau" du colis pour enregistrer les données et permettre leur analyse par la suite.
Ce que le type aimerait savoir à postériori sur son colis
- sur quelle face était posé le colis à un instant t ?
- quelle était la température de l'environnement proche du colis ?
Ce dont le type a besoin matériellement parlant
- une carte Arduino
- sans doute le module support d'une carte µSD pour l'Arduino même si le type n'imagine pas une seconde comme le faire fonctionner pour l'instant
- une/des thermistances
- 6 capteurs de lumière (un pour chaque face) ou 3 capteurs équivalent des anciens contacteurs à mercure.
- des piles, sans aucun doute (la rallonge avec transfo semble trop limitante si l'on souhaite faire parvenir le colis à quelqu'un d'autre que son voisin).
Ce dont le type a besoin intellectuellement parlant
- savoir à peu près comment fonctionne une carte Arduino. Là, Internet est l'ami du type puisque des tutoriels tout à fait sympathiques existent comme par exemple ici : http://www.artsens.org ou là http://www.craslab.org. Au moment où le type écrit ces lignes, la 1ère adresse où l'on est sensé pouvoir trouver un tuto de Ouf-les-Baloufs pour cheminer tout doucement avec l'arduino et faire ses premiers pas accompagné d'un youpala, le site ne fonctionne pas ! Bisque. Le type pointera le tuto un autre jour.
- savoir comment se branche le module µSD sur l'Arduino. On détaillera aussi plus tard.
Voilà pour l'instant pour ce lundi 10 janvier 2011.
Mardi 11 janvier 2011
Pour prendre en main la carte Arduino
Finalement, plutôt que de dépendre d'un site qui parfois tomberait en marche, le choix a été fait de mettre à disposition le document d'entrée en matière directement sur ce Wiki. La fait que le document est sous licence Creative Commons nous l'autorise ! C'est donc ici :[1]
Suivez le tutoriel ci-dessus indiqué...
...et devenez un un pro du cligontement d'une LED ! Revenez ensuite me voir dans les jours prochains.
Mercredi 12 janvier 2011
Badminton
Le mercredi soir, c'est badminton pour le type. Ca va pas être du lourd...
Où se fournir en Arduino ?
Maintenant que vous êtes tout à fait excité à l'idée de faire clignoter une diode avec un Arduino, vous vous demandez légitimement où trouver cette jolie carte italienne. Il y a Snootlab : [2] par exemple et le type ne touche aucune retro-commission.
Bien sûr, il existe d'autres sites mais vous saurez utiliser votre moteur de recherche préféré.
Coût moyen constaté à cette date : 25 €.
Mardi 18 janvier
Invention
Le type prend conscience qu'il a inventé le Wikiblog. Ca va faire date dans l'histoire d'Internet.
Principe pour déduire la position du colis à un instant t
L'idée pour savoir dans quelle position se trouve le colis est de passer par l'information de la lumière qui arrive sur la face considérée du colis. Si la lumière arrive sur la face (et sur le capteur collé à celle-ci), alors, le colis n'est pas posé sur cette face.
Mais, si le colis est dans le noir ? Alors, toutes les faces donneront normalement la même indication. On doit pouvoir déduire le contexte lumineux autour du colis.
Capteurs utilisés
D'abord, ce sont des capteurs de récupération : ça évite de devoir en acheter...Bien sûr, vous n'aurez peut-être pas la chance de pouvoir en récupérer. Dommage pour vous.
Caractéristiques du capteur
En testant le capteur au multimètre en mode résistance, on constate que dans le noir (en mettant le doigt sur le capteur), la résistance augmente : elle se stabilise autour de 40 kohms.
Sous une ampoule économie d'énergie de 14 W (pourquoi 14 W me direz-vous ? Parce que c'est ce qu'il y a de plus proche du clavier évidemment), à 5 cm environ, la résistance passe aux alentours de 280 Ohms.
Bien sûr, vous pouvez aussi vous référer à la doc associée au capteur, c'est mieux. Mais dans mon cas, je n'ai récupéré que les capteurs, pas la doc.
Samedi 22 janvier
Anticipons
Pour enregistrer les données qui seront collectées durant le voyage, il va être nécessaire, comme cela est précisé en début de journal, de connecter le module µSD à la carte Arduino. Cela va avoir pour conséquence de limiter le nombre d'entrées et de sorties qui vont être utilisées par le module.
Le module se positionne comme sur l'image ci-dessous.
Les ports utilisés et restés libres sont visibles sur l'image ci-dessous.
Différence entre une entrée analogique et une entrée numérique
Une entré numérique sera soit à un état bas (0 V) soit à un état haut (Tension correspondant souvent à la tension d'alimentation). Les entrées analogiques sont visibles sur l'image ci-dessous :
Au quotidien, les entrées numériques serviront à savoir si un capteur est ouvert ou fermé.
Les entrées analogiques, elles, permettent de mesurer plusieurs niveaux d'états, en l'occurrence 1023 pour les entrées analogiques de l'Arduino.
Notre besoin
L'objectif pour nous est de savoir sur quelle face est posée le colis. Nous n'avons pas besoin de mesurer le "niveau" de luminosité. Si le colis est posé sur une face : le capteur doit être au niveau bas. Si le capteur est sur une face exposé à la lumière, le niveau de l'entrée numérique doit être "haut".
Principe
Le plus simple est d'utiliser la logique du pont diviseur de tension. Il nous faut trouver la résistance adéquate aux bornes de laquelle la tension sera élevée quand la lumière sera faible et faible par rapport à la tension aux bornes du capteur de luminosité lorsque la lumière sera forte.
Mardi 1er février
On se penche sur les entrées analogiques
L'idée est d'utiliser un capteur de température qui va être branché sur une des entrées analogiques de l'Arduin
Dimanche 23 janvier : 1er test avec l'Arduino
Schéma de principe
On connecte le capteur de luminosité sur l'entrée numérique 2 avec une résistance de Pulldown. Afin de visualiser indirectement la valeur de l'entrée 1, on branche aussi sur la sortie numérique 3 une LED qui prendra la valeur de l'entrée 2.
Programme à importer dans l'Arduino
On suppose ici que vous avez lu les documents pointés en début de blog et que vous avez compris la manière de connecter l'Arduino à votre ordinateur.
Le programme à importer est le suivant :
// Un capteur de lumière est connecté à l'entrée numérique 2 avec une résistance de Pulldown.
// La variation de lumière entraine un basculement de l'état de l'entrée numérique.
// Ce basculement est enregistré dans la variable "val" et, pour visualiser indirectement l'état de
// cette variable, on configure l'entrée/sortie numérique 3 en sortie et on y connecte une Led.
//
int ledPin = 3; // LED connectée à la broche n°3
int inPin = 2; // un capteur de lumière est connecté à l'entrée numérique 2 avec une résistance de pulldown
int val = 0; // variable pour mémoriser la valeur lue sur l'entrée 2
//
void setup() // Partie de programme définissant les configurations utiles des entrées/sorties
{
pinMode(ledPin, OUTPUT); // configure la broche 3 en SORTIE
pinMode(inPin, INPUT); // configure la broche 2 en ENTREE (à priori inutile puisque c'est normalement le cas par défaut)
}
//
void loop() //Partie principale du programme
{
val = digitalRead(inPin); // lit l'état de la broche en entrée et met le résultat dans la variable
digitalWrite(ledPin, val);// met la LED dans l'état lu dans la variable
}
une brique de faite...
Nous avons désormais une brique de faite pour notre futur coliscience. Il faudra encore :
- prévoir de préparer les 6 entrées numériques laissées libres par le module µSD
- faire quelques essais pour que la résistance de pulldown soit la plus adaptée possible
Nous ferons cela en temps utile...Prochaine étape, le capteur de température.
Mardi 1er février
On se penche sur les entrées analogiques
L'idée est d'utiliser un capteur de température qui va être branché sur une des entrées analogiques de l'Arduino. Sur la même logique que le capteur de lumière, on construit un pont diviseur constitué d'une résistance et du capteur lui-même. On alimente la branche capteur+résistance via la source 5V de l'Arduino et on ferme le circuit en connectant l'autre extrémité de la branche au GND de la carte.
En image...
Quant au programme à transférer à l'Arduino...
Cette mise en œuvre a permis au type de se rendre compte de la grande richesse de la bibliothèque intégrée au logiciel de connexion...
En effet, le logiciel contient un exemple pratiquement directement adapté à notre besoin.
Code
Après quelques modifications mineures, cela donne :
/*
Lecture de l'entrée analogique 0 de l'Arduino
Envoi du résultat vers l'écran série
This example code is in the public domain.
*/
void setup() {
Serial.begin(4800);
}
void loop() {
int sensorValue = analogRead(A0);
Serial.println(sensorValue, DEC);
delay(1000);
}
Pour visualiser les valeurs du capteur
Il vous faut ouvrir le terminal :
Samedi 5 février
On n'est pas des boeufs, 966°, c'est pas possible, sauf à la surface d'une planète plus proche du soleil...
Comme vous avez fait le montage de votre côté, vous vous serez aperçu comme le Type que les valeurs affichées dans la fenêtre ne correspondent à rien de réel à priori...
Il va nous falloir "étalonner" le capteur pour que cela traduise des valeurs cohérentes et que nous puissions nous faire une idée de la température autour du colis.
En creusant les caractéristiques de l'Arduino, on se rend compte que les tensions appliquées à l'entrée analogique en question sont découpées en tranches et que le nombre de tranches est de 1023 (2 à la puissance 8 moins une valeur qui doit être réservée).
En mettant un thermomètre à côté du capteur, on se rend compte que la valeur 966 affichée dans le terminal série du programme correspond à 21°. Au passage d'ailleurs, on se rend compte que le type chauffe trop chez lui : on recommande plutôt 18° ; c'est peut-être dû à la proximité de l'ordinateur mais il faudra qu'il vérifie pour éviter de gaspiller de l'énergie inutilement.
D'autre part, on se rend compte que le pont diviseur est alimenté "dans le mauvais sens". En effet, en "pinçant" le capteur entre le pouce et l'index (et donc lorsque l'on augmente la température), les valeurs affichées dans le terminal baisse : ce n'est pas d'une cohérence évidente. Il faut donc inverser l'alimentation du pont diviseur.
résistance --> à la masse Capteur --> à +5V
Quelques valeurs
En prenant quelques valeurs, cela donne :
--> La valeur pour 21° est désormais autour de 54/55 (évidemment le complément de 966 pour 1023). --> pour 34°, on a une valeur de 90 --> pour 12°, on a une valeur de 22
C'est une première table sommaire de correspondance de valeurs.
C'est pas miraculeux, mais c'est un bon début
Ces résultats ne sont pas tout à fait satisfaisants : sur une plage "utilisable" de 1023 valeurs, on voit bien que, en extrapolant (sans savoir d'ailleurs si le capteur a vraiment une réactivité linéaire), on va couvrir au maximum 200 valeurs.
Il restera à affiner cela pour gagner en précision : pour l'instant, le type n'a pas forcément envie de se pencher sur la question et ne voit pas simplement comment faire...Il va falloir vraisemblablement amplifier... On laisse de côté, on reviendra dessus. D'accord ? Non ? Alors écris ci-après ta solution.
Et si on essayait de visualiser sous Squeakbot ?
Pour voir ce qu'est Squeakbot
C'est ici : Squeakbot chez Planète Sciences
On considère que vous parvenez à installer Squeakbot.
Il faut ensuite passer au microcontroleur le programme qui lui permettra de communiquer avec Squeak. Pour cela, ouvrez l'interface de gestion de communication avec l'Arduino (en version 22) et trouvez le programme StandardFirmata (dans File --> Examples puis Firmata).
Ensuite, après avoir envoyé le programme dans la mémoire du microcontrôleur, les différentes étapes sont :
--> trouver le bon port de communication : sous Linux, il vous faut ouvrir "autre" pour y écrire généralement "/dev/ttyUSB0" --> cliquer sur "Se connecter" (bouton vert) --> cliquer sur l'horloge "Del clignote".
Vous devriez constater : - le clignotement d'une microDEL orange sur la carte - le clignotement de la DEL que vous auriez préalablement branchée sur la platine comme montré sur le schéma d'accueil de Squeakbot
Visualisons les valeurs issues du capteur de température
Le montage et les connections sont les mêmes que précédemment.
Ensuite, je vous propose de "ranger dans un coin" de la table de travail Squeak les objets telle la fenêtre de connexion appelée "Playfield". Pour cela cliquer-droit sur la fenêtre et cliquez ensuite sur l'icône "rond".
Les autres conseils peuvent être mis à la poubelle après avoir été lu.
Suivez les étapes ci-dessous pour visualiser les valeurs du capteur de température :
- cliquez sur la sortie "0" analogique : un menu vous propose de connecter virtuellement différent capteurs ("Devices" en anglais)
- choisissez "Thermistor".
- cliquez-droit sur le dessin de la thermistance puis sur l'icône "oeil bleu".
La fenêtre des paramètres liés à la thermistance s'ouvre et vous pouvez y voir la valeur renvoyé par le capteur. Vous pouvez vérifier aussi que cette valeur varie en pinçant le capteur ! Trop nice la life.
Visualisons encore meilleur (mais parlons moins bien)
On va dessiner un point qui bougera en fonction de la valeur prise par le capteur.
- utilisez l'outil de dessin pour faire un point. - cliquez droit sur ce point pour ouvrir, via l'icône "oeil bleu", le "visualiseur" d'état de l'objet. - mettez sur la table la brique "dessin.y <- 264" : un nouveau script est apparu. - ouvrez la fenêtre d'état de l'Arduino. - déplacez la brique "Arduino board.Pin analogique 0" vers le script précédemment créé en lieu et place de la valeur "264" de l'exemple précédent. - passez la valeur "dessin.cap" à 90 - ajoutez dans le script la brique "dessin avance de 1" en dessous de celle précédemment créée. - lancez le script en cliquant sur l'horloge et regardez évoluer le point sur la table en fonction de la température.
Trop forts l'Arduino, Squeabot, le capteurs et l'ordinateur ! Votez pour eux à la prochaine élection présidentielle !
Jeudi 17 février
Vinguette, y'a eu un trou temporel
Ben c'est normal, le type, y peut pas observer de loin aux jumelles des révolutions en Tunisie et en Egypte et écrire en même temps un journal colis-Arduino-Squeak...C'est un être humain après tout.
Reprenons : et si on essayait de stocker sur la carte SD ?
Enthousiasmé par les très nombreux succès précédents (faire bougé un point sur l'écran avec Squeak, pincer un capteur de température et voir des chiffres changer à l'écran, prendre une photo de l'Arduino et la mettre sur un Wiki, etc), le type a très envie ce soir de tenter de stocker des données sur la carte SD.
Tout d'abord, malgré les nombreux essais, le type n'est parvenu à rien en connectant le "shield SD" (vocabulaire tout à fait Arduino voulant dire "carte électronique additionnelle permettant de brancher une carte SD sur la carte Arduino" mais vous l'aurez compris, ça claque moins dans les soirée mondaines) comme montré sur la photo image:MicroSD-en-position.jpg présentée le samedi 22 janvier.
Aussi, il est temps de de prendre le taureau par la goutte d'eau qui met le feu aux poudres. Le type va essayer l'alternative de connexion à l'Arduino : les 6 broches icsp ! Pour cela, il est nécessaire de décaler le cavalier pointé sur la photo ci-dessous pour mettre d'alimenter correctement la carte dans ce nouveau mode de connexion.
Test d'enregistrement des valeurs données par le capteur de température
Les entrées analogiques sont désormais plus difficiles d'accès car légèrement recouvertes par le module SD. Cependant, en pliant les fils, on parvient à le faire.
On repart sur le branchement et le montage présenté le mardi 1er février. De plus, parce que le programme exemple que nous allons envoyer à l'arduino va chercher à relever les valeurs sur les 3 premières entrées numériques, on renvoit aussi la valeur mesurée précédemment sur l'entrée 0, sur l'entrée 1 et l'entrée 2 à l'aide de 2 fils supplémentaires. Le montage est prêt.
Il reste à envoyer le bon programme : pour cela, dans l'interface Arduino, allez dans : --> File --> Examples --> SD --> Datalogger
Procéder comme habituellement pour envoyer le programme dans le microcontroller (le bouton d'initialisation qu'il est recommandé d'activer avant envoi est difficilement accessible à cause de la carte : un tournevis peut être une aide appréciable pour appuyer sur l'interrupteur).
A la fin du chargement ("Done uploading" affiché dans la barre de message en bas), vous pouvez ouvrir la fenêtre "Serial Monitor" et voir défiler les valeurs liées au capteur ! Attention, vérifiez que le débit est identique à l'indication donnée dans le programme (9600 Bauds à priori par défaut).
En ouvrant le fichier "datalog.txt" se trouvant alors sur la carte, vous retrouverez ces valeurs que vous pourrez exploiter comme bon vous semble !
On commence à avoir toutes les briques pour notre colis : ça va être du "lourd" ! (brique/colis/lourd/un peu drôle).
Jeudi 24 février
Dater les données
Sans vouloir entrer dans une datation avancée des données sur la carte µSD, il peut être cependant utile d'avoir une référence pour simplifier l'analyse des données tout au long du temps du voyage du colis. Aussi, on va modifier le programme datalogger pour pouvoir s'adapter mieux à notre besoin. Les lignes ajoutées ont un commentaire qui commence par "AJOUT" suivi d'une explication de la manière dont agit cette nouvelle ligne sur le programme.
code modifié
/*
SD card datalogger
This example shows how to log data from three analog sensors
to an SD card using the SD library.
The circuit:
* analog sensors on analog ins 0, 1, and 2
* SD card attached to SPI bus as follows:
** MOSI - pin 11
** MISO - pin 12
** CLK - pin 13
** CS - pin 4
created 24 Nov 2010
updated 2 Dec 2010
by Tom Igoe
This example code is in the public domain.
*/
#include <SD.h>
// On the Ethernet Shield, CS is pin 4. Note that even if it's not
// used as the CS pin, the hardware CS pin (10 on most Arduino boards,
// 53 on the Mega) must be left as an output or the SD library
// functions will not work.
const int chipSelect = 4;
int compteurTemps = 0; // AJOUT. Déclaration de la variable qui va contenir l'information du temps
void setup()
{
Serial.begin(9600);
Serial.print("Initializing SD card...");
// make sure that the default chip select pin is set to
// output, even if you don't use it:
pinMode(10, OUTPUT);
// see if the card is present and can be initialized:
if (!SD.begin(chipSelect)) {
Serial.println("Card failed, or not present");
// don't do anything more:
return;
}
Serial.println("card initialized.");
}
void loop()
{
// make a string for assembling the data to log:
String dataString = "";
dataString += compteurTemps; //AJOUT. On ajoute à la chaine de caractères la valeur du compteur de temps
dataString += ","; //AJOUT. On met une virgule après l'information du temps pour pouvoir ensuite ajouter la valeur fournie par le capteur
// read three sensors and append to the string:
for (int analogPin = 0; analogPin < 3; analogPin++) {
int sensor = analogRead(analogPin);
dataString += String(sensor);
if (analogPin < 2) {
dataString += ",";
}
}
// open the file. note that only one file can be open at a time,
// so you have to close this one before opening another.
File dataFile = SD.open("datalog.txt", FILE_WRITE);
// if the file is available, write to it:
if (dataFile) {
dataFile.println(dataString);
dataFile.close();
// print to the serial port too:
Serial.println(dataString);
}
// if the file isn't open, pop up an error:
else {
Serial.println("error opening datalog.txt");
}
delay(5000); // AJOUT. On demande d'attendre 5 secondes avant d'opérer une nouvelle mesure sur les 3 entrées numériques
compteurTemps = compteurTemps+5; // AJOUT. On incrémente la variable de 5 (s)
}
Forme du résutlat
Le résultat, dans la fenêtre affichée après un clic sur "serial monitor", se présente sous cette forme :
Initializing SD card...card initialized. 0,165,165,165 5,166,168,165 10,168,168,168 15,168,166,167 20,168,166,166 25,167,167,168 30,168,167,166 35,168,168,169 40,166,169,169 ...
Une ligne s'ajoute évidemment toutes les 5 secondes environ. Le premier chiffre représente le temps en seconde à partir du moment où le programme a été lancé. Vous connaissez les trois chiffres suivants qui représentent la valeur renvoyée sur les 3 entrées analogiques par le capteur de température. Vous constatez, comme le type, une différence de valeur alors qu'il s'agit du même capteur : cela nous donne une idée de la précision qu'il nous faudra prendre en compte...
Dimanche 6 mars
Durée du voyage : une question nécessaire pour vérifier le besoin en énergie électrique
Nous ne nous sommes pas encore posé la question de la durée du voyage et de la gestion de l'énergie : c'est pourtant essentiel et un bilan de consommation énergétique va devoir être réalisé de manière préalable à un envoi. Directement en lien à cette question, il faudra décider de l'alimentation embarquée pour l'Arduino. Pour cela essayons d'être le plus proche possible de la configuration de fonctionnement du colis.
On tend vers le montage final
Les capteurs en jeu
Pour avoir une idée de la consommation énergétique qui devra être confirmée avant envoi par une mesure en totale configuration (tous les capteurs en place, la carte Arduino alimentée ainsi que la carte µSD), on connecte donc 6 capteurs de lumière sur les entrées numériques numérotées de 8 à 13 et 2 capteurs de température sur les entrées analogiques 0 et 1 (le second capteur est là pour redondance en cas de panne du 1er car on a de la place).
Le code
Avec le code, qui est une amélioration du précédent :
/*
partir d'une base de Tom Igoe
This example code is in the public domain.
*/
// 6 capteurs de lumière sont connectés sur les entrées numériques de 8 à 13 avec des résistances de Pulldown.
// 2 capteurs de température sont connectés sur les entrées analogiques 0 et 1
// La variation de lumière entraine un basculement de l'état de chaque entrée numérique.
// Le shield SD est connecté sur les 6 broches ICSP
//
#include <SD.h> // On appelle la bibliothèque nécessaire au pilotage du Shield SD
// int ledPin = 3; // LED connectée à la broche n°3
int inPin8 = 8; // un capteur de lumière est connecté à l'entrée numérique 8 avec une résistance de pulldown
int inPin9 = 9; // un capteur de lumière est connecté à l'entrée numérique 9 avec une résistance de pulldown
int inPin10 = 10; // un capteur de lumière est connecté à l'entrée numérique 10 avec une résistance de pulldown
int inPin11 = 11; // un capteur de lumière est connecté à l'entrée numérique 11 avec une résistance de pulldown
int inPin12 = 12; // un capteur de lumière est connecté à l'entrée numérique 12 avec une résistance de pulldown
int inPin13 = 13; // un capteur de lumière est connecté à l'entrée numérique 13 avec une résistance de pulldown
int compteurTemps = 0; // AJOUT. Déclaration de la variable qui va contenir l'information du temps
const int chipSelect = 4;
//
void setup() // Partie de programme définissant les configurations utiles des entrées/sorties
{
pinMode(inPin8, INPUT); // configure la broche 8 en ENTREE (à priori inutile puisque c'est normalement le cas par défaut)
pinMode(inPin9, INPUT); // configure la broche 9 en ENTREE (à priori inutile puisque c'est normalement le cas par défaut)
pinMode(inPin10, INPUT); // configure la broche 10 en ENTREE (à priori inutile puisque c'est normalement le cas par défaut) DANGER ? cause carte SD ?
pinMode(inPin11, INPUT); // configure la broche 11 en ENTREE (à priori inutile puisque c'est normalement le cas par défaut)
pinMode(inPin12, INPUT); // configure la broche 12 en ENTREE (à priori inutile puisque c'est normalement le cas par défaut)
pinMode(inPin13, INPUT); // configure la broche 13 en ENTREE (à priori inutile puisque c'est normalement le cas par défaut)
Serial.begin(9600);
Serial.print("Initializing SD card...");
// make sure that the default chip select pin is set to
// output, even if you don't use it:
pinMode(10, OUTPUT);
// see if the card is present and can be initialized:
if (!SD.begin(chipSelect)) {
Serial.println("Card failed, or not present");
// don't do anything more:
return;
}
Serial.println("card initialized.");
}
//
void loop() //Partie principale du programme
{
// Constitution d'une chaine de caractère pour collecter les valeurs des différentes entrées.
String dataString = "";
dataString += compteurTemps; // On ajoute à la chaine de caractères la valeur du compteur de temps
dataString += ","; //On met une virgule après l'information du temps pour pouvoir ensuite ajouter la valeur fournie par le capteur
// Lecture des deux capteurs analogiques et ajout à la chaine de caractères
for (int analogPin = 0; analogPin < 2; analogPin++) {
int sensor = analogRead(analogPin);
dataString += String(sensor);
if (analogPin < 1) {
dataString += ",";
}
}
// Lecture des 6 entrées numériques et ajout à la chaine de caractères
dataString += ",";
int sensor8 = digitalRead(inPin8);
dataString += String(sensor8);
dataString += ",";
int sensor9 = digitalRead(inPin9);
dataString += String(sensor9);
dataString += ",";
int sensor10 = digitalRead(inPin10);
dataString += String(sensor10);
dataString += ",";
int sensor11 = digitalRead(inPin11);
dataString += String(sensor11);
dataString += ",";
int sensor12 = digitalRead(inPin12);
dataString += String(sensor12);
dataString += ",";
int sensor13 = digitalRead(inPin13);
dataString += String(sensor13);
dataString += ",";
// open the file. note that only one file can be open at a time,
// so you have to close this one before opening another.
File dataFile = SD.open("datalog.txt", FILE_WRITE);
// if the file is available, write to it:
if (dataFile) {
dataFile.println(dataString);
dataFile.close();
// print to the serial port too:
Serial.println(dataString);
}
// if the file isn't open, pop up an error:
else {
Serial.println("error opening datalog.txt");
}
delay(5000); // AJOUT. On demande d'attendre 5 secondes avant d'opérer une nouvelle mesure sur les 3 entrées numériques
compteurTemps = compteurTemps+5; // AJOUT. On incrémente la variable de 5 (s)
}
Un montage plein de fils
et le montage qui commence à ne pas être très facile à cabler :
Des données pas encore au top
On obtient un affichage de ce type :
Un bout d'explication
On est sans doute confronté à des problèmes de connections: le fil monobrin "gloglote" un peu si on les branche directement sur les supports de la carte Arduino. L'ajout de support "tulipe" atténue le problème mais ne résout pas tout. Il y a sans doute aussi des contacts inopportuns sur la plaquette de connections rapides...Il va falloir vérifier cela avant de mesurer la consommation.
Dimanche 20 mars
Non satisfait du dernier test des 6 capteurs de lumière en simultané, le Type a décidé de faire dans le propre : pour être un peu plus sûr des connections, il a fait chauffé le fer à souder.
Dimanche 15 mai
De soucis dont l'origine restent difficiles à identifier...
De nombreux essais n'ont pas permis d'avoir une "stabilité" quant à la prise de mesure...La carte SD reste régulièrement non détectée et le changement de position sur l'Arduino (SPI ou sur le boche de 8 à 13 avec un changement ad'hoc de position du cavalier présent sur le shield Sd) la font parfois réapparaître mais sans qu'une explication claire se dégage.
Hypothèse
L'hypothèse la plus probable suite aux essais pour l'instant est un dysfonctionnement au niveau shield...Si cela devait ne rien résoudre que d'essayer avec un autre shield, il faudra envisager un essai avec un autre Arduino.
Solution
On a peu de choix : il faut acheter un shield pour faire des essais et comparer.
Vendredi 20 mai
Une réponse
En fait non ! Ce n'est pas un problème au niveau du shield. En recherchant usr les forum, on s'aperçoit que la broche 10 et 4 jouent un rôle particulier et qu'il faut qu'elles soient dans une certaine configuration. Par exemple, la borne 10 doit être configurée en sortie et en position haute...Ce qui rentrait en conflit avec le programme précédent.
La solution qui fonctionne...ce soir en tous cas
Les entrées numériques utilisées deviennent 2, 3, 5, 6, 7 et 8. Ce qui donne le code ci-dessous.
Le nouveau code
/*
partir d'une base de Tom Igoe
This example code is in the public domain.
*/
// 6 capteurs de lumière sont connectés sur les entrées numériques de 8 à 13 avec des résistances de Pulldown.
// 2 capteurs de température sont connectés sur les entrées analogiques 0 et 1
// La variation de lumière entraine un basculement de l'état de chaque entrée numérique.
// Le shield SD est connecté sur les 6 broches ICSP
//
#include <SD.h> // On appelle la bibliothèque nécessaire au pilotage du Shield SD
int inPin2 = 2; // un capteur de lumière est connecté à l'entrée numérique 2 avec une résistance de pulldown
int inPin3 = 3; // un capteur de lumière est connecté à l'entrée numérique 3 avec une résistance de pulldown
int inPin8 = 8; // un capteur de lumière est connecté à l'entrée numérique 4 avec une résistance de pulldown
int inPin5 = 5; // un capteur de lumière est connecté à l'entrée numérique 5 avec une résistance de pulldown
int inPin6 = 6; // un capteur de lumière est connecté à l'entrée numérique 6 avec une résistance de pulldown
int inPin7 = 7; // un capteur de lumière est connecté à l'entrée numérique 7 avec une résistance de pulldown
int compteurTemps = 0; // AJOUT. Déclaration de la variable qui va contenir l'information du temps
const int chipSelect = 4;
//
void setup() // Partie de programme définissant les configurations utiles des entrées/sorties
{
pinMode(inPin2, INPUT); // configure la broche 2 en ENTREE (à priori inutile puisque c'est normalement le cas par défaut)
pinMode(inPin3, INPUT); // configure la broche 3 en ENTREE (à priori inutile puisque c'est normalement le cas par défaut)
pinMode(inPin8, INPUT); // configure la broche 4 en ENTREE (à priori inutile puisque c'est normalement le cas par défaut)
pinMode(inPin5, INPUT); // configure la broche 5 en ENTREE (à priori inutile puisque c'est normalement le cas par défaut)
pinMode(inPin6, INPUT); // configure la broche 6 en ENTREE (à priori inutile puisque c'est normalement le cas par défaut)
pinMode(inPin7, INPUT); // configure la broche 7 en ENTREE (à priori inutile puisque c'est normalement le cas par défaut)
Serial.begin(9600);
Serial.print("Initializing SD card...");
// make sure that the default chip select pin is set to
// output, even if you don't use it:
pinMode(10, OUTPUT);
digitalWrite(10, HIGH);
// see if the card is present and can be initialized:
if (!SD.begin(chipSelect)) {
Serial.println("Card failed, or not present");
// don't do anything more:
return;
}
Serial.println("card initialized.");
}
//
void loop() //Partie principale du programme
{
// Constitution d'une chaine de caractère pour collecter les valeurs des différentes entrées.
String dataString = "";
dataString += compteurTemps; // On ajoute à la chaine de caractères la valeur du compteur de temps
dataString += ","; //On met une virgule après l'information du temps pour pouvoir ensuite ajouter la valeur fournie par le capteur
// Lecture des deux capteurs analogiques et ajout à la chaine de caractères
for (int analogPin = 0; analogPin < 2; analogPin++) {
int sensor = analogRead(analogPin);
dataString += String(sensor);
if (analogPin < 1) {
dataString += ",";
}
}
// Lecture des 6 entrées numériques et ajout à la chaine de caractères
dataString += ",";
int sensor2 = digitalRead(inPin2);
dataString += String(sensor2);
dataString += ",";
int sensor3 = digitalRead(inPin3);
dataString += String(sensor3);
dataString += ",";
int sensor8 = digitalRead(inPin8);
dataString += String(sensor8);
dataString += ",";
int sensor5 = digitalRead(inPin5);
dataString += String(sensor5);
dataString += ",";
int sensor6 = digitalRead(inPin6);
dataString += String(sensor6);
dataString += ",";
int sensor7 = digitalRead(inPin7);
dataString += String(sensor7);
dataString += ",";
// open the file. note that only one file can be open at a time,
// so you have to close this one before opening another.
File dataFile = SD.open("datalog.txt", FILE_WRITE);
// if the file is available, write to it:
if (dataFile) {
dataFile.println(dataString);
dataFile.close();
// print to the serial port too:
Serial.println(dataString);
}
// if the file isn't open, pop up an error:
else {
Serial.println("error opening datalog.txt");
}
delay(5000); // AJOUT. On demande d'attendre 5 secondes avant d'opérer une nouvelle mesure sur les 3 entrées numériques
compteurTemps = compteurTemps+5; // AJOUT. On incrémente la variable de 5 (s)
}
...et ça marche
Sur la capture d'écran ci-dessous, on peut constater que les capteurs répondent un à un lorsqu'on les couvre et qu'il n'y a pas ou peu de lumière qui arrivent sur eux.
A venir : - intégration - mesure de la tension des piles
