Ceci est une ancienne révision du document !
Table des matières
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 fontions 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 One-Wire est un bus série asynchrone utilisant la largeur d'impulsion pour répré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 :
Squelette de l'application
- 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) { }
Mise en oeuvre des fonctions bas-niveau (bit)
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:
Read bit OneWire (esclave envoie un '1') :
Read bit OneWire (esclave envoie un '0') :
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:
unsigned char read_bit_one_wire(unsigned char pin); void write_bit_one_wire(unsigned char pin, unsigned char val);
Tester vos fonctions avec un programme principal qui éxecute en boucle:
- réinitialiser le bus OneWire
- écrire deux bits à 1 sur le bus
- écrire un bit à 0
- lire 3 bits
- 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.
Mise en oeuvre des fonctions d'envoi/réception de données 8 bits
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).
Mise en oeuvre des fonctions de contrôle du bus One-Wire
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 (deux DS18B20 ont un rom code 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 : 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. 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:
- Envoyer le code commande 0x33 sur le bus OneWire
- Lire les 8 octets du code ROM et les stocke 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.
- Afficher le code ROM sur la console (fourni)
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);
Lecture de la température
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:
- Réinitialiser le bus OneWire
- Sélectionner le composant grâce à son adresse MAC.
- Demander une conversion de la température (déterminer le code commande d'après la documentation).
- Attendre le temps nécessaire à la conversion.
- Récupérer le contenu de la mémoire Scratchpad vers le tableau correspondant (déterminer le code commande d'après la documentation).
- Afficher le contenu du tableau Scratchpad (fourni).
- Convertir les valeurs lues en une température en degrés Celsius et l'afficher (fourni).
- retourner la valeur de température (fourni).
Compléter la fonction loop pour faire la mesure de température.
Adressage sur le(s) bus
Diffusion
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.
Plusieurs esclaves sur le bus
Vous pouvez connecter plusieurs capteurs sur le même bus. Les adresses MAC (codes ROM) seront indiquées sur les capteurs. Reportez ces codes ROM 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. La demande de conversion pourra être envoyée en diffusion mais 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 )**.
Plusieurs bus
Vous pouvez connecter plusieurs capteurs sur des bus différents en utilisant des broches différentes. Toutes les fonction 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.