Système autonome pour la mesure de température

Matériels utilisés pour le système 1: 

• Arduino UNO
• Wireless SD Shield
• Solar Charger Shield
• Batterie Li-ion 
• Panneau solaire
• Tinkerkit Sensor Shield
• RTC Module
• LED
• Module Thermistance
• Fils connecteurs
• Boîte

Disponibles sur le site dakarprotoshop.com 

Circuit du système 1:

Présentation du système 1:

Le système 1 permet de mesurer la température ambiante et d’enregistrer les valeurs dans une carte SD tout en précisant la date et l’heure. Après chaque mesure, il se met en veille pendant une heure réduisant ainsi sa consommation d’énergie .Pour faire fonctionner tout ce système grâce au Solar Charger Shield sont juste nécessaires une batterie Li-ion 1000mAh et un panneau solaire de 1W.

En effet, le Solar Charger Shield utilisé permet en plus de charger la batterie; de fournir aussi les 5V dont a besoin le Arduino UNO. Pour cela, il reçoit de la batterie une tension comprise entre 2.7 et 4.2V et fournit en sortie 5V. Au même moment que le système fonctionne; s’il y a suffisamment d’ensoleillement alors grâce au panneau solaire également connecté sur le Solar Charger Shield, la batterie se charge .Le courant de charge peut atteindre au maximum 700 mA.

Notons que le Arduino UNO ne fonctionnera que si l’on agit sur le switch On/Off du Solar Charger Shield. Dans tous ces deux états, la batterie se charge et on aperçoit une Led rouge qui passera au vert à la fin de la charge.

Ce système utilise également un RTC Module qui permet de donner l’heure et la date. Ainsi on garde une information sur les heures de mesure. Contenant une pile de type CR 1225, le RTC Module peut alors fonctionner pendant au moins 7 ans.

Pour effectuer les mesures, nous utilisons un module Thermistance 4K7 Tinkerkit afin d’acquérir une température. Une thermistance est un composant électronique dont la résistance interne varie en fonction de la température. Ce module dispose d’une sortie analogique variant de 0 à 5V correspondant à la variation de température du module. Vous pourrez lire directement des valeurs entre 0 et 1023 correspondant aux variations de température, 0 étant la plus basse et 1023 la plus haute. A l’arrière du module, vous trouvez deux amplificateurs de signal et une LED verte qui signale que le module est correctement alimenté ainsi qu’une LED jaune dont l’intensité varie en fonction de la température. A l’aide d’une formule dans le programme, on pourra alors obtenir la température correspondante en degrés Celsius. Pour avoir des informations sur la présence ou non d’une carte SD au moment de l’initialisation, nous utilisons une Led Rouge. S’il n’y a pas de carte SD alors l’initialisation va échouer .Dans ce cas, nous nous en rendrons compte par deux clignotements de la Led Rouge. Si l’initialisation de la carte a réussi alors il ne se passe rien.

La Led Rouge s’allume à nouveau au moment des mesures puis s’éteint.

Le module Thermistance 4K7 et la Led Rouge peuvent être directement branchés sur le Tinkerkit Sensor Shield à l’aide de câble de liaison (voir circuit système 1).Nous pouvons également utiliser les pins du Tinkerkit à l’aide de fils comme c’est pour le cas avec le RTC Module.

Quant à la diminution de la consommation d’énergie, l’appel à la librairie Narcoleptic permet la mise en veille du système pour une certaine durée. En ce qui concerne cette librairie, elle peut fonctionner jusqu’à 30 secondes. Donc si vous voulez l’utiliser pour une durée beaucoup  plus grande (des heures voir des jours…); vous faîtes juste une boucle à l’intérieur de laquelle vous mettez le Narcoleptic.

Pour plus de confort et de durabilité de ce système, vous pouvez alors mettre tous ses composants dans une boîte étanche avec le panneau qui reposera au dessus du couvercle.

Avec le programme 1, le système 1 effectue deux mesures de température  toutes les heures et enregistrer ensuite les valeurs  dans la carte SD en précisant la date et l’heure. Après cela, la mise en veille démarre jusqu’à la prochaine mesure soit pendant une heure.

Code Arduino du système 1:

/*	
The circuit:
* analog sensor on analog 0
* SCL on analog sensor 5
*SDA on analog sensor 4
*LedPin-pin 9
* SD card attached to SPI bus as follows:
 ** MOSI - pin 11
 ** MISO - pin 12
 ** CLK - pin 13
 ** chipSelect - pin 4	
*/
#include <SD.h>
#include <Narcoleptic.h>
#include <Wire.h>
#define DS1307_ADDRESS 0x68
//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;
const int ledPin=9;
void setup(){
  pinMode(ledPin,OUTPUT);
  pinMode(chipSelect,OUTPUT);
//Open serial communications and wait for port to open:
   Wire.begin();
   Serial.begin(9600);
   Serial.print("  ");
   Serial.print("Initializing SD card...");
//see if the card is present and can be initialized:
if(!SD.begin(chipSelect)) {
   Serial.println("Card failed, or not present");
for(int j=0;j<2;j++){
   digitalWrite(ledPin,HIGH);
   delay(100);
   digitalWrite(ledPin,LOW);
   delay(500);}
//don't do anything more:
   return;
}
  Serial.println("card initialized.");
}
void loop(){
  int a;
  int i=0; 
while(i<2){ 
  digitalWrite(ledPin,HIGH);
//Reset the register pointer
  Wire.beginTransmission(DS1307_ADDRESS);
  byte zero = 0x00;
  Wire.write(zero);
  Wire.endTransmission();
  Wire.requestFrom(DS1307_ADDRESS, 7);
  int second = bcdToDec(Wire.read());
  int minute = bcdToDec(Wire.read());
  int hour = bcdToDec(Wire.read() & 0b111111); //24 hour time
  int weekDay = bcdToDec(Wire.read()); //0-6 ->sunday-Saturday
  int monthDay = bcdToDec(Wire.read());
  int month = bcdToDec(Wire.read());
  int year = bcdToDec(Wire.read());
  String secondString=String(second);
  String minuteString=String(minute);
  String hourString=String(hour);
  String monthString=String(month);
  String monthDayString=String(monthDay);
  String yearString=String(year);
  String dateTime= monthDayString +"/"+ monthString +"/"+ yearString+","+ hourString +":"+ minuteString +":"+ secondString;
     
//print the date EG   03/01/11, 23:59:59
  Serial.print(monthDay);
  Serial.print("/");
  Serial.print(month);
  Serial.print("/");
  Serial.print(year);
  Serial.print(",");
  Serial.print(hour);
  Serial.print(":");
if(minute<10)
  Serial.print("0");
  Serial.print(minute,DEC);
  Serial.print(":");
if(second<10)
  Serial.print("0");
  Serial.print(second,DEC);
  delay(1000); 
  long Resistance;
  double Temp; 
  int sensor = analogRead(A0);
  Resistance=(10230000/sensor-4700);
  Temp = log(Resistance);
  Temp = 1 / (0.001129148 + (0.000234125 * Temp) + (0.0000000876741 * Temp * Temp * Temp));
  Temp = Temp - 273.15;
  String sensorString= String( sensor);
  String tempString=String(Temp);
  String sensTmp=sensorString +","+ tempString;    
  Serial.print(",");  
  Serial.print("Input sensor value= ");
  Serial.print(sensor);
 Serial.print(",");
 Serial.print("Temperature correspondante= ");
 Serial.print(Temp);
 Serial.println(" degrees Celsius");
   // 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("MesTmp2.csv", FILE_WRITE);
  // if the file is available, write to it:
  if (dataFile) {
    dataFile.print(dateTime);
    dataFile.print(",");
    dataFile.print(sensTmp);
    dataFile.println(",degrees Celsius");
    dataFile.close();
  }  
// if the file isn't open, pop up an error:
  else {
    Serial.println("error opening MesTmp2.csv");
  }
 delay(10);
i++;}
 while(i>1&&i<122){
   digitalWrite(ledPin,LOW);
//Put Arduino UNO sleeping
  Narcoleptic.delay(30000);
i++;}
}
byte bcdToDec(byte val)  {
// Convert binary coded decimal to normal decimal numbers
  return ( (val/16*10) + (val%16) );
}

Présentation du système 2:
Nous faisons maintenant  un système 2 tout simple qui est constitué d’un Arduino UNO alimenté par une batterie Li-ion via le Solar Charger Shield .Avec le programme 2, nous faisons clignoter 10 fois la Led Rouge et ensuite nous la maintenons en allumage continu.

Matériels utilisés pour le systeme 2:

Arduino UNO
Solar Charger Shield
Batterie Li-ion
Panneau solaire
Led Rouge
Résistance de 220 ohms
2 fils connecteurs 

Circuit du système 2 avec un Solar Charger Shield:

Code Arduino du systeme 2:

const int ledPin=8; // pin number of LED
  int i=0;
void setup(){
  pinMode(ledPin,OUTPUT);
  digitalWrite(ledPin,LOW);
//light on and off the LED during ten times
while(i<10){
  digitalWrite(ledPin,HIGH);
  delay(1000);
  digitalWrite(ledPin,LOW);
  delay(500);
  i++;}
  delay(2000);
}
void loop(){
  digitalWrite(ledPin,HIGH);
}

Pour réaliser les mêmes tâches que les circuits précédents, nous pouvons utiliser un Lipo-Rider  au lieu du Solar Charger Shield. En effet, le Lipo-Rider a la même fonction que le Solar Charger Shield. La seule particularité du Lipo-Rider est le fait qu’il est relié au Arduino UNO via un câble USB. Il dispose pour cela d’un port USB contrairement aux broches du Solar Charger Shield qui s’incrustaient directement sur les pins du Arduino UNO.

Le Lipo-Rider de même que le Solar Charger Shield ajustent automatiquement l’intensité de charge. Quant à la valeur maximale de l’intensité de charge du Lipo-Rider, elle est de 400 mA.

Lipo-Rider

Même Circuit que le système 1 mais avec un Lipo-Rider au lieu du Solar Charger Shield

Si vous avez des questions n’hésitez pas à les posez en commentaires.

Coulomb Counter Breakout LTC4150

Objectifs:

Mesurer l’évolution de la charge ou décharge d’une batterie; établir la quantité d’électricité consommée par un système.

Ce dont vous aurez besoin: 

