Émission de données (RTC)/Réception, adressage et affichage des données sur plusieurs shields

Etape 1 : Communication entre 3 CAN Bus Shields : 1 émetteur et 2 récepteurs

Nous allons faire communiquer 3 CAN Bus Shields Un CAN Bus Shield jouera le rôle de l’émetteur. Il sera muni d’un RTC avec module i2c et pourra donc transmettre les données (dates et heures) aux autres Shields. Les deux autres CAN Bus Shields joueront le rôle de récepteur et recevront donc les données envoyées par le premier. Ils pourront afficher ses données, dates et heures, sur leur moniteur série (Ctrl – Maj – M). Nous allons définir un récepteur comme le récepteur 0 et le second comme le récepteur 1. Chacun recevra et affichera des données bien précises venant de l’émetteur. Les deux récepteurs ne recevront donc pas les mêmes données, nous pouvons adresser un message à tel ou tel récepteur selon notre choix.

Pour réaliser cette manipulation, nous disposons de :

• 3 cartes Arduino UNO
• 3 Can Bus Shields v.1.2
• une horloge RTC avec module i2c
• des fils de liaisons
• 3 câbles d’alimentation USB

Pour le montage :

• Il faut brancher chaque shield sur un Arduino et relier les signaux CAN_H et CAN_L de chacun.
• Sur un CAN Bus Shield il faut brancher une clock (RTC avec module i2c).

• GND RTC => GND Shield
• VCC RTC => +5V Shield
• SDA RTC => pin analogique A4 Shield
• SCL RTC => pin analogique A5 Shield

Une fois le montage réalisé, nous pouvons ouvrir le programme Arduino et écrire les 3 codes pour chacun des CAN Bus Shields.

Code Emetteur (CAN Bus Shield avec le RTC) :

// Code pour émettre et afficher date et heure sur le moniteur série à l'aide d'un RTC avec module i2c

#include "Wire.h" //librairie déjà disponible sur Arduino
#include "uRTCLib.h" // bibliothèque pour RTC DS1307 à télécharger : croquis - inclure une bibliothèque -gérer les bibliothèques - uRTCLib par Naguissa
#include <mcp_can.h> // télécharger cette librairie en ZIP sur https://github.com/Seeed-Studio/CAN_BUS_Shield et l'ajouter à notre logiciel Arduino
#include <SPI.h> // librairie déjà disponible sur Arduino

#define SPI_CS_PIN 9 // Chip Select bus CAN = broche 9
MCP_CAN CAN(SPI_CS_PIN); // configuration CAN

byte hours = 0; // variables pour l'horloge RTC DS1307
byte mins = 0;
byte sec = 0;
byte date = 0;
byte mois = 0;
int annee = 0;
byte jour = 0;

byte canId = 0;

unsigned char stmp[7] = {0,1,2,3,4,5,6};   // crée un tableau de 7 variables char = données à transmettre (secondes, minutes, heures, jour de la semaine, date, mois, année)
uRTCLib rtc; // création de l'objet rtc

void setup()
{
  Serial.begin(115200);   //nombre de bauds: définir le même nombre sur le moniteur série (Ctrl - Maj - M)
  
rtc.set(0, 48, 14, 3, 2, 8, 17); //Pour initialiser l'horloge : il faut fixer les valeurs correspondantes : 
(secondes, minutes, heures, jour de la semaine (Valeur qui va de 1 à 7 avec 1 = lundi), date, mois, année)


START_INIT:
    if(CAN_OK == CAN.begin(CAN_500KBPS))             // initialisation du bus can : baudrate = 500k
    {
        Serial.println("Initialisation du CAN BUS Shield ok!");   // si le bus can s'initialise correctement alors le moniteur série (Ctrl-Maj-M) affiche cela
    }
    else
    {
        Serial.println("Initialisation du CAN BUS Shield en echec");   //si l'initialisation du Can échoue il tente de se réinitialiser jusqu'à ce que ça fonctionne
        Serial.println("Réinitialisation CAN BUS Shield");
        delay(100);
        goto START_INIT;
    }
}

void loop()  // la fonction loop() s'éxecute sans fin en boucle tant que l'Arduino est sous tension
{
  lectureRTC();   // appel de la fonction lecture données RTC DS1307 : fonction détaillée plus bas
  stmp [0] = hours;
  stmp [1] = mins;
  stmp [2] = sec;
  stmp [3] = jour;
  stmp [4] = date;
  stmp [5] = mois;
  stmp [6] = annee;
  if (sec <= 30)
  {
    CAN.sendMsgBuf(0x00, 0, 7, stmp);  // envoi des données :  id = 0x00, standard frame = 0, nombre de données = 7, stmp : tampon de données
    canId = 0;
  }
  else
  {
    CAN.sendMsgBuf(0x01, 0, 7, stmp);  // envoi des données :  id = 0x01, standard frame = 0, nombre de données = 7, stmp : tampon de données
    canId = 1;
  }
  affRTC();   // appel de la fonction affichage des données RTC sur la console série: fonction détaillée ci-dessous
  delay(10000);
}

