PLL ASK OOK Sans fil RF Sans fil Fonction émetteur-récepteur LINK Modules RX TX 433MHZ

Dans le cadre d’une conception embarquée, vous souhaitez parfois passer au sans fil. Vous voudrez peut-être enregistrer les différentes mesures de capteurs placés à distance ou simplement créer une télécommande pour un robot ou un système d’alarme pour voiture.

Les communications radio entre deux microcontrôleurs AVR peuvent être simples si l’on utilise des modules spécialisés. Essayons d’utiliser les modules radio TX433 et RX433 très répandus, que l’on trouve dans presque tous les magasins d’électronique et dont une paire coûte environ 6,99 USD.

Les modules émetteur et récepteur sont réglés pour fonctionner correctement à 433,92 MHz. L’émetteur peut être alimenté par une alimentationde 1,8 à 3,6 V 5 V, tandis que le récepteur accepte 5 V. 5 V est une tension courante pour les microcontrôleurs AVR, il n’y a donc aucun problème d’interfaçage. Les modules ne nécessitent aucun composant supplémentaire : il suffit de les alimenter et de connecter une ligne de données unique pour envoyer et recevoir des informations. Pour obtenir de meilleures distances, utilisez des antennes de 30 à 35 cm. Les modules utilisent la modulation par déplacement d’amplitude (ASK) et une bande passante de 1 MHz.

J’ai conçu deux circuits distincts pour effectuer des tests sur des microcontrôleurs Atmega8.

   

Passons maintenant à la partie logicielle. La transmission radio est un peu plus complexe que les communications filaires, car on ne sait jamais quels signaux radio sont présents dans l’air. Il est donc essentiel de savoir comment le signal transmis est encodé. C’est à ce niveau que vous avez le choix entre plusieurs méthodes : utiliser un encodage matériel tel que l’USART ou écrire le vôtre en vous basant sur l’une des nombreuses méthodes d’encodage, comme NRZ, Manchester, etc. Dans mon exemple, j’ai utilisé le module USART matériel de l’AVR pour former des paquets de données. Les encodeurs matériels résolvent de nombreux problèmes tels que la synchronisation, le début et la fin de transmission, ainsi que divers contrôles de signal. Mais, pour autant que je sache, vous ne pouvez pas vous fier à un signal USART brut. Vous pouvez en réalité improviser en ajoutant divers contrôles, etc.

J’ai décidé de former des paquets de données de 4 octets afin d’envoyer une information d’un octet. Ceux-ci comprennent :

• un octetet de synchronisation (10101010) ;

• un octet d’adresse – au cas où il y aurait plusieurs récepteurs (ou émetteurs) ;

• un octet de données ;

• et une somme de contrôle, qui est en réalité la somme de l’adresse et des données (adresse + données).

Pourquoi ai-je utilisé un octet fictif au début du paquet ? J’ai simplement remarqué que lorsque l’émetteur ne transmettait aucune donnée, le récepteur captait divers bruits provenant de l’alimentation ou d’autres sources, car le récepteur a tendance à ajuster son gain d’entrée en fonction du niveau du signal d’entrée. Le premier octet permet au récepteur de se régler pour accepter un signal normal, après quoi l’octet d’adresse, les données et la somme de contrôle peuvent être lus plus fiablement. Avec d’autres modules de transmission, vous pouvez peut-être vous passer de cet octet fictif.

Programme de l’émetteur pour AVR Atmega8 :

 

#include 

#include 

#ifndef F_CPU

//définir la vitesse d'horloge du processeur si elle n'est pas définie

#define F_CPU 8000000

#endif

//définir la vitesse de transmission souhaitée

#define BAUDRATE 1200

//calculer la valeur UBRR

#define UBRRVAL ((F_CPU/(BAUDRATE*16UL))-1)

//définir les paramètres de réception

#define SYNC 0XAA// signal de synchronisation

#define RADDR 0x44

#define LEDON 0x11//commande d'allumage de la LED

#define LEDOFF 0x22//commande d'extinction de la LED

void USART_Init(void)