• Batterie Li-ion 
• Coulomb Counter 
• Arduino UNO
• Shield SD
• Tinkerkit Sensor Shield
• Thermistance
• Led 5mm
• fils connecteurs

Ils sont tous disponibles ici

Presentation du Coulomb Counter Breakout LTC4150:

On se sert d’une batterie pour alimenter un système. A l’instar de l’odomètre qui est un compteur kilométrique, on utilise le coulomb counter pour mesurer le flux d’électrons (quantité d’électricité) circulant de la batterie au système. Ainsi, nous pouvons suivre l’évolution de la décharge de la batterie (et de la charge si batterie rechargeable).En effet, à travers les informations obtenues, nous pouvons connaitre la valeur de la charge actuelle de même que la quantité d’électricité ayant circulé pendant un temps donné .Avec le coulomb counter on peut également savoir si la batterie est en état de charge ou de décharge.

Le Coulomb Counter Breakout LTC4150 vu de profil et de face.

Ayant comme circuit intégré le LTC4150 (voir datasheet constructeur); le coulomb counter possède une entrée (IN) dont la tension requise est comprise entre 2.7 et 8.5V; une sortie (OUT). L’intensité maximale qui doit circuler à travers le coulomb counter est de 1A. 

Celui-ci dispose également de 6 pins  pour une interface digitale.

Ces pins sont :

-VIO tension de référence égale à celle qu’utilise le système

-INT (interrupt, OUTPUT) : émet un signal en changeant d’état à chaque fois qu’une certaine quantité d’électricité traverse

-POL (polarity, OUTPUT): renseigne sur l’état de la batterie (charge ou décharge)

-CLR (clear, INPUT): utilisée en commande manuelle pour servir de reset après que l’état du INT ait changé

-SHDN (shutdown) impose au LTC4150 une consommation minimale

Pour l’entrée IN, on peut utiliser soit un connecteur JST 2mm soit les deux broches après soudure.Quant à la sortie, elle est reliée au VIN si la tension d’entrée n’est pas régulée à 5V on utilise ensuite la valeur référence 3.3V ou 5V) sinon directement sur le 5V.

On peut faire fonctionner le coulomb counter soit en mode manuel ou en mode automatique. Pour cela, il suffit d’agir sur les pins CLR et INT.

Exemple d'utilisation:

Dans l’exemple suivant, nous mesurons la température ambiante à l’aide d’un capteur Thermistance 4K7 tout en utilisant  une LED  qui reste allumée. Cette mesure s’effectue à chaque valeur de flux d’électrons passés. On enregistre ensuite les différentes données obtenues dans une carte SD. Nous utilisons également le mode automatique c’est-à-dire que le pin INT revient à son état antérieur après qu’il ait changé d’état lorsqu’une certaine quantité d’électricité ait circulé à travers le coulomb counter.

Code Arduino:

//library for SD card
#include<SD.h>
const int INT=3;
const int POL=6;
const int LedPin=9;
const int chipSelect=4;
// Change the following two lines to match your battery
// and its initial state-of-charge:
volatile double battery_mAh = 1000.0; // milliamp-hours (mAh)
volatile double battery_percent = 100.0;  // state-of-charge (percent)
// Global variables ("volatile" means the interrupt can change them behind the scenes):
volatile boolean isrflag;
volatile long int time, lasttime,time1;
volatile double mA;
double ah_quanta = 0.17067759; // mAh for each INT
double percent_quanta; // calculate below
//////////////////////////////////////////////////////////////
//////////////////SETUP//////////////////////////////////////
////////////////////////////////////////////////////////////
void setup()
{
// Set up I/O pins:
  pinMode(INT,INPUT); // Interrupt input pin 
  pinMode(POL,INPUT); // Polarity input pin  
  pinMode(LedPin,OUTPUT);
  digitalWrite(LedPin,HIGH);
  pinMode(chipSelect,OUTPUT);
// Enable serial output:
  Serial.begin(9600);
  Serial.print("Initializing SD card...");
// see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
     Serial.println("Card failed, or not present");
   return;
  }
  Serial.println("card initialized.");
  Serial.println("LTC4150 Coulomb Counter BOB interrupt's mode");
  // One INT is this many percent of battery capacity: 
  percent_quanta = 1.0/(battery_mAh/1000.0*5859.0/100.0);