void affRTC()   //détails de la fonction affRTC
  {
    Serial.println("-----------------------------");
    Serial.println("Test du Module RTS DS1307 avec la bibliothèque uRTCLib");
    Serial.println("Test du Shield CAN en émission");
    Serial.print ("CAN ID = ");
    Serial.println(canId);
    Serial.print("Nous sommes le ");   //affichage du jour de la semaine
    switch (jour)
    {
      case 1:
        Serial.print("Lun. ");
        break;
      case 2:
        Serial.print("Mar. ");
        break;
      case 3:
        Serial.print("Mer. ");
        break;
      case 4:
        Serial.print("Jeu. ");
        break;
      case 5:
        Serial.print("Ven. ");
        break;
      case 6:
        Serial.print("Sam. ");
        break;
      case 7:
        Serial.print("Dim. ");
        break;
    }
    Serial.print(date);
    Serial.print("/");
    Serial.print(mois);
    Serial.print("/");
    Serial.println(annee);
    Serial.print("Il est : ");
    Serial.print(hours);
    Serial.print(":");
    Serial.print(mins);
    Serial.print(":");
    Serial.println(sec);
    Serial.println();
    delay(1000);
}

void lectureRTC()   // détails de la fonction lectureRTC
{
  rtc.refresh();
  hours = rtc.hour();
  mins = rtc.minute();
  sec = rtc.second();
  date = rtc.day();
  mois = rtc.month();
  annee = rtc.year();
  jour = rtc.dayOfWeek();
}

On va différencier les deux récepteurs : récepteur 0 et récepteur 1.

• Le récepteur 0 affichera la date et l’heure sur son moniteur série ( Ctrl – Maj – M) si les secondes sont inférieures à 30 secondes.
• Le récepteur 1 affichera la date et l’heure sur son moniteur série si les secondes sont supérieures à 30 secondes.

//Programme du recepteur 0 : il reçoit les messages transmis sur le bus CAN et les affiche sur le moniteur série (Ctrl - Maj - M)

#include <SPI.h> // librairie déjà disponible sur Arduino
#include <mcp_can.h> // télécharger cette librairie en ZIP sur https://github.com/Seeed-Studio/CAN_BUS_Shield et l'ajouter à notre logiciel Arduino

#define SPI_CS_PIN 9 // Chip Select bus CAN = broche 9
MCP_CAN CAN(SPI_CS_PIN); // configuration CAN

byte hours = 0; // variables pour l'horloge RTC DS1307
byte mins = 0;
byte sec = 0;
byte date = 0;
byte mois = 0;
int annee = 0;
byte jour = 0;

unsigned char canId = 0 ; // variable identifiant CAN

void setup()
{
    Serial.begin(115200);    //nombre de bauds: définir le même nombre sur le moniteur série (Ctrl - Maj - M)

START_INIT:
    if(CAN_OK == CAN.begin(CAN_500KBPS))        // initialisation du bus can : baudrate = 500k
    {
        Serial.println("Initialisation du CAN BUS Shield ok!");
    }
    else
    {
        Serial.println("Initialisation du CAN BUS Shield en echec");
        Serial.println("Réinitialisation CAN BUS Shield");
        delay(100);
        goto START_INIT;
    }
    CAN.init_Mask(0,0, 0x01); // initialisation mask 0 (buffer 1) on teste le dernier bit
    CAN.init_Mask(1,0, 0x01); // initialisation mask 1 (buffer 2) on teste le dernier bit

    CAN.init_Filt(0,0, 0x00); // positionnement du filtre 0 (buffer 1 - mask 0) réception si Id = 0
    CAN.init_Filt(1,0, 0x00); // positionnement du filtre 1 (buffer 1 - mask 0) réception si Id = 0
    CAN.init_Filt(2,0, 0x00); // positionnement du filtre 2 (buffer 2 - mask 1) réception si Id = 0   
    CAN.init_Filt(3,0, 0x00); // positionnement du filtre 3 (buffer 2 - mask 1) réception si Id = 0  
    CAN.init_Filt(4,0, 0x00); // positionnement du filtre 4 (buffer 2 - mask 1) réception si Id = 0  
    CAN.init_Filt(5,0, 0x00); // positionnement du filtre 5 (buffer 2 - mask 1) réception si Id = 0  
}

void loop()
{
    unsigned char len = 0;
    unsigned char buf[7];

    if(CAN_MSGAVAIL == CAN.checkReceive())            // vérifie l'arrivée d'un message
    {
        CAN.readMsgBuf(&len, buf);    // read data,  len: data length, buf: data buf
        canId = CAN.getCanId();
        hours = buf[0];
        mins = buf[1];
        sec = buf[2];
        jour = buf[3];
        date = buf[4];
        mois = buf[5];
        annee = buf[6];   
        affRTC();   // appel de la fonction affichage des données RTC sur la console série: fonction détaillée ci-dessous
    }
}

