TP Ethernet industriel : Bus OneWire

Objectifs de cette séance :

• Implémenter les fonctions bas niveau pour la communication sur le bus OneWire
• Implémenter les fonctions match_rom et read_rom du protocole OneWire
• Lire une sonde de température OneWire et afficher la mesure

Savoir-faire associés :

• Comprendre la description par chronogramme d'un protocole
• Décrire la couche physique d'un protocole en langage C

Le bus OneWire est un bus série asynchrone utilisant la largeur d'impulsion pour représenter les symboles:

http://en.wikipedia.org/wiki/1-Wire

Ce bus standardisé par Dallas (racheté par Maxim) permet l'échange de données sur un conducteur. Ce même conducteur peut aussi être utilisé pour véhiculer l'alimentation (parasitic power mode) ce qui réduit le nombre de conducteurs nécessaires à 2 (GND et DQ).

Pour ce TP nous utiliserons le capteur de température DS18B20 :

http://datasheets.maximintegrated.com/en/ds/DS18B20.pdf

Le schéma électrique de la carte utilisée est visible sur la page tdcom2. La broche de l'Arduino utilisée est la numéro 2. Dans la suite, cette broche sera accédée directement via le bit 2 des registres du PORT D de l'ATMEGA328P plutôt que de passer par la librairie Arduino (lente) afin de permettre des timing plus précis.

one_wire.ino

//B. Vandeportaele 2018
 
#define PIN_DS 2 // pin to be used for the OneWire communication
 