{

	//Définir la vitesse de transmission

	UBRRL=(uint8_t)UBRRVAL; //octet de poids faible

	UBRRH=(UBRRVAL>>8);	//octet de poids fort

	//Définir le format du trame de données : mode asynchrone, sans parité, 1 bit d'arrêt, taille de 8 bits

	UCSRC=(1< 

(0<  

//Activer l'émetteur et le récepteur et l'interruption à la fin de la réception

	UCSRB=(1< 

}

void USART_vSendByte(uint8_t u8Data)

{

 //Attendre si un octet est en cours de transmission

 while((UCSRA&(1< 

// Transmettre les données

 UDR = u8Data; 

}

void Send_Packet(uint8_t addr, uint8_t cmd)

{

	USART_vSendByte(SYNC);//envoyer l'octet de synchronisation	

	USART_vSendByte(addr);//envoyer l'adresse du récepteur

	USART_vSendByte(cmd);//envoyer la commande d'incrémentation

	USART_vSendByte((addr+cmd));//envoyer la somme de contrôle

}

void delayms(uint8_t t)//retard en ms

{

uint8_t i;

for(i=0;i 

_delay_ms(1);

}

int main(void)

{

USART_Init();

while(1)

	{//transmission en boucle

	//envoyer la commande pour allumer la LED

	Send_Packet(RADDR, LEDON);

	delayms(100);

	//envoyer la commande pour allumer la LED

	Send_Packet(RADDR, LEDOFF);

	delayms(100);

	}

	return 0;

}

 

Dans mon cas, j'ai utilisé une vitesse de transmission UART de 1200 bauds. Elle peut être augmentée ou diminuée en fonction de la distance et de l'environnement. Pour des distances plus longues, des vitesses de transmission plus faibles fonctionnent mieux car il y a une plus grande probabilité d'erreurs de transmission. Le débit maximal de l'émetteur est de 8 kbits/s, soit environ 2400 bauds. Mais ce qui fonctionne en théorie ne fonctionne généralement pas en pratique. Donc 1200 bauds est le maximum que j'ai pu faire fonctionner correctement.

L'émetteur envoie deux commandes (LEDON et LEDOFF) au récepteur avec des intervalles de 100 ms. Le récepteur reconnaît ces commandes et allume ou éteint la LED en fonction de la commande reçue. De cette façon, je peux vérifier si le transfert de données fonctionne correctement. Si le clignotement de la LED est périodique, alors la transmission se fait sans erreurs. S'il y a une erreur dans les données reçues, la LED clignote plus brièvement.

Code du programme du récepteur :

 

#include 

#include 

#include 

#ifndef F_CPU

//définir la vitesse d'horloge du processeur si elle n'est pas définie

#define F_CPU 4000000

#endif

//définir la vitesse de transmission souhaitée

#define BAUDRATE 1200

//calculer la valeur UBRR

#define UBRRVAL ((F_CPU/(BAUDRATE*16UL))-1)

//définir les paramètres de réception

#define SYNC 0XAA// signal de synchronisation

#define RADDR 0x44

#define LEDON 0x11//commande d'allumage de la LED

#define LEDOFF 0x22//commande d'extinction de la LED

void USART_Init(void)

{

	//Définir la vitesse de transmission

	UBRRRL=(uint8_t)UBRRVAL; //octet de poids faible

	UBRRH=(UBRRVAL>>8);	//octet de poids fort

	//Définir le format du cadre de données : mode asynchrone, sans parité, 1 bit d'arrêt, taille de 8 bits

	UCSRC=(1< 

(0<  

//Activer l'émetteur, le récepteur et l'interruption à la fin de la réception

	UCSRB=(1< 

//Activer les interruptions globales

}

uint8_t USART_vReceiveByte(void)

{

 //Attendre qu'un octet soit reçu

 while((UCSRA&(1< 

//Retourner les données reçues

 return UDR;

}

ISR(USART_RXC_vect)

{

	//Définir les variables

	uint8_t raddress, data, chk;//adresse de l'émetteur

	//adresse de destination de réception

	raddress=USART_vReceiveByte();

	//Recevoir les données

	data=USART_vReceiveByte();

	//Recevoir la somme de contrôle

	chk=USART_vReceiveByte();

	//Comparer la somme de contrôle reçue avec celle calculée

	if(chk==(raddress+data))//si correspondance, effectuer les opérations

	{

 //si l'adresse de l'émetteur correspond