void affRTC()    //détails de la fonction affRTC
  {
    Serial.println("-----------------------------");
    Serial.println("Test du Shield CAN en réception");
    Serial.print("Réception de données sur le CAN N° : ");
    Serial.println(canId);
    Serial.print("Nous sommes le ");   //affichage du jour de la semaine
    switch (jour)
    {
      case 1:
        Serial.print("Lun. ");
        break;
      case 2:
        Serial.print("Mar. ");
        break;
      case 3:
        Serial.print("Mer. ");
        break;
      case 4:
        Serial.print("Jeu. ");
        break;
      case 5:
        Serial.print("Ven. ");
        break;
      case 6:
        Serial.print("Sam. ");
        break;
      case 7:
        Serial.print("Dim. ");
        break;
    }
    Serial.print(date);
    Serial.print("/");
    Serial.print(mois);
    Serial.print("/");
    Serial.println(annee);
    Serial.print("Il est : ");
    Serial.print(hours);
    Serial.print(":");
    Serial.print(mins);
    Serial.print(":");
    Serial.println(sec);
    Serial.println();
     delay(1000);
}

//Programme du recepteur 1 : il reçoit les messages transmis sur le bus CAN et les affiche sur le moniteur série (Ctrl - Maj - M)

#include <SPI.h> // librairie déjà disponible sur Arduino
#include <mcp_can.h> // télécharger cette librairie en ZIP sur https://github.com/Seeed-Studio/CAN_BUS_Shield et l'ajouter à notre logiciel Arduino

#define SPI_CS_PIN 9 // Chip Select bus CAN = broche 9
MCP_CAN CAN(SPI_CS_PIN); // configuration CAN

byte hours = 0; // variables pour l'horloge RTC DS1307
byte mins = 0;
byte sec = 0;
byte date = 0;
byte mois = 0;
int annee = 0;
byte jour = 0;

unsigned char canId = 0 ; // variable identifiant CAN

void setup()
{
    Serial.begin(115200);   //nombre de bauds: définir le même nombre sur le moniteur série (Ctrl - Maj - M)

START_INIT:
    if(CAN_OK == CAN.begin(CAN_500KBPS))     // initialisation du bus can : baudrate = 500k
    {
        Serial.println("Initialisation du CAN BUS Shield ok!");
    }
    else
    {
        Serial.println("Initialisation du CAN BUS Shield en echec");
        Serial.println("Réinitialisation CAN BUS Shield");
        delay(100);
        goto START_INIT;
    }
    CAN.init_Mask(0,0, 0x01); // initialisation mask 0 (buffer 1) on teste le dernier bit
    CAN.init_Mask(1,0, 0x01); // initialisation mask 1 (buffer 2) on teste le dernier bit

    CAN.init_Filt(0,0, 0x01); // positionnement du filtre 0 (buffer 1 - mask 0) réception si Id = 1
    CAN.init_Filt(1,0, 0x01); // positionnement du filtre 1 (buffer 1 - mask 0) réception si Id = 1
    CAN.init_Filt(2,0, 0x01); // positionnement du filtre 2 (buffer 2 - mask 1) réception si Id = 1   
    CAN.init_Filt(3,0, 0x01); // positionnement du filtre 3 (buffer 2 - mask 1) réception si Id = 1  
    CAN.init_Filt(4,0, 0x01); // positionnement du filtre 4 (buffer 2 - mask 1) réception si Id = 1  
    CAN.init_Filt(5,0, 0x01); // positionnement du filtre 5 (buffer 2 - mask 1) réception si Id = 1  
}

void loop()
{
    unsigned char len = 0;
    unsigned char buf[7];

    if(CAN_MSGAVAIL == CAN.checkReceive())            // vérifie l'arrivée d'un message
    {
        CAN.readMsgBuf(&len, buf);    // read data,  len: data length, buf: data buf
        canId = CAN.getCanId();
        hours = buf[0];
        mins = buf[1];
        sec = buf[2];
        jour = buf[3];
        date = buf[4];
        mois = buf[5];
        annee = buf[6];   
        affRTC();  // appel de la fonction affichage des données RTC sur la console série: fonction détaillée ci-dessous
    }
}

void affRTC()    //détails de la fonction affRTC
  {
    Serial.println("-----------------------------");
    Serial.println("Test du Shield CAN en réception");
    Serial.print("Réception de données sur le CAN N° : ");
    Serial.println(canId);
    Serial.print("Nous sommes le ");      // affichage jour de la semaine
    switch (jour)
    {
      case 1:
        Serial.print("Lun. ");
        break;
      case 2:
        Serial.print("Mar. ");
        break;
      case 3:
        Serial.print("Mer. ");
        break;
      case 4:
        Serial.print("Jeu. ");
        break;
      case 5:
        Serial.print("Ven. ");
        break;
      case 6:
        Serial.print("Sam. ");
        break;
      case 7:
        Serial.print("Dim. ");
        break;
    }
    Serial.print(date);
    Serial.print("/");
    Serial.print(mois);
    Serial.print("/");
    Serial.println(annee);
    Serial.print("Il est : ");
    Serial.print(hours);
    Serial.print(":");
    Serial.print(mins);
    Serial.print(":");
    Serial.println(sec);
    Serial.println();
   delay(1000);
}