unsigned char romSensor[8]={0,0,0,0,0,0,0,0} ; //global variable: array to store the ROM Code of one sensor (its MAC Address)
////////////////////////////////////////////////////////////////////////////
// Macros to access the port much faster than using the Arduino HAL (PinMode, DigitalRead and Write)
#define SET_PIN(x) PORTD |= (1 << x)
#define CLR_PIN(x) PORTD &= ~(1 << x)
#define IN_PIN(x)  DDRD &= ~(1 << x)
#define OUT_PIN(x) DDRD |= (1 << x)
#define GET_PIN(x) ((PIND>> x) & 0x01)
////////////////////////////////////////////////////////////////////////////
// Functions to act or read on the bus
// set the pin as an output at low level value
static void setPinOutPut0(unsigned char x){
    //Insert your code here
 
 
}
// set the pin as an input at high level value
static void setPinInput1(unsigned char x){
    //Insert your code here
 
 
}
// read the value of the input
static unsigned char getPinInput(unsigned char x){
    //Insert your code here
 
 
}
////////////////////////////////////////////////////////////////////////////
#define TRUE 1
#define FALSE 0
////////////////////////////////////////////////////////////////////////////
/*
pin : pin number for the OneWire communication
returns : 1 if a peripherals responded to the reset, 0 otherwise
*/
unsigned char reset_one_wire(unsigned char pin)
{
    unsigned char r;
    unsigned char retries = 125;
    setPinInput1(pin) ;
    // wait until the wire is high... just in case
    do {
        if (--retries == 0) return 0; //if after 250us, the pin is still low, get out
        delayMicroseconds(2);
    } while ( !GET_PIN(pin));
    setPinOutPut0(pin);   // drive output low
    //The reset begins here:
    delayMicroseconds(480);
    setPinInput1(pin);  // allow it to float
    delayMicroseconds(70);
    r = !getPinInput(pin); //the value read from the pin is inverted to obtain the return value
    delayMicroseconds(410);
    return r;
}
////////////////////////////////////////////////////////////////////////////
/*
pin : pin number for the OneWire communication
b : value to be written to the bus, only LSb of the byte is considered
*/
void write_bit_one_wire(unsigned char pin, unsigned char b)
{
    //Insert your code here
 
 
}
////////////////////////////////////////////////////////////////////////////
/*
pin : pin number for the OneWire communication
returns 1 if read value is '1', 0 otherwise
*/
unsigned char read_bit_one_wire(unsigned char pin)
{
    unsigned char r;
    //Insert your code here
 
    return( r);
}
////////////////////////////////////////////////////////////////////////////
/*
pin : pin number for the OneWire communication
B : the byte to be written to the bus
*/
void write_byte_one_wire(unsigned char pin, unsigned char B) {
    //do the write
    //Insert your code here
 
    setPinInput1(pin);  //set the bus to idle state
}
////////////////////////////////////////////////////////////////////////////
/*
pin : pin number for the OneWire communication
buf : pointer to an array that contain the bytes to send
count: number of bytes to send
*/
void write_bytes_on_wire(unsigned char pin, const unsigned char * buf, unsigned int count) {
    for (uint16_t i = 0 ; i < count ; i++)
        write_byte_one_wire(pin, buf[i]);
    setPinInput1(pin);
}
////////////////////////////////////////////////////////////////////////////
/*
pin : pin number for the OneWire communication
return the byte read from the bus
*/
unsigned char read_byte_one_wire(unsigned char pin) {
    unsigned char val=0;
    //Insert your code here
 
    return (val);
}
////////////////////////////////////////////////////////////////////////////
/*
pin : pin number for the OneWire communication
buf : pointer to an array to store the bytes
count: number of bytes to read
*/
void read_bytes_one_wire(unsigned char pin, unsigned char * buf, unsigned int count) {
    for (uint16_t i = 0 ; i < count ; i++)
        buf[i] = read_byte_one_wire(pin);
}
////////////////////////////////////////////////////////////////////////////
/*
pin : pin number for the OneWire communication
rom : an array of 8 byte containning the rom code of the selected peripheral
*/
void select_one_wire(unsigned char pin, const unsigned char * rom)
{
    //Insert your code here
 
}
////////////////////////////////////////////////////////////////////////////
/*
pin : pin number for the OneWire communication
rom : an array of 8 byte (minimum) to which the function stores the rom code
*/
void read_rom_one_wire(unsigned char pin, unsigned char * rom ){
    //read the rom code from the device
    //Insert your code here
 
 
    //display the rom code in the console
    Serial.print("ROM Value: ");
    for(int i = 0; i < 8 ; i ++){
        Serial.print(rom[i]>>4, HEX);
        Serial.print(rom[i]&0xf, HEX);
        if (i!=7) Serial.print(":");
        else Serial.println("");
    }
}
////////////////////////////////////////////////////////////////////////////
/*
pin : pin number for the OneWire communication
*/
void skip_one_wire(unsigned char pin)
{
    //Insert your code here
}
////////////////////////////////////////////////////////////////////////////
/*
data : pointer to the array of bytes read from the device
return the temperature in degree Celsius
*/
float convert_temp(unsigned char * data){
    unsigned int raw = (data[1] << 8) | data[0];
    float celsius = 0.0 ;
    byte cfg = (data[4] & 0x60);
    // at lower res, the low bits are undefined, so let's zero them
    if (cfg == 0x00) raw = raw & ~7;  // 9 bit resolution, 93.75 ms
    else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
    else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
    //// default is 12 bit resolution, 750 ms conversion time
    celsius = (float)raw / 16.0;
    return celsius ;
}
////////////////////////////////////////////////////////////////////////////
/*
pin : pin number for the OneWire communication
rom : an array of 8 byte (minimum) to which the function stores the rom code
*/
float read_scratchpad_and_get_temperature(unsigned char pin, unsigned char * rom  ){
    unsigned char scratchpad[9];
    float celsius;
 
    //Insert your code here
 
 
    //display the Scratchpad in the console
    Serial.print("Scratchpad Value: ");
    for(int i = 0; i < 9 ; i ++){
        Serial.print(scratchpad[i]>>4, HEX);
        Serial.print(scratchpad[i]&0xf, HEX);
        if (i!=8) Serial.print(":");
        else Serial.println("");
    }
 
    celsius = convert_temp(scratchpad);
    Serial.print("  Temperature = ");
    Serial.print(celsius);
    Serial.println(" Celsius");
    return celsius;
}
////////////////////////////////////////////////////////////////////////////
void setup(void) {
    Serial.begin(9600); // for debug purpose
    pinMode(PIN_DS, INPUT); //set the pin as input using the Arduino HAL
}
////////////////////////////////////////////////////////////////////////////
void loop(void) {
 
}

En vous aidant des macros du code fourni, implémenter les fonctions bas niveau :

static void setPinOutPut0(unsigned char x);
static void setPinInput1(unsigned char x);
static unsigned char getPinInput(unsigned char x);

Les chronogrammes suivants sont fournis pour vous aider à écrire les fonctions correspondantes:

Reset OneWire, l'esclave peut répondre en imposant un 0 sur le bus :

Write bit '1' Onewire :

Write bit '0' Onewire :

Read bit OneWire, l'esclave envoie un '1' en laissant le bus à l'état récessif au moment où le maître lit :

