Un capteur de température sans fil à base de Xbee (partie 1)

EDIT (30/01/2016): Le régulateur de tension (LD1117V33C) proposé initialement dans cet article fonctionne parfaitement mais possède une consommation interne trop importante, ce qui m’a causé une surconsommation des piles et une tenue d’à peine 3 semaines. Je l’ai donc avantageusement remplacé par un LP2950CZ-3.3, qui délivre 100mA maximum, ce qui s’avère bien suffisant pour ce petit montage. La consommation des piles semblent correct et je pense avoir une durée de vie de plusieurs mois. Attention à vérifier l’ordre de broches (Vin, Vout, GND) car il diffère du LD1117.

Salut,

Attention article fleuve :). Je vous propose de voir comment réaliser une lecture de température à distance, c’est à dire transmettre par ondes radios la sortie d’un capteur de température et récupérer le résultat sur un Raspberry Pi (RPi).

Pour ce faire, nous allons utiliser des modules XBee et cet article est donc mon premier à introduire à la programmation et à l’utilisation de ces modules radio fréquences, c’est pourquoi je m’attarderai un peu plus sur les détails de mise en œuvre initiale.

Les modules XBee


Les XBee sont des petits modules électroniques permettant la création d’un réseau de communication par ondes radios, basé sur un protocole spécifique appelé ZigBee (pour les modules à partir de la version 2). Ces modules sont déclinés en deux gammes, une standard et une professionnelle, qui diffèrent essentiellement dans la portée du signal et dans la consommation d’énergie.

Les modules standard qui nous intéressent ont une portée théorique de 30m en intérieur (avec obstacles donc) et de 100m en extérieur (sans obstacle) et ils sont proposés avec plusieurs variantes d’antennes, plus ou moins encombrantes, mais également plus ou moins performante en terme de portée. Pour une petite installation domestique, j’ai choisi les moins encombrants avec une antenne minuscule intégrée au module (cf photo ci-dessus).

Une caractéristique intéressante de ces modules est qu’ils disposent de plusieurs entrées/sorties analogiques et numériques configurables, avec plusieurs options. On le verra dans cet article, ces modules sont programmables de manière assez fine pour réaliser différentes fonctions.

Autres points intéressants: la communauté est assez active autour de ces modules, la littérature et les exemples nombreux sur le net, et on trouve le protocole ZigBee dans des applications ou des équipements de domotique professionnelle, ce qui veut dire qu’on peut potentiellement utiliser ces modules pour interagir avec des capteurs ou des actionneurs achetés par ailleurs.

Il y aurait énormément à dire sur le détail de fonctionnement et les possibilités des XBee en particulier sur le plan de la typologie de réseau (maillé) avec le rôle de chaque module dans cette typologie, comment sont adressés les différents modules, comment peuvent être relayées les trames, etc… Pour l’instant, on va se contenter de noter que les XBee peuvent fonctionner selon deux modes:

  • Mode AT (Transparent) : mode par défaut, essentiellement utilisé pour de la communication en point à point. Aucune information détaillée n’est nécessaire pour la construction des trames. On s’en sert essentiellement pour de la communication série.
  • Mode API (Application Programing Interface) : permet de contrôler plus finement l’adressage des modules aussi bien en réception qu’en émission de trame, permet également d’entrer dans le détail des trames reçues.

Pour chaque mode et pour chaque rôle (coordinateur, routeur, endpoint) correspond un firmware différent à installer sur chaque module. Rassurez-vous, dans le cas d’une petite installation domestique, la mise en œuvre est en réalité extrêmement simple.

Principe du dispositif capteur/transmetteur


L’objectif de notre montage est de créer un capteur de température sans fil. On va donc choisir un capteur de température avec sortie analogique, que l’on va connecter à une entrée de conversion analogique/numérique (ADC) d’un module XBee. Celui-ci va régulièrement lire la valeur sur son entrée ADC et l’envoyer à un autre XBee connecté à un RPi.

Le schéma électronique de principe pour la réalisation du capteur/transmetteur de température est simple, je me suis même fendu d’un petit schéma avec le logiciel Fritzing:

La source d’énergie est composée de 4 piles AA en série (soit 6Volts), que l’on passe dans un régulateur de tension pour abaisser la tension à 3.3Volts puisque c’est la tension d’alimentation des XBee. Un petit condensateur pour lisser et filtrer la tension lors des micro pics de consommation (la valeur vient des recommandations du constructeurs du régulateur de tension). Pour finir, le capteur de température est alimenté de la même manière et sa sortie analogique est connectée à l’entrée ADC3 (pin 17) du XBee.

Liste des composants


Voici la liste des composants que j’ai choisis pour ce montage. D’autres composants peuvent aussi faire l’affaire. Si vous changez le capteur de température, il faudra juste penser à vérifier la tension d’alimentation, la tension de sortie (1.2Volts maximum en entrée des ADC du XBee), la consommation, l’intervalle de température de fonctionnement, etc. Bref, si vous ne voulez pas vous compliquer la vie, commandez les mêmes composants que moi et ça marchera :

  • Un boitier coupleur pour 4 piles AA (ref: BH341BS)
  • Deux modules XBee série 2 (ref: XB24-Z7PIT-004)
  • Une platine de conversion pour XBee (ref: PL/XBEE) qui permet d’adapter l’espacement des broches de 2mm du XBee, qui n’est pas standard, et le ramener à un pas standard de 2,54mm pour les platines de prototypage. Cette platine va également nous permettre, à terme, de la souder sur un circuit tout en pouvant enlever le module XBee pour le reprogrammer par exemple (voir photo).
  • Un jeu de 2 connecteurs femelle au pas de 2mm pour la platine de conversion (voir photo)
  • Un jeu de 2 connecteurs mâle au pas de 2,54mm pour la platine de conversion (voir photo)
  • Un dongle USB « XBee explorer » (ref: WRL-11697). Ce dongle permet de programmer les modules XBee depuis un ordinateur avec le logiciel idoine, puis, il permettra de relier un module XBee à notre RPi.
  • Un régulateur de tension 3.3V (ref: LD1117V33C)
  • Un condensateur 10uF 16V (ref: ECA1CAD100X)
  • Un capteur de température TMP36 en packaging TO-92 (ref: TMP36GT9Z)

Configuration des modules XBee


Pour programmer les XBee, il nous faut:

  • Un dongle USB « XBee explorer »
  • Le logiciel gratuit XCTU, fourni par le fabriquant des XBee (digi.com), existe pour Mac ou PC
  • La documentation technique des XBee (sur le site de digi.com)

Je vous laisse suivre la documentation de digi.com pour l’installation du logiciel XCTU, il n’y a pas grand chose à faire, c’est assez basique. Il faut ensuite insérer le module XBee sur le dongle USB « XBee explorer », puis brancher le dongle USB sur un port USB de votre ordinateur.

Je n’expliquerai pas dans cet article comment utiliser le logiciel XCTU, d’abord parce que c’est assez simple, et ensuite parce que la documentation (y compris une vidéo) du digi.com est bien faite. Une fois notre Xbee détecté par le logiciel, l’ensemble de la configuration courante du XBee est affichée, et il est possible de changer les valeurs. C’est ce que nous allons faire.

Nous avons deux XBee à configurer:

  1. Un fera office de coordinateur en mode API, puisque dans tout réseau ZigBee il faut un coordinateur. C’est ce XBee qui recevra les trames de l’autre XBee relié au capteur de température. Le coordinateur sera tout le temps « en marche » et en écoute. C’est également celui-là qui sera connecté sur notre RPi.
  2. L’autre module, celui relié au capteur de température, sera configuré comme routeur en mode AT. Pour faire des économies d’énergie et rallonger la durée de vie des piles, on configurera ce module selon le cycle suivant: a) lire la valeur sur une de ses entrées ADC b) transmettre cette valeur au coordinateur c) dormir 5 minutes d) se réveiller et recommencer son cycle. On aura ainsi une lecture de température toutes les 5 minutes (largement suffisant compte tenu de l’inertie de la température dans une maison, ou même en extérieur) tout en économisant les piles puisque la consommation du XBee en mode sommeil est extrêmement faible.

Voyons maintenant les paramètres à configurer sur nos deux modules XBee. Les valeurs des paramètres sont toujours spécifiées en hexadécimal.