Entre le récepteur 0 et le récepteur 1 il y a une seule différence au niveau du code : pour le récepteur 0, l’Id est à 0 et pour le récepteur 1, l’Id est à 1.

Une fois la compilation et le téléversement de chaque code sur son CAN Bus Shield, nous pouvons ouvrir les moniteurs série (Ctrl – Maj- M) du récepteur 0 et du récepteur 1.

• le moniteur série du récepteur 0 affiche donc bien les dates et heures lorsque les secondes sont inférieures à 30 secondes (canId=0 pour sec<=30)

• le moniteur série du récepteur 1 affiche donc bien les dates et heures lorsque les secondes sont supérieures à 30 secondes (canId=1 pour sec=>30)

Grâce au CAN Bus Shields nous pouvons donc adresser nos messages à tel ou tel Shield à l’aide d’un identifiant (ici Id= 0 ou Id=1). Il s'agit de l'identifiant des messages et peuvent donc être adresser à plusieurs ou un seul shield.

On peut ainsi ajouter davantage de CAN Bus Shields récepteurs et leur adresser tel ou tel messages.

Etape 2 : Communication entre 4 CAN Bus Shields : 2 émetteurs et 2 récepteurs

Nous allons faire communiquer 4 CAN Bus Shields. Dans un premier temps, il faut les brancher ensemble: il suffit de brancher les shields sur les Arduinos et de relier les signaux CAN_H et CAN_L de chacun.

Une fois les quatre shields branchés, nous allons donc pouvoir les faire communiquer. Nous allons définir deux shields comme émetteurs : le premier aura un RTC avec module i2c branché et le second un capteur de température ou un capteur de luminosité. Les 2 autres shields seront des récepteurs : le récepteur 0 recevra les données du RTC et le récepteur 1, les données du capteur.

Dans un premier temps, nous allons tester les capteurs sur les Arduinos pour vérifier qu'ils fonctionnent correctement.

Test du capteur de luminosité sur Carte Arduino UNO

Pour réaliser le montage nous avons besoin de:

• 1 bread board
• 1 câble d’alimentation USB
• 1 carte Arduino UNO
• 1 capteur de luminosité
• une résistante 120 ohms
• 1 led
• 5 fils de liaison

Une fois le montage réalisé comme ci-dessus, sur le programme Arduino nous pouvons donc ajouter le code suivant :

//code qui Lit la luminosité et fait clignoter une LED à vitesse variable.
 
const int luminosityPin = A0;   // Numéro de la broche du capteur de luminosité - brancher fil sur pin A0
const int ledPin = 9;   // Numéro de la broche de la LED - brancher fil sur pin 9
 
void setup() {

  Serial.begin(9600);    // Initialise la communication avec l'ordinateur - nombre de bauds à définir également sur le "moniteur série" (Ctrl - Maj - M)
  pinMode(ledPin, OUTPUT);       // Indique que la broche de la LED est une sortie
}
 
void loop() {
  int sensorValue = analogRead(luminosityPin);    // Lit la valeur du capteur de luminosité
  Serial.print(" Valeur du Capteur = " );   // affiche la valeur du capteur dans le "moniteur série" sur l'ordinateur
  Serial.print(sensorValue);

 int waitTime = map(sensorValue, 0, 1023, 20, 1000);   // Convertit la valeur en durée d'attente pour la LED: il sera nécessaire d'adapter les valeurs du "mapping" en fonction de la luminosité ambiante
 
 Serial.print("\t Delai de clignotement (millisecondes) = ");    // Envoie le résultat vers l'ordinateur
 Serial.println(waitTime);

 // Fait clignoter la LED au rythme de la luminosité
 digitalWrite(ledPin, HIGH); // allume la LED
 delay(waitTime); // attends la durée choisie
 digitalWrite(ledPin, LOW); // éteints la LED
 delay(waitTime); // attends la durée choisie
}

Une fois la compilation et le téléversement du code terminé sur la plateforme Arduino :

• Nous observons que la LED clignote au rythme de la luminosité
• Nous pouvons ouvrir le moniteur série où la valeur du capteur et le délais de clignotement de la LED sont indiqués

Test du capteur de température sur Carte Arduino UNO

Pour réaliser le montage nous avons besoin de:

• 1 bread board
• 1 câble d’alimentation USB
• 1 carte Arduino UNO
• 1 capteur de température
• 3 fils de liaison

Une fois le montage réalisé comme ci-dessus, sur le programme Arduino nous pouvons donc ajouter le code suivant :