// Enable active-low interrupts on D3 (INT1) to function myISR().
  // On 328 Arduinos, you may also use D2 (INT0), change '1' to '0'. 
  isrflag = false;
  attachInterrupt(1,myISR,FALLING);
}
////////////////////////////////////////////////////////////
/////////////////LOOP//////////////////////////////////////
//////////////////////////////////////////////////////////
void loop()
{
  static int n = 0;
  // When we detect an INT signal, the myISR() function
  // will automatically run. myISR() sets isrflag to TRUE
  // so that we know that something happened.
  if (isrflag)
  {
    // Reset the flag to false so we only do this once per INT    
    isrflag = false;
    // Blink the LED
 delay(100);   
  long Resistance;
  double Temp; 
  int sensor = analogRead(A0);
  Resistance=(10230000/sensor-4700);
  Temp = log(Resistance);
  Temp = 1 / (0.001129148 + (0.000234125 * Temp) + (0.0000000876741 * Temp * Temp * Temp));
  Temp = Temp - 273.15;
    // Print out current status (variables set by myISR()) 
    Serial.print("sensor");
    Serial.print(sensor);
    Serial.print("Temp:     °C");
    Serial.print(Temp);
    Serial.print("mAh: ");
    Serial.print(battery_mAh);
    Serial.print(" soc: ");
    Serial.print(battery_percent);
    Serial.print("% time: ");
    Serial.print((time-lasttime)/1000000.0);
    Serial.print(",,");
    Serial.print(time1);
    Serial.print("s mA: ");
    Serial.println(mA);
    String sensorValue=String(sensor);
    String TempStg=String(Temp);
    String mAh=String(battery_mAh);
    String percent=String(battery_percent);
    String time2=String(time1);
    String mAStg=String(mA);
    String valueStg=sensorValue +","+ TempStg +","+ mAh +","+ percent +","+ time2 +"s"","+ mAStg;
    File datafile=SD.open("QuanBa.csv",FILE_WRITE);
      datafile.print("sensor");
      datafile.print(",");
      datafile.print("temperature");
      datafile.print(",");
      datafile.print("mAh");
      datafile.print(",");
      datafile.print("percent");
      datafile.print(",");
      datafile.print("time ");
      datafile.print(",");
      datafile.println("mA");
      datafile.println(valueStg);
      datafile.close();
  }
  // You can run your own code in the main loop()
  // myISR() will automatically update information
  // as it needs to, and set isrflag to let you know
  // that something has changed.
}
void myISR() // Run automatically for falling edge on D3 (INT1)
{
  static boolean polarity;  
  // Determine delay since last interrupt (for mA calculation)
  // Note that first interrupt will be incorrect (no previous time!)
  lasttime = time;
  time = micros();
  // Get polarity value 
  polarity = digitalRead(POL);
  if (polarity) // high = charging
  {
    battery_mAh += ah_quanta;
    battery_percent += percent_quanta;
  }
  else // low = discharging
  {
    battery_mAh -= ah_quanta;
    battery_percent -= percent_quanta;
  }
  // Calculate mA from time delay (optional)
  time1=((time-lasttime)/1000000.0);
  mA = 614.4/((time-lasttime)/1000000.0);
  // If charging, we'll set mA negative (optional) 
  if (polarity) mA = mA * -1.0;
  // Set isrflag so main loop knows an interrupt occurred  
  isrflag = true;
}

Circuit illustrant l’exemple

Si vous avez des questions n’hésitez pas à les posez en commentaires.

REAL TIME CLOCK MODULE

Objectif:   

Connaître l’heure et la date (lecture et réglage)

Ce dont vous avez besoin:

- RTC Module

- Arduino UNO

- 4 fils connecteurs

- Disponibles ici

Avec le RTC module, nous pouvons  suivre l’évolution dans le temps d’un projet en cours. En effet, le RTC module nous indique l’heure et la date .Il contient en outre une batterie  CR1225 lui permettant de fonctionner de façon autonome.

Son circuit étant constitué du circuit intégré DS1307, le système d’oscillation à quartz est celui utilisé. Ainsi une meilleure précision de l’heure est obtenue.

Facile à utiliser; il dispose de cinq pins dont seulement les quatre seront utilisés après les avoir soudés pour bien les fixer sur une breadboard.

Ces pins sont :

-SCL : Serial Clock

-SDA :Serial Data

-SQW

-GND

-5V

SCL et SDA seront respectivement connectés aux entrées analogiques A5 et A4 pour l’Arduino UNO. Le système fonctionne sous 5V .Donc seul le SQW n’est pas relié.

Utilisant des registres, on procèdera alors pour le programme sous arduino à une conversion de la base binaire à la base décimale. En effet cela est dû au DS1307 qui code toutes les données en BCD (code binaire décimal).

Comme toute montre on peut régler l’heure et la date.

Dans l’exemple 1, nous lisons à travers le Serial monitor l’heure et la date.

Exemple 1:

//library “Wire” using
#include <Wire.h> 
#define DS1307_ADDRESS 0x68
////////////////////////////////////////////////////
////////////////////SETUP//////////////////////////
//////////////////////////////////////////////////
void setup(){
//Open serial communications and wait for port to open:
  Wire.begin();
  Serial.begin(9600);
}	
//print date and time every second by calling “printDate()”function
////////////////////////////////////////////////////////////////////
///////////////////LOOP////////////////////////////////////////
//////////////////////////////////////////////////////////////
void loop(){
  printDate();
  delay(1000);
}
byte bcdToDec(byte val)  {
//Convert binary coded decimal to normal decimal numbers
  return ( (val/16*10) + (val%16) );
}
//define printDate() function
void printDate(){
//Reset the register pointer
  Wire.beginTransmission(DS1307_ADDRESS);
  byte zero = 0x00;
  Wire.write(zero);
  Wire.endTransmission();
  Wire.requestFrom(DS1307_ADDRESS, 7);
  int second = bcdToDec(Wire.read());
  int minute = bcdToDec(Wire.read());
  int hour = bcdToDec(Wire.read() & 0b111111); //24 hour time
  int weekDay = bcdToDec(Wire.read()); //0-6 -> sunday – Saturday
switch(weekDay){
  case 0:Serial.print("Sunday");break;
  case 1:Serial.print("Monday");break;
  case 2:Serial.print("Tuesday");break;
  case 3:Serial.print("Wednesday");break;
  case 4:Serial.print("Thursday");break;
  case 5:Serial.print("Friday");break;
  case 6:Serial.print("Saturday");break;
}
  int monthDay = bcdToDec(Wire.read());
  int month = bcdToDec(Wire.read());
  int year = bcdToDec(Wire.read()); 
  Serial.print(" ");
if(monthDay<10)
  Serial.print("0");
  Serial.print(monthDay,DEC);
  Serial.print("/");
if(month<10)
  Serial.print("0");
  Serial.print(month,DEC);
  Serial.print("/");
  Serial.print(year);
  Serial.print(" ");
if(hour<10)
  Serial.print("0");
  Serial.print(hour,DEC);
  Serial.print(":");
if(minute<10)
  Serial.print("0");
  Serial.print(minute,DEC);
  Serial.print(":");
if(second<10)
  Serial.print("0");
  Serial.println(second,DEC);

}

