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)

Jouer une mélodie avec le MPLAB Xpress Evaluation Board

L'activité d'aujourd'hui consiste à faire jouer une mélodie de votre choix à travers un petit haut-parleur branché à une carte MPLAB Xpress Evaluation Board (cette carte utilise un microcontrôleur PIC 16F18855 mais notre méthode pourra s'appliquer à bien d'autres microcontrôleurs de la série PIC).

Pour produire le signal sonore, nous allons utiliser une fonction du microcontrôleur qui se nomme NCO, pour Numerically Controlled Oscillator; il s'agit d'un oscillateur qui produit un signal en créneaux dont la fréquence peut être contrôlée à volonté par notre programme.

Le circuit

Le signal produit par l'oscillateur sera accessible par la sortie RC0 du microcontrôleur.  Il est fortement déconseillé de brancher un haut-parleur de 8 Ω directement sur la sortie d'un microcontrôleur, car les courants générés dépassent largement les limites permises.  Je vous suggère plutôt de piloter indirectement le haut-parleur en utilisant un transistor: le faible courant qui circulera dans la base du transistor contrôlera un courant plus intense qui circulera dans le haut-parleur.

Il existe plusieurs variantes (on peut utiliser un transistor bipolaire ou un transistor à effet de champ), voici le circuit que j'ai utilisé:

Même circuit, en version Fritzing:

Si vous désirez vous simplifier la vie, vous pouvez aussi utiliser un buzzer piézo qui, compte tenu de sa grande impédance, peut sans problème être branché directement à la sortie RC0.  Mais la qualité sonore sera moins bonne.

Configuration du projet avec MCC

Nous allons d'abord créer un nouveau projet dans MPLAB Xpress, et ensuite effectuer quelques réglages au moyen du MPLAB Xpress Code Configurator (MCC).  Si vous n'êtes pas familier avec ces outils, il pourrait s'avérer utile de jeter un oeil sur cet article.

Dans MCC, vous localisez "NCO" dans la liste intitulée "Device Resources".  Vous cliquez deux fois sur "NCO1" afin de l'ajouter à votre projet :

 NCO1 apparaît maintenant dans la liste "Project resources":

Je rappelle que NCO signifie Numerically Controlled Oscillateur: il s'agit d'un oscillateur dont nous pourrons contrôler la fréquence à volonté.

Les paramètres par défaut de NCO1 sont adéquats: vous n'avez pas à modifier quoi que ce soit: "NCO mode" est réglé à "FDC_mode", "Output polarity" est à "active_io" et "Clock Source" est réglé à "FOSC".

Notez qu'avec ces réglages, la fréquence maximale de l'oscillateur sera de 500 000 Hz (cette information sera utile lors de la rédaction de notre programme).

Nous allons associer la broche RC0 à l'oscillateur NCO1, en cliquant le cadenas approprié dans le bas de l'écran (sur la ligne NCO1 - ouput), puisque c'est là que nous avons branché notre haut-parleur:

Ne pas oublier de cliquer sur le bouton "Generate" afin que nos réglages soient exportés vers le projet que nous avons créé dans MPLAB Xpress.

Calcul des fréquences

Chaque note musicale de la gamme est associée à une fréquence bien précise.  Par exemple, une fréquence de 130,81 Hz donne un do.

Pour choisir la fréquence à laquelle vibrera notre oscillateur, nous devons régler la valeur du registre d'incrémentation ("increment register") qui est un nombre à 16 bits réparti sur deux octets: NCO1INCH (haute valeur) et NCO1INCL (basse valeur).  Plus cette valeur est grande, plus la fréquence d'oscillation sera élevée.

Puisque la valeur maximale du timer est de 1 048 575 et que la fréquence maximale de l'oscillateur est de 500 000 Hz, nous calculons la valeur du registre d'incrémentation de la façon suivante:

Par exemple, pour produire une fréquence de 130,81 Hz correspond à un do,  l'équation nous donne une valeur décimale de 549 qui se traduit par le nombre binaire 1000100101.  Il reste à placer les 8 derniers bits (00100101) dans le registre NCO1INCL et les bits excédentaires (10) dans le registre NCO1INCH.  Dans le script présenté ci-dessous, c'est ainsi que j'ai défini la note "C3":

const int NoteC3[2] = {0b00000010, 0b00100101};

Le script