//Déclaration et initialisation des variables
  float mesure=0;        //Variable pour le stockage de la mesure retournée par le capteur
  float tension=0;       //Variable pour le stockage de la tension 
  float temperature=0;   //Variable pour le stockage de la température 
  float tempmin=100;     //Temperature mini
  float tempmax=0;       //Temperature maxi
  
  int portana0 = 0;      //Numéro du port analogique sur lequel la température est mesurée


  void setup()
  {
    analogReference(INTERNAL); //Permet de fixer la tension de reference à 1,1 volt
    Serial.begin(9600);        //initialisation de la liaison série à 9 600 bauds - définir le même nombre de bauds sur le moniteur série (Ctrl - Maj - M)
  }


  void loop()
  {
    mesure = analogRead(portana0);  //Lecture de la valeur fournie par le capteur de température
    tension = mesure * 1.1 / 1024;  //Conversion en tension (en volt)
    
    temperature = tension * 100;    //Conversion en température (en degré Celsius)
    if (temperature < tempmin) {tempmin = temperature;} //Calcul temperature mini
    if (temperature > tempmax) {tempmax = temperature;} //Calcul temperature maxi
    
    //Envoi de la tension et des températures au PC par la liaison série pour affichage dans la console
    Serial.print("Tension : "); Serial.print (tension); Serial.print(" Volts - ");         
    Serial.print("Temperatures :"); 
    Serial.print(" Actuelle : "); Serial.print (temperature); 
    Serial.print(" Mini : "); Serial.print (tempmin); 
    Serial.print (" Max : "); Serial.println (tempmax);
    //Attente de 5 secondes avant de faire une nouvelle mesure
    delay(5000);                    
  }

Une fois la compilation et le téléversement du code terminé sur la plateforme Arduino, nous ouvrons le moniteur série (Ctrl – Maj- M), qui nous indique :

• La valeur de la tension
• Les températures actuelle, minimale et maximale

Communication entre les 4 CAN Bus Shields

Nous allons faire communiquer 4 CAN Bus Shields : 2 joueront le rôle d’émetteur et 2 autres le rôle de récepteur. Un émetteur transmettra les données de la clock (RTC avec module i2C) et le deuxième émetteur transmettra les données du capteur de température. Un récepteur recevra les données du RTC (récepteur 0) et l’autre les données du capteur (récepteur 1).

Pour réaliser le montage nous avons besoin de:

• 1 bread board
• 4 câbles d’alimentation USB
• 4 CAN Bus Shields v.1.2
• 4 cartes Arduino UNO
• 1 capteur de température
• 1 horloge RTC avec module i2c
• des fils de liaison

Une fois le montage réalisé, nous pouvons ouvrir le programme Arduino et écrire les 4 codes pour chacun des CAN Bus Shields.

Code Emetteur CAN avec RTC :

// Code pour afficher date et heure sur le moniteur série à l'aide d'un RTC avec module i2c

#include "Wire.h" //librairie déjà disponible sur Arduino
#include "uRTCLib.h" // bibliothèque pour RTC DS1307 à télécharger : croquis - inclure une bibliothèque -gérer les bibliothèques - uRTCLib par Naguissa
#include <mcp_can.h> // télécharger cette librairie en ZIP sur https://github.com/Seeed-Studio/CAN_BUS_Shield et l'ajouter à notre logiciel Arduino
#include <SPI.h> // librairie déjà disponible sur Arduino

#define SPI_CS_PIN 9 // Chip Select bus CAN = broche 9
MCP_CAN CAN(SPI_CS_PIN); // configuration CAN

byte hours = 0; // variables pour l'horloge RTC DS1307
byte mins = 0;
byte sec = 0;
byte date = 0;
byte mois = 0;
int annee = 0;
byte jour = 0;

byte canId = 0;

unsigned char stmp[7] = {0,1,2,3,4,5,6};   // crée un tableau de 7 variables char = données à transmettre (secondes, minutes, heures, jour de la semaine, date, mois, année)
uRTCLib rtc; // création de l'objet rtc

void setup()
{
  Serial.begin(115200);   //nombre de bauds: définir le même nombre sur le moniteur série (Ctrl - Maj - M)
  
rtc.set(0, 43, 10, 5, 4, 8, 17); //Pour initialiser l'horloge : il faut fixer les valeurs correspondantes : 
 (secondes, minutes, heures, jour de la semaine (Valeur qui va de 1 à 7 avec 1 = lundi), date, mois, année)


START_INIT:
    if(CAN_OK == CAN.begin(CAN_500KBPS))             // initialisation du bus can : baudrate = 500k
    {
        Serial.println("Initialisation du CAN BUS Shield ok!");   // si le bus can s'initialise correctement alors le moniteur série (Ctrl-Maj-M) affiche cela
    }
    else
    {
        Serial.println("Initialisation du CAN BUS Shield en echec");   //si l'initialisation du Can échoue il tente de se réinitialiser jusqu'à ce que ça fonctionne
        Serial.println("Réinitialisation CAN BUS Shield");
        delay(100);
        goto START_INIT;
    }
}