Dans l’exemple 2 ,nous réglons l’heure et la date. Notons également qu’avec ce programme,on initialise l’heure et la date à chaque fois qu’on ouvre le Serial monitor.

Exemple 2:

// library “Wire” using
#include <Wire.h> 
#define DS1307_ADDRESS 0x68  
///////////////////////////////////////////////////////
//////////////SETUP/////////////////////////////////
/////////////////////////////////////////////////////
void setup(){
//Open serial communications and wait for port to open:
   Wire.begin();
   Serial.begin(9600);
   setDateTime(); //MUST CONFIGURE IN FUNCTION
}
// print date and time every second by calling “printDate()”function
/////////////////////////////////////////////////////////
////////////////LOOP/////////////////////////////////
////////////////////////////////////////////////////
void loop(){ 
  printDate();
  delay(1000);
}
//define "setDateTime()"function
void setDateTime(){
  byte zero = 0x00;
  byte second =      07; //0-59
  byte minute =      13; //0-59
  byte hour =        9; //0-23
  byte weekDay =     3; //0-6
  byte monthDay =    20; //1-31
  byte month =       03; //1-12
  byte year  =       11; //0-99
  Wire.beginTransmission(DS1307_ADDRESS);
  Wire.write(zero); //stop Oscillator
  Wire.write(decToBcd(second));
  Wire.write(decToBcd(minute));
  Wire.write(decToBcd(hour));
  Wire.write(decToBcd(weekDay));
  Wire.write(decToBcd(monthDay));
  Wire.write(decToBcd(month));
  Wire.write(decToBcd(year));
  Wire.write(zero); //start 
  Wire.endTransmission();
}
byte decToBcd(byte val){
//Convert normal decimal numbers to binary coded decimal
  return ( (val/10*16) + (val%10) );
}
byte bcdToDec(byte val)  {
//Convert binary coded decimal to normal decimal numbers
  return ( (val/16*10) + (val%16) );
}


//define "printDate()"function
void printDate(){
   byte zero = 0x00;
//Reset the register pointer
  Wire.beginTransmission(DS1307_ADDRESS);
  Wire.write(zero);
  Wire.endTransmission();
  Wire.requestFrom(DS1307_ADDRESS, 7);
  int second = bcdToDec(Wire.read());
  int minute = bcdToDec(Wire.read());
  int hour = bcdToDec(Wire.read() & 0b111111); //24 hour time
  int weekDay = bcdToDec(Wire.read()); //0-6 -> sunday - Saturday
switch(weekDay){
  case 0:Serial.print("Sunday");break;
  case 1:Serial.print("Monday");break;
  case 2:Serial.print("Tuesaday");break;
  case 3:Serial.print("Wednesday");break;
  case 4:Serial.print("Thursday");break;
  case 5:Serial.print("Friday");break;
  case 6:Serial.print("Saturday");break;
}
  int monthDay = bcdToDec(Wire.read());
  int month = bcdToDec(Wire.read());
  int year = bcdToDec(Wire.read());
  Serial.print(" ");
if(monthDay<10)
  Serial.print("0");
  Serial.print(monthDay,DEC);
  Serial.print("/");
if(month<10)
  Serial.print("0");
  Serial.print(month,DEC);
  Serial.print("/");
  Serial.print(year);
  Serial.print(" ");
if(hour<10)
  Serial.print("0");
  Serial.print(hour,DEC);  
  Serial.print(":");
if(minute<10)
  Serial.print("0");
  Serial.print(minute,DEC);
  Serial.print(":");
if(second<10)
  Serial.print("0");
  Serial.println(second,DEC);
}

Si vous avez des questions n’hésitez pas à les posez en commentaires.

Utilisation de la carte gps

Objectifs

Affichage des données du GPS qu’on envoyera par GSM

Matériels nécessaires:

• Arduino UNO
• Pmod GPS
• Shield GSM

Tous ces matériels sont disponibles sur notre magasin en ligne

Comment procède t-on?