Configuration du module 1 : le coordinateur

  • Firmware à installer: « Coordinator – API mode ».
  • PAN ID = 2001, il s’agit de l’identifiant de notre réseau, valeur arbitraire mais doit être la même sur tout les XBee participants à ce réseau.
  • Configuration de la période de sommeil – c’est une subtilité dont la résolution m’a pris du temps (source : le blog de guiduc). En effet, le coordinateur ne dort jamais, mais si un des modules XBee du réseau est configuré pour dormir (c’est notre cas), alors il faut configurer les paramètres suivants du coordinateur, de sorte que le temps résultant soit supérieur au temps de sommeil du module dormant afin que le coordinateur ne l’oublie pas, et que le module dormant n’ait pas à recommencer une procédure d’initialisation sur le réseau qu’il n’aurait pas le temps de faire pendant les quelques millisecondes de son temps de réveil :
    • SP = 3E8 (Sleep Period), il s’agit de la période de sommeil, en unité de 10ms, qui sera ensuite multipliée par le paramètre SN afin d’obtenir la durée de sommeil finale. 0x3E8 = 1000 en décimal. 1000 x 10ms = 10 secondes.
    • SN = 20 (SP Multiplier), facteur multiplicateur du paramètre SP pour déterminer la durée total du sommeil du module XBee. Ici, 0x20 = 32, donc 32x10s = 320 secondes ce qui est bien supérieur au 5 minutes de sommeil que nous définirons pour l’autre module XBee.
  • Tous les autres paramètres sont laissés à leur valeur par défaut.

Configuration module 2 : le routeur

  • Firmware à installer: « Router – AT mode ».
  • PAN ID = 2001, même identifiant de réseau que notre coordinateur.
  • JV = 1 (Join Verification), vérification au démarrage que le réseau a bien pu être joint et que le coordinateur est bien présent sur le réseau.
  • DH = 0 (Destination High), octet de poids fort de l’adresse de destination des trames. Lorsque l’adresse de destination est 0, alors les trames sont envoyées au coordinateur par défaut.
  • DL = 0 (Destination Low), octets de poids faible de l’adresse de destination des trames. Lorsque l’adresse de destination est 0, alors les trames sont envoyées au coordinateur par défaut.
  • Configuration du sommeil :
    • SM = 5 (Sleep Mode), mode de veille. La valeur 5 correspond à un réveil cyclique avec possibilité de réveiller le module en plein sommeil par l’application d’un niveau logique sur son pin ‘Pin Wake’ (permet de réveiller le module, pour le programmer par exemple, sans avoir à attendre la fin de son cycle de sommeil).
    • SP = 3E8 (Sleep Period), il s’agit de la période de sommeil, en unité de 10ms, qui sera ensuite multipliée par le paramètre SN afin d’obtenir la durée de sommeil finale. 0x3E8 = 1000 en décimal. 1000 x 10ms = 10 secondes.
    • SN = 1E (SP Multiplier), facteur multiplicateur du paramètre SP pour déterminer la durée du sommeil du module XBee. Ici, 0x1E = 30, donc 30x10s = 300 secondes = 5 minutes.
    • ST = 1F4 (Time before sleep), temps de réveil, en millisecondes, du module Xbee, c’est à dire pendant combien de temps doit se réveiller pour faire ce qu’il a à faire. 0x1F4 = 500 Le module restera donc réveillé 500ms avant de se rendormir pour 5 minutes.
  • V+ = FFFF (Supply voltage information), indique au XBee que l’on souhaite recevoir, dans chaque trame qu’il envoie, une information sur la valeur courante de la tension d’alimentation. Cela nous permettra de savoir, et d’agir, lorsque la tension commencera à faiblir (indication de changer les piles).
  • Configuration des entrées sorties (IOSettings) :
    • D3  = 2, indique que l’on souhaite utiliser le pin ‘AD3/DIO3’ comme convertisseur analogique numérique
    • IR = 1388 (IO sampling Rate), indique en millisecondes, la période d’échantillonnage de ses entrées IO (analogique ou numérique). Ici, 0x1388 = 5000, donc 5000ms = 5s. En clair, on demande au XBee d’envoyer une lecture de ses IO toute les 5 secondes, MAIS comme il ne reste réveillé que 500ms puis dort pendant 5 minutes, il n’a le temps d’envoyer qu’un seul échantillon pendant son temps de réveil. C’est une astuce pour obtenir un seul échantillon par cycle de réveil/sommeil.
  • Tous les autres paramètres sont laissés à leur valeur par défaut.