Read bit OneWire, l'esclave envoie un '0' en positionnant le bus à l'état dominant au moment où le maître lit :

En vous aidant du code fourni pour la fonction unsigned char reset_one_wire(unsigned char pin), implémenter les fonctions bas niveau qui permettent de lire et d'écrire des bits sur le bus:

void write_bit_one_wire(unsigned char pin, unsigned char val);
unsigned char read_bit_one_wire(unsigned char pin);

Tester vos fonctions avec un programme principal qui éxecute en boucle:

1. réinitialiser le bus OneWire
2. Si un composant a répondu au reset sur le bus:
   1. écrire deux bits à 1 sur le bus
   2. écrire un bit à 0
   3. lire 3 bits
3. attendre 100ms

Vérifier à l'oscilloscope les signaux générés, le module DS18B20 étant successivement branché et débranché. Interpréter les résultats.

En utilisant les fonctions précédentes, définir les fonctions de communication:

unsigned char read_byte_one_wire(unsigned char pin);
void write_byte_one_wire(unsigned char pin, unsigned char B);

Ces fonctions effectuent l'envoi et la réception d'une donnée 8-bit en partant du bit de poids faible (Lsb First).

Une fois les fonctions de base mises en place, nous allons pouvoir communiquer avec le composant DS18B20. Les composants sur le bus OneWire sont identifiés par un ROM-code de 64-bit unique utilisé en tant qu'adresse MAC (deux DS18B20 ont des ROM-codes différents). Ce ROM-code doit être spécifié pour la plupart des transactions sur le bus.

Dans le cas d'un bus à plusieurs périphériques, il est nécessaire d'effectuer une recherche de tous les ROM-codes présents sur le bus si ils ne sont pas connus à priori. Une recherche exhaustive prendrait trop de temps, et un algorithme dichotomique de recherche à travers un arbre binaire est mis en place tel que décrit dans : http://www.maximintegrated.com/en/app-notes/index.mvp/id/187

Dans le cas d'un composant unique; il est possible de lire ce ROM-code à l'aide de la commande read_rom. C'est ce que nous ferons dans ce TP. A partir de la datasheet du DS18B20, compléter la fonction suivante:

void read_rom_one_wire(unsigned char pin, unsigned char * rom );

Cette fonction doit:

1. Envoyer le code commande 0x33 sur le bus OneWire
2. Lire les 8 octets du ROM-code et les stocker dans un tableau de 8 octets rom. Vous pourrez utiliser la fonction void read_bytes_one_wire(unsigned char pin, unsigned char * buf, unsigned int count); fournie.
3. Afficher le ROM-code sur la console (fourni)

Modifier la fonction loop pour:

1. réinitialiser le bus OneWire
2. appeler la fonction void read_rom_one_wire(unsigned char pin, unsigned char * rom );