void loop()  // la fonction loop() s'éxecute sans fin en boucle tant que l'Arduino est sous tension
{
  lectureRTC();   // appel de la fonction lecture données RTC DS1307 : fonction détaillée plus bas
  stmp [0] = hours;
  stmp [1] = mins;
  stmp [2] = sec;
  stmp [3] = jour;
  stmp [4] = date;
  stmp [5] = mois;
  stmp [6] = annee;

  CAN.sendMsgBuf(0x00, 0, 7, stmp);  // envoi des données :  id = 0x00, standard frame = 0, nombre de données = 7, stmp : tampon de données
  canId = 0;

  affRTC();   // appel de la fonction affichage des données RTC sur la console série: fonction détaillée ci-dessous
  delay(10000);
}


void affRTC()   //détails de la fonction affRTC
  {
    Serial.println("-----------------------------");
    Serial.println("Test du Module RTS DS1307 avec la bibliothèque uRTCLib");
    Serial.println("Test du Shield CAN en émission");
    Serial.print ("CAN ID = ");
    Serial.println(canId);
    Serial.print("Nous sommes le "); //affichage du jour de la semaine
    switch (jour)
    {
      case 1:
        Serial.print("Lun. ");
        break;
      case 2:
        Serial.print("Mar. ");
        break;
      case 3:
        Serial.print("Mer. ");
        break;
      case 4:
        Serial.print("Jeu. ");
        break;
      case 5:
        Serial.print("Ven. ");
        break;
      case 6:
        Serial.print("Sam. ");
        break;
      case 7:
        Serial.print("Dim. ");
        break;
    }
    Serial.print(date);
    Serial.print("/");
    Serial.print(mois);
    Serial.print("/");
    Serial.println(annee);
    Serial.print("Il est : ");
    Serial.print(hours);
    Serial.print(":");
    Serial.print(mins);
    Serial.print(":");
    Serial.println(sec);
    Serial.println();
    delay(1000);
}
void lectureRTC()   // détails de la fonction lectureRTC
{
  rtc.refresh();
  hours = rtc.hour();
  mins = rtc.minute();
  sec = rtc.second();
  date = rtc.day();
  mois = rtc.month();
  annee = rtc.year();
  jour = rtc.dayOfWeek();
}

Code Récepteur des données du CAN avec RTC (récepteur 0 : Id=0):

//Programme du recepteur 0 : il reçoit les messages transmis sur le bus CAN avec le RTC et les affiche sur le moniteur série (Ctrl - Maj - M)

#include <SPI.h> // librairie déjà disponible sur Arduino
#include <mcp_can.h> // télécharger cette librairie en ZIP sur https://github.com/Seeed-Studio/CAN_BUS_Shield et l'ajouter à notre logiciel Arduino

#define SPI_CS_PIN 9 // Chip Select bus CAN = broche 9
MCP_CAN CAN(SPI_CS_PIN); // configuration CAN

byte hours = 0; // variables pour l'horloge RTC DS1307
byte mins = 0;
byte sec = 0;
byte date = 0;
byte mois = 0;
int annee = 0;
byte jour = 0;

unsigned char canId = 0 ; // variable identifiant CAN

void setup()
{
    Serial.begin(115200);    //nombre de bauds: définir le même nombre sur le moniteur série (Ctrl - Maj - M)

START_INIT:
    if(CAN_OK == CAN.begin(CAN_500KBPS))           // initialisation du bus can : baudrate = 500k
    {
        Serial.println("Initialisation du CAN BUS Shield ok!");
    }
    else
    {
        Serial.println("Initialisation du CAN BUS Shield en echec");
        Serial.println("Réinitialisation CAN BUS Shield");
        delay(100);
        goto START_INIT;
    }
    CAN.init_Mask(0,0, 0x01); // initialisation mask 0 (buffer 1) on teste le dernier bit
    CAN.init_Mask(1,0, 0x01); // initialisation mask 1 (buffer 2) on teste le dernier bit

    CAN.init_Filt(0,0, 0x00); // positionnement du filtre 0 (buffer 1 - mask 0) réception si Id = 0
    CAN.init_Filt(1,0, 0x00); // positionnement du filtre 1 (buffer 1 - mask 0) réception si Id = 0
    CAN.init_Filt(2,0, 0x00); // positionnement du filtre 2 (buffer 2 - mask 1) réception si Id = 0   
    CAN.init_Filt(3,0, 0x00); // positionnement du filtre 3 (buffer 2 - mask 1) réception si Id = 0  
    CAN.init_Filt(4,0, 0x00); // positionnement du filtre 4 (buffer 2 - mask 1) réception si Id = 0  
    CAN.init_Filt(5,0, 0x00); // positionnement du filtre 5 (buffer 2 - mask 1) réception si Id = 0  
}