Prototypage


Les deux modules XBee sont maintenant programmés, il nous reste à tester le prototype.

Avant d’assembler les composants électroniques sur une plaque de prototypage (breadboard), il y a un peu de soudure à faire pour assembler les différents connecteurs à la platine XBee. Pour partager mon expérience, j’ai du m’y reprendre à deux fois pour souder les connecteurs femelles (au pas de 2mm) sur la platine car sur mon premier essai, l’étain était remonté dans le connecteur et m’empêchait d’y insérer le module XBee. Attention donc à ne pas mettre trop d’étain. Le résultat final attendu est le suivant :

Pour continuer, il nous reste à enficher l’ensemble des composants électronique en respectant le schéma électrique montré au début de cet article. Attention: sur ce montage, mettez bien le module XBee numéro 2 (celui configuré en routeur mode AT). Pour le reste, rien de compliqué, quelques fils pour relier les différentes pattes des composants et voilà le résultat :

Dans un premier temps on va vérifier, avec le logiciel XCTU, que le montage envoie bien les trames et qu’on les reçoit bien grâce à notre module XBee numéro 1 (le coordinateur):

  1. Connectez le dongle USB « XBee explorer », avec le module 1 enfiché dessus, à votre ordinateur.
  2. Lancez le logiciel XCTU, détectez le module et activez la console qui permet de voir en direct les trames reçues.
  3. Alimentez le dispositif électronique sur la plaque de prototypage (bouton on/off du coupleur de pile, ou simplement en connectant l’alimentation)
  4. Après quelques secondes (environ 9 secondes chez moi) nécessaires à l’initialisation du XBee et qu’il rejoigne le réseau ZigBee, vous devriez voir arriver les premières trames contenant deux échantillons analogiques : 1/ la valeur numérique lue sur le pin ADC3, 2/ la valeur de la tension d’alimentation du XBee :

Comme on peut le voir, la réception des trames est espacée (d’environ) 5 minutes. Chaque trame contient un champs appelé « Analog sample » contenant deux échantillons de 2 octets chacun (octets de poids faible et de poids fort). Les deux premiers octets correspondent à la lecture de l’entrée ADC3, c’est à dire une conversion numérique de la tension de sortie du capteur de température, et les deux derniers octets correspondent à la valeur de la tension d’alimentation actuelle du XBee, ce qui permet de surveiller la fatigue des piles.

Tout fonctionne bien, il nous reste à créer le bout de code qui pourra récupérer ces trames, en extraire les informations utiles et les convertir en quelque chose de lisible pour les humains que nous sommes.

Le logiciel


Le code que l’on va écrire doit pouvoir tourner sur un Raspberry Pi sans pour autant consommer tout les cycles CPU dans l’attente qu’une trame ZigBee arrive. Dans la communauté XBee et Raspberry Pi on trouve beaucoup d’adeptes du langage Python. En conséquence, les exemples de code et les bibliothèques pour XBee que l’on trouve le plus pour s’interfacer sont en langage Python.

Cependant, les exemples de code Python que j’ai trouvé utilisent tous une boucle sans fin dans l’attente de l’arrivée du trame sur le port série ce qui, non seulement ne me semble pas efficace, mais en plus d’aucuns ont remonté des problèmes de performances ou de consommation CPU pour simplement attendre l’arrivée d’une trame. N’ayant pas testé moi même je ne peux pas confirmer ou infirmer.

En revanche, je me suis récemment intéressé, pour divers mini projets, à une plateforme de développement qui me semble tout à fait appropriée pour ce que l’on a à faire:  NodeJS. Le langage utilisé est javascript et c’est une plateforme :

  • Orientée évènement (event oriented)
  • Sans blocage des entrées sorties (non-blocking IO)

Deux propriétés parfaitement adaptées à notre besoin. En outre, je connais déjà NodeJS donc c’est parti ! 🙂

1/ Installation de NodeJS sur RPi

Il y a un site qui maintient des versions de NodeJS pour processeur ARM (celui du RPi). L’installation se fait en deux lignes de commandes :

pi@domopi ~ $ wget http://node-arm.herokuapp.com/node_latest_armhf.deb
pi@domopi ~ $ sudo dpkg -i node_latest_armhf.deb
pi@domopi ~ $ node -v
v0.12.1

