Émission de données (RTC)/Réception et affichage des données : Différence entre versions

Version du 17 juillet 2017 à 21:20

Tout d'abord nous allons mettre en œuvre le breakout Tiny RTC et un afficheur LCD avec une liaison I2C, puis dans un second temps nous allons mettre en œuvre le bus CAN en deux arduinos Uno.le breakout Tiny RTC sera branché sur le premier arduino Uno, l'afficheur RTC sera branché sur un second arduino Uno qui pourra afficher les données émises par le RTC.

Présentation et objectifs

Le but de ce tutoriel est de tester le fonctionnement de l’horloge RTC sur l’écran LCD à l’aide d’une carte Arduino UNO. La manipulation permet de faire communiquer l’horloge avec l’écran LCD afin que ce dernier affiche l’heure et la date. Ce tutoriel nécessite une connaissance minimale de la plateforme Arduino. La page Formation Arduino du wiki contient toutes les ressources nécessaires pour découvrir la programmation avec Arduino.

Le montage utilise donc :

• une carte Arduino UNO
• une horloge RTC avec module i2c
• un écran LCD avec module i2c
• des fils de liaison
• une breadboard
• un câble d’alimentation USB

L'utilisation de ce connecteur permet d'accéder directement aux signaux CAN_H et CAN_L sans passer par la prise DB-9.

Le montage final devrait ressembler à cela :

Pré-requis

Ce tutoriel nécessite une connaissance minimale de la plateforme Arduino. La page Formation Arduino contient toutes les ressources nécessaires pour découvrir la programmation avec Arduino.

La bibliothèque CAN_BUS_Shield devra être ajouté à votre installation Arduino pour faire fonctionner les programmes ci-après.

Matériel

Matériel nécessaire :

• 2 Arduino Uno
• 2 shield CAN-BUS Sparkfun
• 2 Résistances de 120 Ohms
• Straps ou fils de liaison

Émission/Réception simple

Etape 1 : Cablage

Pour cette étape, il suffit de brancher les shields sur les Arduinos et de relier les signaux CAN_H, CAN_L et GND par des straps comme sur la photo suivante :

Pour atteindre des vitesses de transmission supérieures à 40Kbit/s, il faut rajouter une résistance de 120 Ohms entre CAN_H et CAN_L.

Etape 2 : Programmation de l'émetteur

Sur l'Arduino émetteur téléverser le programme ci-après. Ce programme va envoyer sans cesse un message standard contenant les données "0, 1, 2, 3, 4, 5, 6, 7" avec l'identifiant 0.

/*
  Ce programme envoie un tableau de donnée sur le bus CAN
*/
#include <mcp_can.h>
#include <SPI.h>
const int SPI_CS_PIN = 10;
MCP_CAN CAN(SPI_CS_PIN);

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

START_INIT:
    if(CAN_OK == CAN.begin(CAN_500KBPS))                   // init can bus : 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;
    }
}

unsigned char stmp[8] = {0, 1, 2, 3, 4, 5, 6, 7};

void loop()
{
    // send data:  id = 0x00, standard frame, data len = 8, stmp: data buf
    CAN.sendMsgBuf(0x00, 0, 8, stmp);
    delay(100);
}

Etape 3 : programmation du récepteur

Sur l'Arduino récepteur téléverser le programme suivant :

/*
  Ce programme reçois les messages transmis sur le bus CAN et les affiches sur la console série.
*/
#include <SPI.h>
#include <mcp_can.h>

const int SPI_CS_PIN = 10;
MCP_CAN CAN(SPI_CS_PIN);

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

START_INIT:
    if(CAN_OK == CAN.begin(CAN_500KBPS))                   // init can bus : 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;
    }
}

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

    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

        unsigned char canId = CAN.getCanId();
        
        Serial.println("-----------------------------");
        Serial.println("get data from ID: ");
        Serial.println(canId);

        for(int i = 0; i<len; i++)    // affiche les données
        {
            Serial.print(buf[i]);
            Serial.print("\t");
        }
        Serial.println();
    }
}

Etape 4 : essai de la communication

Brancher les deux Arduinos. Ouvrez la console série du récepteur et vérifier que les données émises sont bien reçues :

Conseils

Si jamais vous n'arrivez pas à recevoir vos données, essayez de baisser la vitesse sur l'émetteur et le récepteur. Si jamais vous n'avez pas de résistances de 120 Ohms, la communication devrait quand-même fonctionner pour des vitesses inférieures à 40Kbit/s.

Pour aller plus loin

Si vous disposez d'un cable DB-9 Droit, vous pouvez remplacer les straps par ce câble. D'après nos premiers essais, il semblerait que le cablage de la prise sur le shield de Sparkfun soit différent du standard. Les différents signaux sont câblés comme suit :

• CAN_L : 5
• CAN_H : 3
• GND : 2

alors que le câblage standard est le suivant :

• CAN_L : 2
• CAN_H : 7
• GND : 3

Bibliographie

• https://github.com/Seeed-Studio/CAN_BUS_Shield
• http://www.seeedstudio.com/wiki/CAN-BUS_Shield
• http://skpang.co.uk/catalog/arduino-canbus-shield-with-usd-card-holder-p-706.html