PLL ASK OOK Funk-RF-Funk-LINK-Transceiver-Funktion RX-TX-Module 433 MHz

Manchmal möchte man bei der Entwicklung eingebetteter Systeme auf drahtlose Kommunikation setzen. Möglicherweise möchte man verschiedene Messwerte von entfernt platzierten Sensoren aufzeichnen oder einfach eine Fernbedienung für ein Roboter- oder Autoalarmsystem bauen.

Die Funkkommunikation zwischen zwei AVR-Mikrocontrollern kann einfach sein, wenn spezielle Module verwendet werden. Lassen Sie uns die sehr bekannten RF-Module TX433 und RX433 ausprobieren, die (oder ähnliche) in fast jedem Elektronikgeschäft zu finden sind und ein Paar etwa  6,99 USD kostet.

Die Sender- und Empfängermodule sind so abgestimmt, dass sie bei 433,92 MHz korrekt funktionieren. Der Sender kann mit 1,8-3,6 V Stromversorgungbetrieben werden, während der Empfänger 5 Vakzeptiert. 5 V sind für AVR-Mikrocontroller üblich, daher gibt es keine Probleme bei der Schnittstelle. Die Module benötigen keine zusätzlichen Komponenten – einfach mit Strom versorgen und eine Datenleitung für den Informationsversand verbinden, und schon ist es fertig. Für größere Entfernungen verwenden Sie 30–35 cm Antennen. Die Module verwenden die Amplitudenmodulation (ASK) und eine Bandbreite von 1 MHz.

Ich habe zwei separate Schaltungen für Tests auf Atmega8-Mikrocontrollern konstruiert.

   

Kommen wir zum Softwareteil. Die Funkübertragung ist etwas komplizierter als die kabelgebundene Kommunikation, weil man nie weiß, welche Funksignale in der Luft vorhanden sind. Daher ist es wichtig, wie das übertragene Signal kodiert wird. Und hier gibt es viele Möglichkeiten: Verwenden Sie eine Hardware-Kodierung wie USART oder schreiben Sie Ihre eigene basierend auf einer von vielen Kodierungsmethoden wie NRZ, Manchester usw. In meinem Beispiel habe ich das AVR-USART-Modul verwendet, um Datenpakete zu bilden. Hardware-Encoder lösen viele Probleme wie Synchronisation, Start und Stopp sowie verschiedene Signalprüfungen. Aber solange ich mich damit beschäftigte, konnten Sie sich nicht auf ein reines USART-Signal verlassen. Hier können Sie tatsächlich improvisieren, indem Sie verschiedene Prüfungen usw. hinzufügen.

Ich habe beschlossen, 4-Byte-Datenpakete zu bilden, um ein Byte an Informationen zu senden. Diese beinhalten:

• ein dummy Synchronisationsbyte (10101010);

• ein Address Byte – falls es weitere Empfänger (oder Sender) gibt;

• eine Daten Byte;

• und Prüfsumme , die eigentlich die Summe aus Adresse und Daten ist (Adresse+Daten).

Warum habe ich ein Dummy-Byte am Anfang des Pakets verwendet? Ich habe einfach bemerkt, dass der Empfänger verschiedene Störgeräusche aus der Stromversorgung oder anderen Quellen aufnimmt, wenn der Sender keine Daten überträgt, weil der Empfänger seine Eingangsgewinnung je nach Eingangssignal level anpasst. Das erste Byte stimmt den Empfänger ein, damit er ein normales Signal akzeptiert, danach können Adresse, Daten und Prüfsumme zuverlässiger gelesen werden. Wahrscheinlich können Sie dieses Dummy-Byte bei anderen Übertragungsmodulen weglassen.

Sende-Programm für AVR Atmega8:

 

#include 

#include 

#ifndef F_CPU

//Taktfrequenz der CPU definieren, falls nicht bereits definiert

#define F_CPU 8000000

#endif

//Gewünschte Baudrate festlegen

#define BAUDRATE 1200

//UBRR-Wert berechnen

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

//Empfängerparameter festlegen

#define SYNC 0XAA//Synchronisationssignal

#define RADDR 0x44

#define LEDON 0x11//Befehl zum Einschalten der LED

#define LEDOFF 0x22//Befehl zum Ausschalten der LED

void USART_Init(void)