Au passage, ça nous installe aussi le gestionnaire de paquet pour NodeJS qui répond au doux nom de npm (Node Package Manager). On va ensuite utiliser npm pour installer deux dépendances à notre programme : le paquet « serialport » et le paquet « xbee ». A nouveau, l’installation se fait en deux lignes de commandes, par contre soyez patient pour l’installation du paquet « serialport » , il y a un peu de compilation qui se fait en arrière plan :

pi@domopi ~ $ npm install serialport
pi@domopi ~ $ npm install xbee

 2/ Connexion du « XBee explorer » sur le RPi

Connectez le dongle USB « XBee explorer » avec le module XBee numéro 1 (le coordinateur) enfiché dessus, sur un port USB de votre RPi. Une fois fait, votre RPi va le détecter, charger les pilotes nécessaires et vous présenter un nouveau device série dans l’arborescence /dev. Pour vérifier tout cela, un commande est suffisante :

pi@domopi ~ $ dmesg
[255109.332836] usb 1-1.2.1: new full-speed USB device number 8 using dwc_otg
[255109.460356] usb 1-1.2.1: New USB device found, idVendor=0403, idProduct=6015
[255109.460394] usb 1-1.2.1: New USB device strings: Mfr=1, Product=2, SerialNumber=3
[255109.460409] usb 1-1.2.1: Product: FT231X USB UART
[255109.460423] usb 1-1.2.1: Manufacturer: FTDI
[255109.460436] usb 1-1.2.1: SerialNumber: DA01ACDA
[255109.475072] ftdi_sio 1-1.2.1:1.0: FTDI USB Serial Device converter detected
[255109.475275] usb 1-1.2.1: Detected FT-X
[255109.475299] usb 1-1.2.1: Number of endpoints 2
[255109.475316] usb 1-1.2.1: Endpoint 1 MaxPacketSize 64
[255109.475331] usb 1-1.2.1: Endpoint 2 MaxPacketSize 64
[255109.475345] usb 1-1.2.1: Setting MaxPacketSize 64
[255109.476555] usb 1-1.2.1: FTDI USB Serial Device converter now attached to ttyUSB3

Prenez note du nom de device donné par le RPi : ttyUSB3. Notre XBee est donc accessible via le chemin de fichier « /dev/ttyUSB3« .

3/ Le calcul de la température

On l’a vu, dans une trame on reçoit une valeur numérique (en hexadécimal) correspondant à une conversion numérique de la valeur de la tension de sortie du capteur de température. Il y aura donc deux petites opérations mathématiques à effectuer dans notre code pour retrouver la température correspondante :

  1. A partir de la valeur numérique reçue dans la trame, calculer la tension correspondante, en mV, de la sortie du capteur de température.
  2. A partir de la valeur de tension en mV, calculer la température en °C correspondante.

Les ports de conversion analogique/numérique (ADC) des XBee échantillonnent une plage de tension maximale de 1200mV et ce sur 10 bits. Dit autrement, cela signifie que pour la valeur minimale de 0mV en entrée, le XBee donnera une valeur numérique de 0 (balaise), et pour une valeur maximale de 1200mV, le XBee donnera une valeur numérique de 1023 (10 bits à 1 en notation binaire =  1023 en notation décimale). Il ne reste plus qu’à faire une règle de trois sur la valeur reçue dans la trame pour retrouver la tension correspondante en mV. Comme la valeur reçue est codée sur deux octets, un de poids fort et un de poids faible, la formule finale est la suivante :

tension en mV = ((octets de poids fort)*256 + octet de poids faible)*1200 / 1023

A partir de cette tension en mV, il suffit de se reporter à la datasheet du capteur de température de notre choix, en l’occurrence le TMP36, pour voir la formule permettant de trouver la correspondance, il s’agit simplement de :

température en °C = (tension en mV – 500) / 10

On retrouvera donc ces deux calculs hautement savants en une seule ligne dans le code que je vous propose.

4/ Le code