Pour avoir les données du GPS transmises par satellites on doit choisir l’exemple qui est dans la librairie TinyGPS ( librairie déjà téléchargée) puis on choisit l’exemple nommé “test with gps device”, une fois ouvert on va sur le setup pour mettre sur le Serial.begin 115200 (c’est pour l’affichage des données sur le moniteur série) et 9600 pour le GPS( exemple nss.begin(9600) pour SoftwareSerial et altSerial.begin(9600) pour AltSoftSerial), une fois ce code téléversé on pourra lire directement les données sur le moniteur série.
Pour utiliser le GPS et le GSM en même temps c'est-à-dire on envoie les données du GPS par SMS via le GSM on ne peut pas utiliser la librairie SoftwareSerial car cette dernière est en conflit avec la librairie du GSM mais on peut utiliser AltSoftSerial qui est bien compatible avec le GPS et le GSM.

Exemple:

#include <AltSoftSerial.h>
#include <TinyGPS.h>
#include <GSM.h>

NB: Notons que AltSoftSerial utilisent les pins 9 et 8 respectivement pour TX et RX pour la carte Arduino UNO.
Si j’utilise ces pins respectivement sur le câblage je risque de ne pas avoir de données je ne sais pas exactement la cause mais j’intervertis seulement les pins pour avoir les données.

Pour se faire on peut envoyer le message sans pour autant utiliser le moniteur série pour entrer le numéro c'est-à-dire on entre le numéro de téléphone directement dans le code pour cela on crée une fonction qui comportera et le numéro de téléphone et le contenu du message(les données du GPS) et cette fonction déclarée sera appelée dans le loop.

Exemple:

void sendSMS(char* myNumber,long myMessage1,long myMessage2) et dans le loop j’ai
ça  sendSMS("myNumber",lat,lon);

lat et lon sont la latitude et la longitude que j’ai déclaré dés le début long lat,lon;


Maintenant voici le code qu'on a utilisé, on a seulement comme données la latitude et la longitude que nous allons envoyer comme message toutes les minutes.

  
#include <AltSoftSerial.h>

#include <TinyGPS.h>
#include <GSM.h>
AltSoftSerial altSerial;
TinyGPS gps; // créer gps object
// initialized gsm
#define PINNUMBER ""
GSM gsmAccess;
GSM_SMS sms;
int mySMSCount=1;

long lat,lon; // create object for latitude and longitude

void setup()
{
 Serial.begin(115200); // serial connexion 
 altSerial.begin(9600); // sensor gps connexion 
 
   // verification état
 boolean notConnected = true;

 // Start GSM shield
 // If your SIM has PIN, pass it as a parameter of begin() in quotes
 while(notConnected)
 {
   if(gsmAccess.begin(PINNUMBER)==GSM_READY)
     notConnected = false;
   else
   {
     Serial.println("Not connected");
    
   }
 
   }
     Serial.println("GSM initialized");
     delay(5000);
}
void loop()
{
 while(altSerial.available())
 { 
  if(gps.encode(altSerial.read()))
  { // encode gps data
   gps.get_position(&lat,&lon); // get latitude and longitude
   // display position 
   Serial.print("Position: ");
   Serial.print("lat: ");
   Serial.print(lat);
   Serial.print(" ");// print latitude
   Serial.print("lon: ");
   Serial.println(lon); //print longitude
  }
 }
 
     sendSMS("myNumber",lat,lon);
     Serial.println(" ");
     Serial.print("message sent: ");
     Serial.println(mySMSCount);
     mySMSCount++;
     
}

void sendSMS(char* myNumber,long myMessage1,long myMessage2)
{
     sms.beginSMS(myNumber);
     sms.print(myMessage1);
     sms.print("/");
     sms.print(myMessage2);
     sms.endSMS(); 
     delay(10000);
     
}

Explication des parties essentielles du code:

AltSoftSerial altSerial;
TinyGPS gps; // créer gps object
L'objet "altSerial" est utilisé pour extraire les données du récepteur GPS, l'objet "GPS" est utilisé pour séparer les données du récepteur en composants individuels.

Nous allons vérifier s’il y a des données qui sont disponibles
while(altSerial.available())

Puis on lit et on encode les données
 if(gps.encode(altSerial.read()))

Enfin, nous conservons les valeurs de latitude et de longitude dans les variables lat et lon.
gps.get_position(&lat,&lon);

Et pour envoyer ces données nous avons déclarées une fonction
void sendSMS(char* myNumber,long myMessage1,long myMessage2)

N'hésitez pas à poser des questions dans les commentaires.

Comment concevoir une voiture téléguidée par Bluetooth?

Présentation du tutoriel

Piloter une voiture par Bluetooth avec un téléphone Android. Pour se faire on a utilisé le châssis d’une ancienne voiture qu’on n'a assemblé avec le matériel que nous avons listé ci dessous pour réaliser ce projet. Pour les moteurs qui ont permis à la propulsion et la direction nous avons utilisé ceux d’origine qui se trouvaient déjà sur la voiture (puisqu'ils étaient en bon état).

Ce dont vous avez besoin

• 1 Arduino UNO R3
• 1 Bluetooth SMIRF Silver
• 1 ProtoShield
• 1 circuit intégré L239D H-bridge
• 1 châssis voiture
• 2 moteurs DC
• 5 piles AA assemblées
• 4 leds
• 2 résistances 220 Ohm pour les phares
• 2 résistances de 1000 Ohm pour les transistors
• 2 transistors 2N3904 NPN ou équivalent
• Des fils de différentes couleurs
• Des connecteurs males et femelles

 Vous pouvez avoir tous ces composant sur Dakar Proto Shop