void loop()
{
    unsigned char len = 0;
    unsigned char buf[7];

    if(CAN_MSGAVAIL == CAN.checkReceive())            // vérifie l'arrivée d'un message
    {
        CAN.readMsgBuf(&len, buf);    // read data,  len: data length, buf: data buf
        canId = CAN.getCanId();
        hours = buf[0];
        mins = buf[1];
        sec = buf[2];
        jour = buf[3];
        date = buf[4];
        mois = buf[5];
        annee = buf[6];   
        affRTC();   // appel de la fonction affichage des données RTC sur la console série: fonction détaillée ci-dessous
    }
}

void affRTC()    //détails de la fonction affRTC
  {
    Serial.println("-----------------------------");
    Serial.println("Test du Shield CAN en réception");
    Serial.print("Réception de données sur le CAN N° : ");
    Serial.println(canId);
    Serial.print("Nous sommes le ");   //affichage du jour de la semaine
    switch (jour)
    {
      case 1:
        Serial.print("Lun. ");
        break;
      case 2:
        Serial.print("Mar. ");
        break;
      case 3:
        Serial.print("Mer. ");
        break;
      case 4:
        Serial.print("Jeu. ");
        break;
      case 5:
        Serial.print("Ven. ");
        break;
      case 6:
        Serial.print("Sam. ");
        break;
      case 7:
        Serial.print("Dim. ");
        break;
    }
    Serial.print(date);
    Serial.print("/");
    Serial.print(mois);
    Serial.print("/");
    Serial.println(annee);
    Serial.print("Il est : ");
    Serial.print(hours);
    Serial.print(":");
    Serial.print(mins);
    Serial.print(":");
    Serial.println(sec);
    Serial.println();
     delay(1000);
}

Code Emetteur CAN avec capteur de température:

// Code pour afficher la température sur le moniteur série à l'aide d'un capteur de température

#include "Wire.h" //librairie déjà disponible sur Arduino
#include <mcp_can.h> // télécharger cette librairie en ZIP sur https://github.com/Seeed-Studio/CAN_BUS_Shield et l'ajouter à notre logiciel Arduino
#include <SPI.h> // librairie déjà disponible sur Arduino

#define SPI_CS_PIN 9 // Chip Select bus CAN = broche 9
MCP_CAN CAN(SPI_CS_PIN); // configuration CAN

//Déclaration et initialisation des variables
float mesure=0;        //Variable pour le stockage de la mesure retournée par le capteur
float tension=0;       //Variable pour le stockage de la tension 
float temperature=0;   //Variable pour le stockage de la température 
float tempmin=100;     //Temperature mini
float tempmax=0;       //Temperature maxi
  
int portana0 = 0;      //Numéro du port analogique sur lequel la température est mesurée


byte canId = 0;

unsigned char stmp[4] = {0,1,2,3};   // crée un tableau de 4 variables char = données à transmettre (tension, températures : actuelle, mini, maxi)

void setup()
{
  analogReference(INTERNAL); //Permet de fixer la tension de reference à 1,1 volt
  Serial.begin(115200);   //nombre de bauds: définir le même nombre sur le moniteur série (Ctrl - Maj - M)
  
START_INIT:
    if(CAN_OK == CAN.begin(CAN_500KBPS))         // initialisation du bus can : baudrate = 500k
    {
        Serial.println("Initialisation du CAN BUS Shield ok!");   // si le bus can s'initialise correctement alors le moniteur série (Ctrl-Maj-M) affiche cela
    }
    else
    {
        Serial.println("Initialisation du CAN BUS Shield en echec");   //si l'initialisation du Can échoue il tente de se réinitialiser jusqu'à ce que ça fonctionne
        Serial.println("Réinitialisation CAN BUS Shield");
        delay(100);
        goto START_INIT;
    }
}

void loop()  // la fonction loop() s'éxecute sans fin en boucle tant que l'Arduino est sous tension
{
   mesure = analogRead(portana0);  //Lecture de la valeur fournie par le capteur de température
   tension = mesure * 1.1 / 1024;  //Conversion en tension (en volt)
    
   temperature = tension * 100;    //Conversion en température (en degré Celsius)
   if (temperature < tempmin) {tempmin = temperature;} //Calcul temperature mini
   if (temperature > tempmax) {tempmax = temperature;} //Calcul temperature maxi

  stmp [0] = tension;
  stmp [1] = temperature;
  stmp [2] = tempmin;
  stmp [3] = tempmax;

    CAN.sendMsgBuf(0x01, 0, 4, stmp);  // envoi des données :  id = 0x01, standard frame = 0, nombre de données = 4, stmp : tampon de données
    canId = 1;

Serial.println("-----------------------------");
    Serial.println("Test du capteur de température");
    Serial.println("Test du Shield CAN en émission");
    Serial.print ("CAN ID = ");
    Serial.println(canId);

    //Envoi de la tension et des températures au PC par la liaison série pour affichage dans la console
    Serial.print("Tension : "); Serial.print (tension); Serial.print(" Volts - ");         
    Serial.print("Temperatures :"); 
    Serial.print(" Actuelle : "); Serial.print (temperature); 
    Serial.print(" Mini : "); Serial.print (tempmin); 
    Serial.print(" Max : "); Serial.print (tempmax);
    delay(5000);     //Attente de 5 secondes avant de faire une nouvelle mesure 
}

