Communication RF 433 MHz entre ATTiny85 et Arduino

Je vous propose aujourd'hui un petit projet consistant à transmettre à une carte Arduino la mesure d'un capteur analogique branché à un ATTiny85, au moyen d'un signal radio de 433 MHz.  Si vous le désirez, vous pouvez utiliser les principes exposés dans ce billet pour mettre en place un réseau constitué de plusieurs capteurs satellites peu coûteux qui communiquent leurs données à un seul Arduino.

Si vous préférez, vous pouvez également utiliser les informations présentées ici pour créer une communication entre deux ATTiny85, ou entre deux cartes Arduino.

Matériel nécessaire pour faire cette activité: une paire émetteur/récepteur 433 MHz, une carte Arduino, un ATTiny85 (avec une alimentation et ce qu'il faut pour le programmer). et un potentiomètre qui tiendra lieu de capteur.

Installation de la bibliothèque Manchester

Le sketch que je vous propose pour l'émetteur et pour le récepteur nécessitent tous deux la bibliothèque Manchester, que vous devrez donc installer dans votre IDE Arduino.

Deux fichiers d'exemple sont fournis avec la bibliothèque: "ManchesterRX_Array-unfixed_length" et "ManchesterTX_Array-unfixed_length".  Ces deux sketches fonctionnent très bien (ils ont d'ailleurs servi de fondation aux sketches que je vous propose ci-dessous), mais pour obtenir de bons résultats, j'ai dû supprimer l'appel à la routine "man.workAround1MhzTinyCore()" dans le sketch de l'émetteur et diminuer la vitesse de la communication (2400 plutôt que 9600).

Sketch de l'émetteur (pour l'ATTiny85)

Voici le sketch destiné à l'ATTiny85.  Au besoin, vous pouvez vous référer à ce précédent billet qui explique comment programmer l'ATTiny avec l'IDE Arduino et une carte Arduino Uno.  Comme d'habitude, j'ai utilisé le noyau de David A. Mellis.

Le sketch est plutôt simple: une fois par seconde, l'ATTiny enverra, par l'entremise de l'émetteur RF, un message constitué de 4 octets: le premier octet contient la taille du message, et le deuxième octet contient le numéro de l'émetteur (qui n'a aucune utilité si votre carte Arduino ne reçoit des messages qu'en provenance d'un seul ATTiny, mais qui pourrait s'avérer essentiel pour distinguer plusieurs ATTiny émetteurs l'un de l'autre).

Les deux autres octets contiennent la lecture analogique que nous désirons transmettre.  Puisque le convertisseur analogique-numérique de l'ATTiny produit des valeurs à 10 bits, la lecture du potentiomètre doit être distribuée sur deux octets distincts, grâce aux fonctions highByte et lowByte (l'Arduino récepteur s'occupera de les fusionner lors de la réception).

	/**************************************************************
	Émetteur ATTiny85
	La valeur d'un potentiomètre branché à l'ATTiny est
	transmise par RF 433 MHz
	Instructions complètes:
	http://electroniqueamateur.blogspot.com/2018/02/communication-rf-433-mhz-entre-attiny85.html
	****************************************************************/
	#include <Manchester.h>
	#define NUMERO_EMETTEUR 8 // choisir un nombre entre 0 et 254, unique pour chaque émetteur du réseau
	#define TX_PIN 1 // broche reliée à l'émetteur 433 MHz
	#define POT_PIN A1 // broche reliée au potentiomètre dont nous désirons transmettre l'état
	#define LED_PIN 0 // broche reliée à la LED clignotante (facultative)
	uint8_t LedOn = 1; //statut de la LED clignotante facultative
	#define datalength 4 //nombre de bytes que contiendra le message (minimum 2)
	uint8_t data[datalength]; // matrice qui contiendra le message à envoyer
	void setup()
	{
	pinMode(LED_PIN, OUTPUT);
	digitalWrite(LED_PIN, LedOn);
	man.setupTransmit(TX_PIN, MAN_2400);
	}
	void loop()
	{
	int mesure = analogRead(POT_PIN); //on prend la valeur du potentiomètre
	data[0] = datalength; // nombre de bytes du message envoyé
	data[1] = NUMERO_EMETTEUR; // pour que le récepteur sache de qui provient le message
	data[2] = highByte(mesure); // la mesure du potentiomètre (10 bits) est répartie
	data[3] = lowByte(mesure); // sur deux bytes
	man.transmitArray(datalength, data);
	LedOn = !LedOn;
	digitalWrite(LED_PIN, LedOn);
	delay(1000);
	}

view raw Emetteur_ATTiny85.ino hosted with ❤ by GitHub

Sketch du récepteur (pour la carte Arduino)

Rien de très complexe de ce côté non plus, puisque c'est la bibliothèque Manchester qui effectue le sale boulot: chaque fois qu'un message est reçu, il est affiché sur le moniteur série.

	/**************************************
	L'Arduino reçoit les données envoyées par l'ATTiny
	et les affiche dans le moniteur série.
	Instructions complètes:
	http://electroniqueamateur.blogspot.com/2018/02/communication-rf-433-mhz-entre-attiny85.html
	***************************************/
	#include "Manchester.h"
	#define RX_PIN 4 // là où est branché le récepteur 433 MHz
	#define LED_PIN 13
	uint8_t LedOn = 1;
	#define BUFFER_SIZE 22
	uint8_t buffer[BUFFER_SIZE];
	void setup()
	{
	pinMode(LED_PIN, OUTPUT);
	digitalWrite(LED_PIN, LedOn);
	Serial.begin(9600);
	man.setupReceive(RX_PIN, MAN_2400);
	man.beginReceiveArray(BUFFER_SIZE, buffer);
	}
	void loop()
	{
	if (man.receiveComplete())
	{
	uint8_t receivedSize = 0;
	receivedSize = buffer[0]; // la taille du message se trouve dans le premier byte
	int valeur = (buffer[2] << 8) + buffer[3]; // on combine les deux bytes pour former la valeur analogique mesurée
	Serial.print("Message en provenance de l'emmeteur ");
	Serial.print(buffer[1]);
	Serial.print(" : ");
	Serial.println(valeur);
	man.beginReceiveArray(BUFFER_SIZE, buffer);
	LedOn = !LedOn;
	digitalWrite(LED_PIN, LedOn);
	}
	}

view raw Recepteur_ATTiny85.ino hosted with ❤ by GitHub

Circuit de l'émetteur (ATTiny85)

Une LED indicatrice est branchée à la pin 0, l'émetteur est branché à la pin 1, et le potentiomètre est branché à la pin 2 de l'ATTiny85, tel qu'indiqué sur le schéma ci-dessous.

La LED n'est pas obligatoire;  elle change d'état chaque fois qu'un message est envoyé, ce qui peut être utile pour savoir si votre ATTiny est actif ou non.

Circuit du récepteur

Le récepteur est connecté à la broche 4 de l'Arduino.  C'est la LED intégrée à la carte qui change d'état pour indiquer la réception d'un message.

Résultats

Toutes les secondes, l'ATTiny mesure la position du potentiomètre et envoie le résultat à l'Arduino. Sur réception d'un message, l'Arduino l'affiche dans le moniteur série.  Lorsque vous tournez le potentiomètre, la valeur transmise est modifiée.

Et ensuite?

Vous trouverez ici d'autres projets impliquant l'ATTiny85.  En ce qui concerne les émetteurs et récepteurs RF 433 MHz, vous serez peut-être intéressé par ce projet impliquant deux cartes Arduino, ou celui qui établit une communication entre Arduino et Raspberry Pi.

Yves Pelletier   (Twitter, Facebook)