1- Montage sur BreadBord

  Image1: Câblage sur une breadbord

Apres avoir terminé avec les phares nous allons vous montrer comment nous avons monté le kit Bluetooth. Mais tout d’abord nous allons faire un petit résumé sur ce module Bluetooth pour vous faciliter sa compression.
Comme nous l'avons dis précédemment à la partie matériel nous avons utilisé un BlueSMIRF silver qui a une portée maximale de 10 mètre contrairement au Gold qui peut atteindre les 100 mètres. Il est facile à utiliser et très compatible avec Arduino UNO R3 ici utilisé. Vous pouvez le trouver ici et ici.

2- Présentation de la carte bluetooth

Il contient deux LEDS. Une LED rouge appelée «STAT LED» et une LED verte appelée «CONNECT LED». Elles sont utilisées pour montrer l’état dans lequel se trouve la carte.

    Image2: la carte bluetooth et les différentes parties

      Les entrées, sorties et puissance

Nom des pins	Fonction des pins	Entrées sorties et puissance	Description
RTS-O	Request to send	Output	RTS est utilisé pour le contrôle de flux matériel dans certaines interfaces série. Cette sortie n’est pas critique pour la communication série simple.
RX-I	Serial receive	Input	Cette broche reçoit des données de série d'un autre appareil. Il doit être raccordé au TX de l'autre appareil.
TX-O	Serial transmit	Output	Cette broche transmet les données série à un autre appareil. Il doit être connecté à la RX de l'autre appareil.
VCC	Voltage supply	Power In	Ce signal de tension d'alimentation est acheminé à travers un régulateur de 3,3 V, alors acheminé vers le module Bluetooth. Il devrait se situer entre 3,3 V à 6V.
CTS-I	Clear to send	Input	CTS est un autre signal série de contrôle de flux. Comme RTS, il ne est pas nécessaire pour la plupart, des interfaces série simples.
GND	Ground	Power In	La tension de référence 0V, commune à un autre appareil connecté au modem Bluetooth.

Le BlueSMiRF s’alimente aussi bien en 3,3V qu’en 5V. La tension fournie aux broches VCC / GND peut être ne importe où entre 3,3 et 6V. Les tensions sur les signaux séries et de commande d'entrée (RX-I et CTS-I) peuvent être comprises entre 3,3 V et 5 V. Les signaux de sortie (TX-O et O-RTS) sont à 0 V pour le niveau logique bas, et VCC pour un niveau logique haut.

3-Comment monter sa carte BlueSMiRF ?

Nous avons souder des pins sur la carte pour faciliter son montage sur notre protoshield

     Image3: la carte avec des pins soudés

TX-O est reliée au pin 2 de l'Arduino, RX-i est reliée au pin 3 de l’arduino, GND à GND, VCC à 5V. Les broches CTS-I et RTS-S ne sont pas connectées. Les broches TX-O et RX-I pourraient être connectées à n’importe quelle broche numérique (supérieur à 0 et 1), si vous avez besoin 2 et 3 pour autre chose.

Image4: montage de la carte BlueSMiRF sur un Arduino UNO R3

Après avoir préparé notre carte Bluetooth on va à présent faire un peu de soudure sur le Protoshield. On va ajouter le H-Bridge L239D IC ( dans le cercle rouge) et des pins femelles pour monter la carte. Comme dans l’image qui suit.

Image5: Protoshield et le H-Bridge monté la dessus.

Un petit commentaire sur le L239D IC s’impose parce que c’est un élément très important pour le pilotage. Le circuit intégré H-Bridges L239D IC permet de contrôler deux moteurs DC grâce à ses 16 pins dont 4 pins de contrôle qui sont ici les pins (2, 7, 10 et 15) pins respectives des moteurs de propulsion et direction. Il s’active avec le Enable pin qui se trouve sur ces pattes (1 et 9). Ses deux pattes du milieu de chaque cote sont relies au GND (ground, 0V). Les autres les pattes (4, 5, 12 et 13) sont raccordées aux deux moteurs. Et le reste de ses pattes (8 et 16) sont reliées au VCC (5V). Et c’est grâce à ce petit circuit intégré qu’on peut contrôler les moteurs dans notre application. Vous pouvez vous procurer ce composant dans sur dakarprotoshop.

Code Arduino:

  
#include <SoftwareSerial.h>  

// bluetooth setup
int bluetoothTx = 2;  // TX-O pin of bluetooth mate, Arduino D2
int bluetoothRx = 3;  // RX-I pin of bluetooth mate, Arduino D3
SoftwareSerial bluetooth(bluetoothTx, bluetoothRx);


// H-Bridges pins
int const controlPin1=6; // pin 2 on L293D IC
int const controlPin2 = 4; // pin 7 on L293D IC
int const controlPin3 = 8; // pin 10 on L293D IC
int const controlPin4 = 11; // pin 15 on L239D IC
int const enablePin1 = 9; // pin 1 on L239D IC
int const enablePin2 = 10;// pin 9 on L293D IC
// lights pins
int ledPin1 = 7; // LED connected to pin 7 
int ledPin2 = 12; // LED connected to pin 12  
int hornPin = 5;

