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.