Relever la valeur du premier octet affiché (dont vous devrez déterminer le rôle à l'aide de la documentation) et la comparer avec celles des autres étudiants.

Une fois ce code validé, implémentez la fonction suivante qui permet la sélection du composant sur le bus (lire la documentation pour déterminer ce que doit faire la fonction, vous pourrez utiliser la fonction void write_bytes_on_wire(unsigned char pin, unsigned char * buf, unsigned int count); fournie.):

void select_one_wire(unsigned char pin, const unsigned char * rom);

Compléter la fonction suivante permettant de lire la sonde de température DS18B20 et d'afficher la température toutes les 2 secondes:

float read_scratchpad_and_get_temperature(unsigned char pin, unsigned char * rom  );

Cette fonction doit:

1. Réinitialiser le bus OneWire
2. Sélectionner le composant grâce à son adresse MAC.
3. Demander une conversion de la température (déterminer le code commande d'après la documentation).
4. Attendre le temps nécessaire à la conversion.
5. Récupérer le contenu de la mémoire Scratchpad vers le tableau correspondant (déterminer le code commande d'après la documentation).
6. Afficher le contenu du tableau Scratchpad (fourni).
7. Convertir les valeurs lues en une température en degrés Celsius et l'afficher (fourni).
8. retourner la valeur de température (fourni).

Compléter la fonction loop pour faire la mesure de température.

Nous souhaitons maintenant vérifier les données lues sur le bus (le ROM-code et le contenu de scratchpad). Pour cela le code de vérification de CRC suivant est fourni:

crc.ino

static const unsigned char PROGMEM dscrc_table[] = {
      0, 94,188,226, 97, 63,221,131,194,156,126, 32,163,253, 31, 65,
    157,195, 33,127,252,162, 64, 30, 95,  1,227,189, 62, 96,130,220,
     35,125,159,193, 66, 28,254,160,225,191, 93,  3,128,222, 60, 98,
    190,224,  2, 92,223,129, 99, 61,124, 34,192,158, 29, 67,161,255,
     70, 24,250,164, 39,121,155,197,132,218, 56,102,229,187, 89,  7,
    219,133,103, 57,186,228,  6, 88, 25, 71,165,251,120, 38,196,154,
    101, 59,217,135,  4, 90,184,230,167,249, 27, 69,198,152,122, 36,
    248,166, 68, 26,153,199, 37,123, 58,100,134,216, 91,  5,231,185,
    140,210, 48,110,237,179, 81, 15, 78, 16,242,172, 47,113,147,205,
     17, 79,173,243,112, 46,204,146,211,141,111, 49,178,236, 14, 80,
    175,241, 19, 77,206,144,114, 44,109, 51,209,143, 12, 82,176,238,
     50,108,142,208, 83, 13,239,177,240,174, 76, 18,145,207, 45,115,
    202,148,118, 40,171,245, 23, 73,  8, 86,180,234,105, 55,213,139,
     87,  9,235,181, 54,104,138,212,149,203, 41,119,244,170, 72, 22,
    233,183, 85, 11,136,214, 52,106, 43,117,151,201, 74, 20,246,168,
    116, 42,200,150, 21, 75,169,247,182,232, 10, 84,215,137,107, 53};
////////////////////////////////////////////////////////////////////////////
/*
addr : pointer to the array containing the bytes to check
len : number of bytes to process in the array
returns : 0 if there is no error, other value otherwise
*/
unsigned char crc8_one_wire(const unsigned char * addr, unsigned char len)
{
        unsigned char crc = 0;
        while (len--) {
                crc = pgm_read_byte(dscrc_table + (crc ^ *addr++));
        }
        return crc;
}

Compléter votre programme pour vérifier les données lues. L'affichage de la valeur retournée par la fonction unsigned char crc8_one_wire(const unsigned char * addr, unsigned char len) doit être 0 si les données sont correctes. Modifier les données pour détecter des erreurs, par exemple en faisant:

erreur.ino

rom[3]+=5;
Serial.println(crc8_one_wire(rom,8));
scratchpad[2]-=3;
Serial.println(crc8_one_wire(scratchpad,9));

Le bus OneWire supporte le mécanisme de diffusion (Broadcast). Nous allons l'utiliser avec un unique capteur sur le bus pour se passer de la phase d'adressage. Pour cela vous implémenterez la fonction suivante qui envoie la commande skip rom (déterminer le code commande d'après la documentation).:

void skip_one_wire(unsigned char pin);

Ensuite, vous copierez le code de float read_scratchpad_and_get_temperature(unsigned char pin, unsigned char * rom ) vers une nouvelle fonction float read_scratchpad_and_get_temperature_broadcast(unsigned char pin) en remplaçant les appels de select_one_wire(PIN_DS, rom); par skip_one_wire(PIN_DS); et vérifierez que la lecture de température est toujours possible.

Vous pouvez connecter plusieurs capteurs sur le même bus. Les adresses MAC (ROM-codes) sont indiquées sur les capteurs donc il n'y a pas besoin de faire l'énumération par recherche des adresses. Reportez ces ROM-code dans des variables globales telles que:

unsigned char romSensor[8]={0,0,0,0,0,0,0,0} ; //global variable: array to store the ROM-Code of one sensor (its MAC Address)

Adapter le programme pour permettre la lecture sur les différents capteurs. Les lectures de Scratchpad devront utiliser l'adressage MAC en appelant la fonction float read_scratchpad_and_get_temperature(unsigned char pin, unsigned char * rom )**. Eventuellement, la demande de conversion pourra être envoyée en diffusion.

Vous pouvez connecter plusieurs capteurs sur des bus différents en utilisant des broches différentes. Toutes les fonctions ayant été codées avec le numéro de la broche en paramètre, il suffit d'appeler les fonctions plusieurs fois avec des numéros de broches différents. S'il y a un unique capteur par bus, il est possible d'utiliser la diffusion.

Vous ferez attention à ce que chaque bus OneWire dispose de sa propre résistance de tirage à l'état haut, cette dernière n'étant pas installée ni sur la sonde ni sur le module RTC.