Nous y voilà ! Dans le code proposé, comme d’habitude écrit et commenté en anglais, il y a quelques valeurs de variable à modifier au tout début :

  1. La variable ‘xbeeExplorerDevice‘ : spécifiez ici le chemin du device sur lequel votre XBee explorer est détecté. On a vu précédemment comment le trouver. Sur mon RPi c’est /dev/ttyUSB3, mais ça sera probablement différent chez vous.
  2. La variable ‘temperatureSensorAddress‘ : indiquez ici l’adresse 64bits de votre module XBee numéro 2 (celui avec le capteur de température). Pour la trouver, il suffit de la lire avec le logiciel XCTU par exemple.
  3. La variable ‘temperatureFilePath‘ : spécifiez le chemin du fichier dans lequel on enregistrera, de façon horodatée, les valeurs de température et de voltage de la tension d’alimentation reçue.

Voici le code, qu’on sauvegardera à titre d’exemple dans un fichier nommé xbee-receiver.js :

/**
* xbee-receiver - for NodeJS
*
* @author Arno0x0x - https://twitter.com/Arno0x0x
* @license GPLv3 - licence available here: http://www.gnu.org/copyleft/gpl.html
*
* Description :
* This script treats the ZigBee frames received from various remote XBee's.
* It works with XBee Serie 2 talking ZigBee protocol.
*
* A XBee set as coordinator must be connected to the computer.
* The easiest way is to use an XBee explorer (USB). The XBee is then seen as a serial device.
*
* The script relies on two external NPM modules ('xbee' and 'serialport') to interact with this serial device and
* to be able to receive and parse incoming frames.
*
* Once parsed with the xbee nodejs module, the whole frame is available as an object with
* the following format (values are just example) :
*	remote64:
*	   { dec: [ 0, 19, 162, 0, 64, 191, 87, 78 ],
*    	 hex: '0013a20040bf574e' },
*  		remote16: { dec: [ 93, 138 ], hex: '5d8a' },
*		receiveOptions: 65,
*		numSamples: 1,
*		digitalChannelMask: [ 0, 0 ],
*		analogChannelMask: 136,
*		bytes: [ 146, 0, 19, 162, 0, 64, 191, 87, 78, 93, 138, 65, 1, 0, 0, 136, 1, 215, 9, 192 ],
*		analogSamples: [ 1, 215, 9, 192 ],
* 		samples: { A3: 471, supply: 2496 } }
*/

//======================================================================
// Importing required external modules
//======================================================================
var rsp = require('serialport');
var xbee = require('xbee');
var fs = require('fs');

var SerialPort = rsp.SerialPort; // localize object constructor

//======================================================================
// Define the serial device the xbee explorer is seen as on the system
//======================================================================
// var xbeeExplorerDevice = '/dev/tty.usbserial-DA01ACDA'; // On my Mac
var xbeeExplorerDevice = '/dev/ttyUSB3'; // On my RPi

//======================================================================
// Defining remote sensors addresses
// Set the 64bits address of each remote xbee we want to receive frames from
//======================================================================
var temperatureSensorAddress = '0013a20040bf574e';

// Set the path for the file we will write temperature sensor records to
var temperatureFilePath = 'tempRecords.csv';

//======================================================================
// Connect to xbee module on  using serialport.
// Pass xbee.packetParser as the parser - that's it
//======================================================================
var serial_xbee = new SerialPort(xbeeExplorerDevice, {
  parser: xbee.packetParser()
});

//======================================================================
// ----------------------------- MAIN LOOP -----------------------------
//======================================================================

// Add event listener for incoming data on the serial port
// That means an XBee frame has been received
serial_xbee.on('data', function(data) {

	//---------------------------------------------------
	// Receiving a frame from the temperature sensor xbee
	//---------------------------------------------------
	if (data.remote64.hex === temperatureSensorAddress) {

		// The analog sample is available on the first two bytes of the 'analogSamples' array
		// of the received frame. So its in data.analogSamples[0] and data.analogSamples[1]

		// To get the actual temperature, we first need to convert the analog to digital (ADC) sample
		// into its corresponding mV reading. Formula is: analog in mV = (digital_sample * 1200)/1023
		// Then we convert the mV reading into a temperature in Celsius degrees for a TMP36 sensor:
		// temperature = (mv -500) /10
		var temperature = ((((data.analogSamples[0]*256 + data.analogSamples[1])*1200/1023) - 500)/10).toFixed(2);

		// The frame also contains a sample corresponding to a reading of the current xbee power supply
		// Formula to get the actual voltage is the same as for any analog sample reading
		var voltage = ((data.samples.supply*1200/1023)/1000).toFixed(2);

		// Get the current date and time
		var now = new Date();

		// Write all values into the records file, in CSV format
		fs.appendFile(temperatureFilePath,now.toLocaleString()+';'+temperature+';'+voltage+'\n',function (error) {
			if (error) {
				console.log ('Error, could not write file %s',temperatureFilePath);
				throw err;
			}
		});
	} // End of temperature sensor frame
});