//Programme du recepteur 1 : il reçoit les messages transmis sur le bus CAN par le capteur de température et les affiche sur le moniteur série

#include <SPI.h> // librairie déjà disponible sur Arduino
#include <mcp_can.h> // télécharger cette librairie en ZIP sur https://github.com/Seeed-Studio/CAN_BUS_Shield et l'ajouter à notre logiciel Arduino
#define SPI_CS_PIN 9 // Chip Select bus CAN = broche 9
MCP_CAN CAN(SPI_CS_PIN); // configuration CAN

//Déclaration et initialisation des variables
float mesure=0;        //Variable pour le stockage de la mesure retournée par le capteur
float tension=0;       //Variable pour le stockage de la tension 
float temperature=0;   //Variable pour le stockage de la température 
float tempmin=100;     //Temperature mini
float tempmax=0;       //Temperature maxi
int portana0 = 0;      //Numéro du port analogique sur lequel la température est mesurée
unsigned char canId = 0 ; // variable identifiant CAN

void setup()
{
    analogReference(INTERNAL); //Permet de fixer la tension de reference à 1,1 volt
    Serial.begin(115200);   //nombre de bauds: définir le même nombre sur le moniteur série (Ctrl - Maj - M)

START_INIT:
    if(CAN_OK == CAN.begin(CAN_500KBPS))        // initialisation du bus can : baudrate = 500k
    {
        Serial.println("Initialisation du CAN BUS Shield ok!");
    }
    else
    {
        Serial.println("Initialisation du CAN BUS Shield en echec");
        Serial.println("Réinitialisation CAN BUS Shield");
        delay(100);
        goto START_INIT;
    }
    CAN.init_Mask(0,0, 0x01); // initialisation mask 0 (buffer 1) on teste le dernier bit
    CAN.init_Mask(1,0, 0x01); // initialisation mask 1 (buffer 2) on teste le dernier bit

    CAN.init_Filt(0,0, 0x01); // positionnement du filtre 0 (buffer 1 - mask 0) réception si Id = 1
    CAN.init_Filt(1,0, 0x01); // positionnement du filtre 1 (buffer 1 - mask 0) réception si Id = 1
    CAN.init_Filt(2,0, 0x01); // positionnement du filtre 2 (buffer 2 - mask 1) réception si Id = 1   
    CAN.init_Filt(3,0, 0x01); // positionnement du filtre 3 (buffer 2 - mask 1) réception si Id = 1  
    CAN.init_Filt(4,0, 0x01); // positionnement du filtre 4 (buffer 2 - mask 1) réception si Id = 1  
    CAN.init_Filt(5,0, 0x01); // positionnement du filtre 5 (buffer 2 - mask 1) réception si Id = 1  
}

void loop()
{
    unsigned char len = 0;
    unsigned char buf[4];
   
    if(CAN_MSGAVAIL == CAN.checkReceive())            // vérifie l'arrivée d'un message
    {
        CAN.readMsgBuf(&len, buf);    // read data,  len: data length, buf: data buf
        canId = CAN.getCanId();
        tension = buf[0];
        temperature = buf[1];
        tempmin = buf[2];
        tempmax = buf[3];
        
        affTemperature();  // appel de la fonction affichage des données du capteur de température sur la console série: fonction détaillée ci-dessous
    }
}

void affTemperature()    //détails de la fonction affTemperature
  {
    Serial.println("-----------------------------");
    Serial.println("Test du Shield CAN en réception");
    Serial.print("Réception de données sur le CAN N° : ");
    Serial.println(canId);

    
    //Envoi de la tension et des températures au PC par la liaison série pour affichage dans la console
    Serial.print("Tension : "); Serial.print (tension); Serial.print(" Volts - ");         
    Serial.print("Temperatures :"); 
    Serial.print(" Actuelle : "); Serial.print (temperature); 
    Serial.print(" Mini : "); Serial.print (tempmin); 
    Serial.print (" Max : "); Serial.println (tempmax);
    delay(5000);     //Attente de 5 secondes avant de faire une nouvelle mesure                
  }

Une fois la compilation et le téléversement de chaque code sur son CAN Bus Shield, nous pouvons ouvrir les moniteurs série (Ctrl – Maj- M) du récepteur 0 et du récepteur 1.

• Le moniteur série du récepteur 0 nous indique la date et l’heure exacte :

• Le moniteur série du récepteur 1 nous indique la température (actuelle, mini et maxi) :