int motorSpeed = 100;
boolean warningOn=false;
boolean frontLightOn=false;
boolean backLightOn=false;

void setup() 
{
   //Setup des pins
   pinMode(controlPin1, OUTPUT); 
   pinMode(controlPin2, OUTPUT);
   pinMode(enablePin1, OUTPUT);
   pinMode(controlPin3, OUTPUT);
   pinMode(controlPin4, OUTPUT);
   pinMode(enablePin2, OUTPUT);
   pinMode(ledPin1, OUTPUT);
   pinMode(ledPin2, OUTPUT);  
   pinMode(hornPin, OUTPUT);
   digitalWrite(controlPin1, LOW); 
   digitalWrite(controlPin2, LOW);
   digitalWrite(enablePin1, LOW);
   digitalWrite(controlPin3, LOW);
   digitalWrite(controlPin4, LOW);
   digitalWrite(enablePin2, LOW);
   digitalWrite(ledPin1, LOW);
   digitalWrite(ledPin2, LOW);  
   digitalWrite(hornPin, LOW);
   
   Serial.begin(9600);  // Begin the serial monitor at 9600bps
   
   // activation du bluetooth
    bluetooth.begin(115200);  // The Bluetooth Mate defaults to 115200bps
    bluetooth.print("$");  // Print three times individually
    bluetooth.print("$");
    bluetooth.print("$");  // Enter command mode
    delay(100);  // Short delay, wait for the Mate to send back CMD
    bluetooth.println("U,9600,N");  // Temporarily Change the baudrate to 9600, no parity
    // 115200 can be too fast at times for NewSoftSerial to relay the data reliably
    bluetooth.begin(9600);  // Start bluetooth serial at 9600
    bluetooth.flush();
}
void loop() 
{
  char val; // variable to receive data from the serial port
  
  if(bluetooth.available())  // If the bluetooth sent any characters
  { 
    val =(char)bluetooth.read();         // read it and store it in 'val'
  }
  switch(val)              
  {
    case 'F':
      forward (); // car run forward
      straight();
      break;
    case 'B':
      back (); // car run back
      straight();
      break;
    case 'R':
      turnRight (); // car turn Rght
      stopProp();
      break;
    case 'L':
      turnLeft (); // car turn Left
      stopProp();
      break;
    case 'W':
      frontLightOn=true; // light front on
      break;
    case 'w':
      frontLightOn=false; // light front off
      break;
    case 'U':
      backLightOn=true; // light back on
      break;
    case 'u':
      backLightOn=false; // light back off
      break;
    case 'G':
      {
        turnLeft();
        forward ();
      }
      break;
    case 'I':
      {
        turnRight();
        forward ();
      }
      break;
    case 'H':
      {
        turnLeft ();
        back ();
      }
      break;
    case 'J':
      {
        turnRight ();
        back();
      }
      break;
    case 'V':
      hornOn ();
      break;
    case 'v':
      hornOff ();
      break;
    case 'X':
      warningOn=true;
      break;
    case 'x':
      warningOn=false;
      break;
    case 'S':
      stopAll ();
      break;
    default:  //Get velocity
      if(val=='q')
        {
          motorSpeed= 255;  //Full velocity
        }
      else
        {
          if((val >= 48) && (val <= 57))
           //Chars '0' - '9' have an integer equivalence of 48 - 57, accordingly.
            { 
              //Subtracting 48 changes the range from 48-57 to 0-9.
              //Multiplying by 25 changes the range from 0-9 to 0-225.
              motorSpeed= (val- 48)*25; 
              Serial.print("motorSpeed:");
              Serial.println(motorSpeed);   
             }   
         }
   
  }
  
  setLight();
  
}
void forward ()
{
   digitalWrite(controlPin1,LOW);
   digitalWrite(controlPin2,HIGH);
   analogWrite(enablePin1, motorSpeed);
   
}
void back ()
{
   digitalWrite(controlPin1,HIGH);
   digitalWrite(controlPin2,LOW);
   analogWrite(enablePin1, motorSpeed);
}
void stopProp ()
{
   analogWrite(enablePin1, 0);
}

void turnLeft ()
{
  digitalWrite(controlPin3, HIGH);
  digitalWrite(controlPin4, LOW);
  analogWrite(enablePin2, 250);
}
void turnRight ()
{
  digitalWrite(controlPin3, LOW);
  digitalWrite(controlPin4, HIGH);
  analogWrite(enablePin2, 250);
}
void straight ()
{
  analogWrite(enablePin2, 0);
}
void stopAll ()
{
  analogWrite(enablePin1, 0);
  analogWrite(enablePin2, 0);
}

void hornOn ()
{
  tone(hornPin, 220);
}
void hornOff ()
{
  noTone(hornPin);
}
void setLight ()
{
  if (warningOn){
    if (millis()%1000 <500)
    {
      digitalWrite(ledPin1, HIGH);
      digitalWrite(ledPin2, HIGH);
    }
    else 
    {
      digitalWrite(ledPin1, LOW);
      digitalWrite(ledPin2, LOW);
    }
  }
 else
  {
    digitalWrite(ledPin1, frontLightOn);
    digitalWrite(ledPin2, backLightOn);
  }
}
   

Si vous avez des questions n’hésitez pas à les posez en commentaires.