Le fichier de code est également disponible en téléchargement ici. Pour exécuter ce code, entrez simplement la commande suivante :

pi@domopi ~ $ node xbee-receiver.js

Après l’avoir laissé tourner plus de 5 minutes idéalement, histoire d’avoir au moins deux échantillons, on trouvera, dans le fichier que vous avez spécifié dans la variable ‘temperatureFilePath‘, les lignes suivantes :

Mon Jun 22 2015 20:18:55 GMT+0200 (CEST);21.67;3.18
Mon Jun 22 2015 20:24:03 GMT+0200 (CEST);21.79;3.18

Vous pouvez lire que le 22 juin, à 20h18, il faisait 21.67 °C et que la tension d’alimentation de mon XBee était de 3.18V.

Conclusion


Nous avons vu dans cet article une introduction aux XBee et à leur configuration sur une application concrète, la partie prototypage électronique et le code de réception et de traitement, avec au passage une très brève mention de NodeJS.

Dans une deuxième partie, je vous proposerai de voir, pour la partie électronique, comment passer du prototype sur breadboard à un boitier un peu mieux fini. Mais attention, aux ultras de l’électronique: je ne me casse pas la tête avec des circuits imprimés, je parle d’un produit un peu mieux fini et packagé. On verra également comment rendre l’exécution du code un peu plus « industrialisée » c’est à dire capable de tourner en tâche de fond comme un démon Unix et de se lancer automatiquement au démarrage du RPi. Pour finir, on verra comment intégrer tout ça dans notre interface domotique web sur le RPi frontal (rappel de mon environnement), comme on l’a vu dans un précédent article avec un capteur de température local ou encore sur l’exemple de page web vue dans l’article sur la commande des prises à distance.

Et puis, parti comme c’est parti, ça ne sera certainement pas mon dernier bricolage à base de XBee, j’ai encore plein de petites idées en prévision (commande de volet roulant électrique, capteur de mouvement, capteur de porte de garage, etc.).

A bientôt.

Vous aimez cet article ? Faites le savoir avec quelques bitcoins !

Publicités

4 réflexions sur “Un capteur de température sans fil à base de Xbee (partie 1)

  1. eclipseflorian 8 juin 2017 / 10 h 56 min

    Super tuto, c’est exactement ce dont j’avais besoin. Sinon pour les régulateurs, une bonne option serait de passer sur des régulateur de commutation comme le TSR 1-2433 de chez Traco Power.

    Le problème d’un régulateur linéaire, c’est que son intensité reste la même en entrée et en sortie. Du coup, cela crée une puissance plus élevée en entrée (comme la tension est plus élevée) que le régulateur devra libérer sous forme de chaleur.

    Alors qu’avec un régulateur de commutation, l’intensité va s’adapté selon l’appel de courant imposé par le système, ici le xbee.
    Du coup, la puissance reste la même, on réduit énormément les pertes et donc la consommation des piles.

    Kymaro

    J'aime

  2. Chiaberge 27 juin 2015 / 13 h 17 min

    Question : pourquoi 4 x 1,5v = 6V pour abaisser ensuite à 3,3v alors que tu pourrais prendre 3 x 1,5v = 4,5v pour abaisser ensuite à 3,3V pour obtenir le même résultat, à moins que tes 6V dispenseraient une tension de 3,3v plus longtemps…???

    J'aime

    • arno0x0x 28 juin 2015 / 16 h 26 min

      Bonjour,

      Un coupleur 3 piles serait tout à fait suffisant en terme de tension. Par contre le tout durera moins longtemps (maH) qu’avec 4 piles. Il se trouve que j’avais besoin pour un autre projet d’alimenter en 5v, donc j’avais pris plusieurs coupleurs 4 piles.

      J'aime

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s