J'ai cherché à faire un programme qui rendrait facile l'écriture d'une mélodie.  J'ai donc défini toutes les notes de la gamme sur 3 octaves (ces constantes portent des noms de la forme "NoteA3", "NoteC2", etc.  Il s'agit de la convention dans laquelle "A" correspond à un LA, "B" correspond à un SI, etc.

Pour chaque note qu'on désire jouer, il s'agit d'utiliser la commande "Playnote" en donnant comme argument le nom de la note (comme par exemple "NoteC2" pour le do le plus grave) et la durée (1 pour une noire, 2 pour une blanche, 4 pour une ronde...).

Vous pouvez modifier la valeur de la variable globale "tempo" pour changer la vitesse à laquelle la mélodie sera jouée.

	/**************************************************
	On joue une mélodie grâce au NCO
	(numerically controlled oscillator) du
	MPLAB Xpress Evaluation Board
	La sortie est RC0.
	Plus d'informations:
	http://electroniqueamateur.blogspot.com/2018/02/jouer-une-melodie-avec-le-mplab-xpress.html
	**************************************************/
	#include "mcc_generated_files/mcc.h"
	const int tempo = 100; //durée, en millisecondes, de la note la plus courte
	const int pause = 20; // durée, en millisecondes, de la courte pause après chaque note; doit être plus petite que tempo!
	//Définition des notes
	const int NoteC2[2] = {0b00000001, 0b00010010};
	const int NoteDb2[2]= {0b00000001, 0b00100011};
	const int NoteD2[2] = {0b00000001, 0b00110100};
	const int NoteEb2[2] = {0b00000001, 0b01000110};
	const int NoteE2[2] = {0b00000001, 0b01011010};
	const int NoteF2[2] = {0b00000001, 0b01101110};
	const int NoteGb2[2] = {0b00000001, 0b10000100};
	const int NoteG2[2] = {0b00000001, 0b10011011};
	const int NoteAb2[2] = {0b00000001, 0b10110011};
	const int NoteA2[2] = {0b00000001, 0b11001101};
	const int NoteBb2[2] = {0b00000001, 0b11101001};
	const int NoteB2[2] = {0b00000010, 0b00000110};
	const int NoteC3[2] = {0b00000010, 0b00100101};
	const int NoteDb3[2]= {0b00000010, 0b01000101};
	const int NoteD3[2] = {0b00000010, 0b01101000};
	const int NoteEb3[2] = {0b00000010, 0b10001100};
	const int NoteE3[2] = {0b00000010, 0b10110011};
	const int NoteF3[2] = {0b00000010, 0b11011100};
	const int NoteGb3[2] = {0b00000011, 0b00001000};
	const int NoteG3[2] = {0b00000011, 0b00110110};
	const int NoteAb3[2] = {0b00000011, 0b01100111};
	const int NoteA3[2] = {0b00000011, 0b10011011};
	const int NoteBb3[2] = {0b00000011, 0b11010010};
	const int NoteB3[2] = {0b00000100, 0b00001100};
	const int NoteC4[2] = {0b00000100, 0b01001001};
	const int NoteDb4[2]= {0b00000100, 0b10001011};
	const int NoteD4[2] = {0b00000100, 0b11010000};
	const int NoteEb4[2] = {0b00000101, 0b00011001};
	const int NoteE4[2] = {0b00000101, 0b01100111};
	const int NoteF4[2] = {0b00000101, 0b10111001};
	const int NoteGb4[2] = {0b00000110, 0b00010000};
	const int NoteG4[2] = {0b00000110, 0b01101100};
	const int NoteAb4[2] = {0b00000110, 0b11001110};
	const int NoteA4[2] = {0b00000111, 0b100110101};
	const int NoteBb4[2] = {0b00000111, 0b10100011};
	const int NoteB4[2] = {0b00001000, 0b00010111};
	const int NoteC5[2] = {0b00001000, 0b10010011};
	// Puisque __delay_ms() n'accepte pas de variable, on
	// écrit une routine qui attend pendant un certain
	// nombre de millisecondes
	attend(int milliseconds)
	{
	while(milliseconds > 0)
	{
	__delay_ms(1);
	milliseconds--;
	}
	}
	// on joue la note avec la fréquence et la durée requises
	void playnote(int laNote[2], int duree)
	{
	NCO1CONbits.N1EN = 1; // activation du NCO
	// réglage de la fréquence
	NCO1INCH = laNote[0]; // increment register (high value)
	NCO1INCL = laNote[1]; // increment register (low value)
	attend(duree*tempo-pause); // on attend pendant que la note joue
	NCO1CONbits.N1EN = 0; // désactivation du NCO
	attend(pause); // court silence pour séparer les notes les unes des autres
	}
	void main(void)
	{
	SYSTEM_Initialize();
	while (1)
	{
	// playnote (note, durée)
	playnote(NoteC2, 3);
	playnote(NoteC2, 1);
	playnote(NoteE2, 3);
	playnote(NoteE2, 1);
	playnote(NoteG2, 3);
	playnote(NoteG2, 1);
	playnote(NoteA2, 3);
	playnote(NoteA2, 1);
	playnote(NoteBb2, 3);
	playnote(NoteBb2, 1);
	playnote(NoteA2, 3);
	playnote(NoteA2, 1);
	playnote(NoteG2, 3);
	playnote(NoteG2, 1);
	playnote(NoteA2, 3);
	playnote(NoteG2, 1);
	playnote(NoteC4, 3);
	playnote(NoteC4, 1);
	playnote(NoteE4, 3);
	playnote(NoteE4, 1);
	playnote(NoteG4, 3);
	playnote(NoteG4, 1);
	playnote(NoteA4, 3);
	playnote(NoteA4, 1);
	playnote(NoteBb4, 3);
	playnote(NoteBb4, 1);
	playnote(NoteA4, 3);
	playnote(NoteA4, 1);
	playnote(NoteG4, 3);
	playnote(NoteG4, 1);
	playnote(NoteA4, 3);
	playnote(NoteG4, 1);
	playnote(NoteF3, 3);
	playnote(NoteF3, 1);
	playnote(NoteA3, 3);
	playnote(NoteA3, 1);
	playnote(NoteC4, 3);
	playnote(NoteC4, 1);
	playnote(NoteD4, 3);
	playnote(NoteD4, 1);
	playnote(NoteEb4, 3);
	playnote(NoteEb4, 1);
	playnote(NoteD4, 3);
	playnote(NoteD4, 1);
	playnote(NoteC4, 3);
	playnote(NoteC4, 1);
	playnote(NoteD4, 3);
	playnote(NoteC4, 1);
	playnote(NoteF2, 3);
	playnote(NoteF2, 1);
	playnote(NoteA2, 3);
	playnote(NoteA2, 1);
	playnote(NoteC3, 3);
	playnote(NoteC3, 1);
	playnote(NoteD3, 3);
	playnote(NoteD3, 1);
	playnote(NoteEb3, 3);
	playnote(NoteEb3, 1);
	playnote(NoteD3, 3);
	playnote(NoteD3, 1);
	playnote(NoteC3, 3);
	playnote(NoteC3, 1);
	playnote(NoteD3, 3);
	playnote(NoteC3, 1);
	}
	}

view raw melodie.c hosted with ❤ by GitHub

Voici, pour terminer, une courte vidéo permettant d'entendre le résultat.

D'autres articles du même genre

J'ai déjà publié plusieurs articles impliquant le MPLAB Xpress Evaluation Board:  programmation des entrées/sorties, communication série par USB, utilisation d'une entrée analogique, contrôle d'un moteur à courant continu.

Si vous désirez jouer une mélodie en utilisant autre chose que le MPLAB Xpress Evaluation Board, ces articles pourraient vous intéresser: brancher un haut-parleur à l'Arduino,  jouer une mélodie avec le STM32 Nucleo, jouer une mélodie avec l'ATTiny85,  Bip bip: 5 circuits qui produisent un son.


Yves Pelletier   (Twitter, Facebook)

Jouer une mélodie avec l'ATTiny85

Si, tout comme moi, vous programmez l'ATTiny85 avec l'IDE Arduino et le noyau ATtiny par David A. Mellis, vous avez peut-être été frustré par l'absence de support pour la fonction "tone()" qui permet, sur une carte Arduino, de produire un son dont on peut contrôler la fréquence à volonté.

Il existe toutefois un remède, proposé par David Johnson-Davies dans son excellent blog Technoblogy: dans un sketch qu'il a baptisé "TinyTone", il utilise le timer/counter1 de l'ATtiny85 pour produire l'équivalent de ce que fait la fonction tone() sur l'Arduino.

Programmation de l'ATTiny

Au besoin, référez-vous à ce billet pour la façon d'installer le noyau ATtiny de David A. Mellis et programmer l'ATTiny au moyen d'une carte Arduino.

Sketch

Le sketch ci-dessous est celui publié par David Johnson-Davies, dans lequel je me suis contenté de modifier la mélodie (il s'agit d'À la Claire Fontaine) de la fonction playTune().  Le contenu de la fonction TinyTone() peut vous sembler obscur si vous n'êtes pas familier avec la manipulation des registres de l'ATTiny, mais vous n'aurez probablement pas besoin de la modifier.

	/****************************************************
	TinyTone for ATtiny85
	Basé sur le programme original de David Johnson-Davies:
	http://www.technoblogy.com/show?KVO
	Plus de détails:
	http://electroniqueamateur.blogspot.com/2018/02/jouer-une-melodie-avec-lattiny85.html
	*****************************************************/
	// Notes
	const int Note_C = 239;
	const int Note_CS = 225;
	const int Note_D = 213;
	const int Note_DS = 201;
	const int Note_E = 190;
	const int Note_F = 179;
	const int Note_FS = 169;
	const int Note_G = 159;
	const int Note_GS = 150;
	const int Note_A = 142;
	const int Note_AS = 134;
	const int Note_B = 127;
	int Speaker = 1;
	void setup()
	{
	pinMode(Speaker, OUTPUT);
	}
	void loop()
	{
	playTune();
	delay(1000);
	}
	void TinyTone(unsigned char divisor, unsigned char octave, unsigned long duration)
	{
	TCCR1 = 0x90 | (8 - octave); // for 1MHz clock
	// TCCR1 = 0x90 | (11-octave); // for 8MHz clock
	OCR1C = divisor - 1; // set the OCR
	delay(duration);
	TCCR1 = 0x90; // stop the counter
	delay(10); // pour la séparation des notes identiques successives
	}
	// Mélodie (À la claire fontaine)
	void playTune(void)
	{
	//TinyTone (note, octave, durée);
	TinyTone(Note_C, 4, 800);
	TinyTone(Note_C, 4, 400);
	TinyTone(Note_E, 4, 400);
	TinyTone(Note_E, 4, 400);
	TinyTone(Note_D, 4, 400);
	TinyTone(Note_E, 4, 400);
	TinyTone(Note_D, 4, 400);
	TinyTone(Note_C, 4, 800);
	TinyTone(Note_C, 4, 400);
	TinyTone(Note_E, 4, 400);
	TinyTone(Note_E, 4, 400);
	TinyTone(Note_D, 4, 400);
	TinyTone(Note_E, 4, 800);
	TinyTone(Note_E, 4, 800);
	TinyTone(Note_E, 4, 400);
	TinyTone(Note_D, 4, 400);
	TinyTone(Note_C, 4, 400);
	TinyTone(Note_E, 4, 400);
	TinyTone(Note_G, 4, 400);
	TinyTone(Note_E, 4, 400);
	TinyTone(Note_G, 4, 800);
	TinyTone(Note_G, 4, 400);
	TinyTone(Note_E, 4, 400);
	TinyTone(Note_C, 4, 400);
	TinyTone(Note_E, 4, 400);
	TinyTone(Note_D, 4, 800);
	TinyTone(Note_C, 4, 800);
	TinyTone(Note_C, 4, 400);
	TinyTone(Note_E, 4, 400);
	TinyTone(Note_E, 4, 400);
	TinyTone(Note_D, 4, 200);
	TinyTone(Note_C, 4, 200);
	TinyTone(Note_E, 4, 400);
	TinyTone(Note_C, 4, 400);
	TinyTone(Note_E, 4, 800);
	TinyTone(Note_E, 4, 400);
	TinyTone(Note_D, 4, 200);
	TinyTone(Note_C, 4, 200);
	TinyTone(Note_E, 4, 400);
	TinyTone(Note_D, 4, 400);
	TinyTone(Note_C, 4, 800);
	}

view raw melodie_ATTiny85.ino hosted with ❤ by GitHub

Circuit

Après avoir programmé l'ATTiny85, il ne reste plus qu'à lui ajouter un haut-parleur sur la broche physique numéro 6 (également nommée broche 1 pour l'IDE Arduino), tel qu'illustré ci-dessous.

Vidéo du résultat

Aller plus loin

Pour générer des sons plus sophistiqués, vous pouvez également jeter un oeil sur le Tiny Synth, également développé par David Johnson-Davies et présenté dans son blog Technoblogy.  De plus, David vient tout juste de publier une version améliorée de sa fonction "TinyTone()".

Yves Pelletier   (Twitter, Facebook)