Module récepteur RF superhétérodyne ASK AM à distance RX 433 MHz -112 dBm RX TX

Parfois, dans la conception de systèmes embarqués, vous pouvez vouloir passer au sans fil. Vous souhaiterez peut-être enregistrer diverses mesures de capteurs placés à distance, ou simplement créer une télécommande pour un robot ou un système d'alarme de voiture.

 

J'ai construit deux circuits séparés pour des tests sur des microcontrôleurs Atmega8.

Émetteur

 

 

 

 

Comme vous pouvez le voir, j'ai utilisé une LED pour indiquer l'activité RF. Bon, assez parlé du matériel – en réalité, il n'y a rien de plus à dire – les circuits sont simples.

Passons à la partie logicielle. La transmission radio est un peu plus compliquée que les communications filaires car vous ne savez jamais quels signaux radio sont présents dans l'air. Ainsi, tout dépend de la manière dont le signal transmis est encodé. Et c'est là que vous avez de nombreux choix : utiliser un codage matériel comme USART ou écrire le vôtre basé sur l'une des nombreuses méthodes d'encodage comme NRZ, Manchester, etc. Dans mon exemple, j'ai utilisé le module USART AVR pour former des paquets de données. Les encodeurs matériels résolvent de nombreux problèmes comme la synchronisation, le début et la fin, et divers contrôles de signal. Mais tant que je m'entraînais, vous ne pouviez pas compter sur un simple signal USART. Ici, vous pouvez en fait 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 octet fictif de synchronisation (10101010) ;

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

• un octet de données ;

• et une somme de contrôle qui est en fait la somme de l'adresse et des données (adresse+données).

Pourquoi ai-je utilisé un octet fictif au début du paquet. Tout simplement, j'ai remarqué que lorsque l'émetteur ne transmettait aucune donnée – le récepteur capte divers bruits provenant de l'alimentation ou d'autres sources car le récepteur aime ajuster son gain d'entrée en fonction du niveau du signal d'entrée. Le premier octet accorde le récepteur 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. Probablement avec différents modules de transmission vous pouvez exclure cet octet fictif.

Programme d'émission 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 le débit en bauds souhaité

#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 le débit en bauds

	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 de t ms

{

uint8_t i;

for(i=0;i 

_delay_ms(1);

}

int main(void)

{

USART_Init();

while(1)

	{//transmission en boucle

	//envoyer la commande d'allumage de la LED

	Send_Packet(RADDR, LEDON);

	delayms(100);

	//envoyer la commande d'allumage de la LED

	Send_Packet(RADDR, LEDOFF);

	delayms(100);

	}

	return 0;

}

 

Dans mon cas, j'ai utilisé un débit UART de 1200 bauds. Il peut être augmenté ou diminué en fonction de la distance et de l'environnement. Pour des distances plus longues, des débits 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 8kbits/s, ce qui correspond à 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.

<