{

	//Baudrate festlegen

	UBRRL=(uint8_t)UBRRVAL; //unteres Byte

	UBRRH=(UBRRVAL>>8);	//oberes Byte

	//Datenrahmenformat festlegen: asynchron, keine Parität, 1 Stoppbit, 8 Bit

	UCSRC=(1< 

(0<  

//Sender, Empfänger und Interrupt bei vollständigem Empfang aktivieren

	UCSRB=(1< 

}

void USART_vSendByte(uint8_t u8Data)

{

 //Warten, wenn ein Byte gesendet wird

 while((UCSRA&(1< 

// Daten senden

 UDR = u8Data; 

}

void Send_Packet(uint8_t addr, uint8_t cmd)

{

	USART_vSendByte(SYNC);//Synchronisationsbyte senden	

	USART_vSendByte(addr);//Empfängeradresse senden

	USART_vSendByte(cmd);//Inkrementbefehl senden

	USART_vSendByte((addr+cmd));//Prüfsumme senden

}

void delayms(uint8_t t)//Verzögerung in ms

{

uint8_t i;

for(i=0;i 

_delay_ms(1);

}

int main(void)

{

USART_Init();

while(1)

	{//Endlossendung

	//Befehl zum Einschalten der LED senden

	Send_Packet(RADDR, LEDON);

	delayms(100);

	//Befehl zum Einschalten der LED senden

	Send_Packet(RADDR, LEDOFF);

	delayms(100);

	}

	return 0;

}

 

In meinem Fall habe ich eine UART-Baudrate von 1200 verwendet. Sie kann je nach Entfernung und Umgebung erhöht oder verringert werden. Bei größeren Entfernungen funktionieren niedrigere Baudraten besser, da die Wahrscheinlichkeit für Übertragungsfehler größer ist. Die maximale Bitrate des Senders beträgt 8kbits/s, was etwa 2400 Baud entspricht. Aber was in der Theorie funktioniert, tut sich in der Praxis meistens nicht. Daher war 1200 Baud das Maximum, was ich zuverlässig zum Laufen bringen konnte.

Der Sender sendet dem Empfänger zwei Befehle (LEDON und LEDOFF) mit 100ms Abstand. Der Empfänger erkennt diese Befehle und schaltet die LED je nach erhaltenem Befehl ein oder aus. Auf diese Weise kann ich überwachen, ob die Datenübertragung korrekt funktioniert. Wenn die LED periodisch blinkt, erfolgt die Übertragung fehlerfrei. Wenn die empfangenen Daten fehlerhaft sind, blinkt die LED kürzer.

Programmcode des Empfängers:

 

#include 

#include 

#include 

#ifndef F_CPU

//Taktfrequenz der CPU definieren, falls nicht bereits definiert

#define F_CPU 4000000

#endif

//Gewünschte Baudrate festlegen

#define BAUDRATE 1200

//UBRR-Wert berechnen

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

//Empfängerparameter festlegen

#define SYNC 0XAA//Synchronisationssignal

#define RADDR 0x44

#define LEDON 0x11//Befehl zum Einschalten der LED

#define LEDOFF 0x22//Befehl zum Ausschalten der LED

void USART_Init(void)

{

	//Baudrate einstellen

	UBRRRL=(uint8_t)UBRRVAL; //unteres Byte

	UBRRH=(UBRRVAL>>8);	//oberes Byte

	//Datenrahmenformat einstellen: asynchroner Modus, keine Parität, 1 Stoppbit, 8 Bit

	UCSRC=(1< 

(0<  

//Sender und Empfänger aktivieren sowie Interrupt bei vollständigem Empfang aktivieren

	UCSRB=(1< 

//Globale Interrupts aktivieren

}

uint8_t USART_vReceiveByte(void)

{

 //Warten, bis ein Byte empfangen wurde

 while((UCSRA&(1< 

// Empfangene Daten zurückgeben

 return UDR;

}

ISR(USART_RXC_vect)

{

	//Variablen definieren

	uint8_t raddress, data, chk;//Senderadresse

	//Empfängeradresse

	raddress=USART_vReceiveByte();

	//Daten empfangen

	data=USART_vReceiveByte();

	//Prüfsumme empfangen

	chk=USART_vReceiveByte();

	//Empfangene Prüfsumme mit der berechneten vergleichen

	if(chk==(raddress+data))//Wenn übereinstimmend, Operationen ausführen

	{

 //Wenn die Senderadresse übereinstimmt