Zum Inhalt springen
RWS-371 RF Modul

Funkübertragung von Messwerten mit dem RF Link Modul

Das RF Link Modul (Receiver und Transmitter) aus der RWS-371-Serie ist ein ziemlich günstiger Weg, Signale kabellos über kurze Distanzen zu übertragen. Dieses Beispiel zeigt, wie man es verwendet. Als Transmitter kannst Du die Module TLP 434, 434-A oder 916-A, als Receiver die Module RLP 434, 434-A, 916-A oder 916-F verwenden.

Die Funktionsweise der Module ist sehr einfach. Wenn der Daten-Pin des Sendemoduls getriggert wird, sendet es ein Signal. Der Empfänger empfängt es und schickt ein Signal an einen Pin des Mikrocontrollers.

Damit man mit dieser Funktion etwas Sinnvolles anstellen kann, werden wir die VirtualWire Bibliothek von Mike McCauley verwenden, die es uns ermöglicht, komplexe Daten zu übertragen.


Sieh dir jetzt meinen neuen Arduino-Videokurs an: Jetzt ansehen!


Die Bibliothek kannst Du Dir von dieser Seite herunterladen. Sie muss in den Libraries Ordner im Arduino-Benutzerordner kopiert werden. Danach musst Du die Arduino IDE erneut starten.

Ich schlage vor, dass Du die Schaltung einfach nachbaust und die Programme auf die beiden Mikrocontroller überträgst. Der Code ist ziemlich selbsterklärend: Sechs analoge Inputs des Sendenden Mikrocontrollers werden ausgelesen und mittels RF Link Modul verschickt. Der empfangende Mikrocontroller sendet die empfangenen Daten dann an die serielle Schnittstelle. Mit dem seriellen Monitor der Arduino-Software kann man sich die Daten ansehen.

Circuits using Arduino UNO

RF Link Modul mit Arduino

Circuits using the Teensy 3.1

RF Link Modul mit Teensy

Code für den Sender

/*.............................................................
transmitter

build on example "Sending Multiple Variables Using VirtualWire. Transmitter"
by Author: Rodrigo Mompo Redoli
For controlrobotics.rodrigomompo.com
..............................................................*/
#include <VirtualWire.h>

int sensorPins[] = {A0,A1,A2,A3,A4,A5}; // The pins were sensor are attached
char Sensor1CharMsg[21];// The string that we are going to send trought rf 

void setup() {
  // VirtualWire setup
  vw_set_ptt_inverted(true);

  vw_setup(2000); // Bits per sec
  vw_set_tx_pin(12);// Set the Tx pin. Default is 12
}

void loop() {
  sprintf(Sensor1CharMsg, "%d,%d,%d,%d,%d,%d", analogRead(sensorPins[0]), analogRead(sensorPins[1]), analogRead(sensorPins[2]), analogRead(sensorPins[3]), analogRead(sensorPins[4]), analogRead(sensorPins[5]));
  delay(5);

  vw_send((uint8_t *)Sensor1CharMsg, strlen(Sensor1CharMsg));
  vw_wait_tx(); // Wait until the whole message is gone
 
  delay(40);
}

Code für den Empfänger

/* Receiver 

build on example "Sending Multiple Variables Using VirtualWire."
by Author: Rodrigo Mompo Redoli
For controlrobotics.rodrigomompo.com
..............................................................*/

#include <VirtualWire.h>

const int led_pin = 13;
const int receive_pin = 12;

int maxSensorData = 6;
int sensorData[6];

char StringReceived[22]; 

void setup() {
  Serial.begin(9600);                        // initialising serial
  vw_set_rx_pin(receive_pin);                // virtual wire setup
  vw_set_ptt_inverted(true);                 // virtual wire setup
  vw_setup(2000);                            // bits per second
  vw_rx_start();                             // Start the receiver PLL running
} // END void setup

void loop(){
  uint8_t buf[VW_MAX_MESSAGE_LEN];
  uint8_t buflen = VW_MAX_MESSAGE_LEN;
  if (vw_get_message(buf, &buflen)) {        //Taking the data from the control base
    int i;
    for (i = 0; i < buflen; i++) {            
      StringReceived[i] = char(buf[i]);      // data to array
    }
    // split data into array sensorData
    sscanf(StringReceived, "%d,%d,%d,%d,%d,%d", &sensorData[0], &sensorData[1], &sensorData[2], &sensorData[3], &sensorData[4], &sensorData[5]); // Converts a string to an array
  }
  for (int i=0; i<maxSensorData; i++){       // nice output
    Serial.print("Sensor "); Serial.print(i); Serial.print(": "); 
    Serial.print(sensorData[i]); Serial.print("\t");
  }
  Serial.println("");                        // linefeed
  // reset variable StringReceived
  memset(StringReceived, 0, sizeof(StringReceived));
  delay(5);
}

Arduino

RF Link Modul mit Arduino

Teensy

RF Link Modul mit Teensy

Montage auf Breadboard. Für den Versuchsaufbau teilen sich beide Controller eine Stromquelle. Das ist natürlich nicht nötig.


Wenn dir das Projekt gefallen hat und du von weiteren interessanten Projekten inspiriert werden willst, sieh dir doch mal mein neues E-Book »Arduino Projekte Volume 1« an!

  • Die beliebtesten Arduino-Projekte von StartHardware
  • Inklusive Schaltplan, Beschreibung und Code
  • Arduino-Schnellstart-Kapitel
  • Kompakter Programmierkurs


0 0 votes
Article Rating
17 Comments
Newest
Oldest Most Voted
Inline Feedbacks
Alle Kommentare anzeigen
Didi
7 Jahre zuvor

Hallo,
über welche Schnittstelle werden Funkmodule und Microcontroller angeschlossen ?
Danke und Gruß

Marc
8 Jahre zuvor

hi…
ich hab ne allgemeine frage zur drahtlosen übertragung von daten/funktionen…

ist es möglich die funkverbindung irgendwie fix zu koppeln?
also das ich sobald ich die schaltung anschalte nur ein bestimmter funkempfänger angesprochen wird…

ich habe vor mehrere empfänger mit unterschiedlichen sendern zu steuern…

gruss marc

Micha
9 Jahre zuvor

Hallo zusammen,

Ich nutze diesen Codes zur Übertragung von Temperaturen und in einem Menü vorgegebenen Werten.

Ich habe jetzt zwei Probleme und hoffe das mir jemand helfen kann……

Ich versende die analogen Eingänge der Temperaturfühler (NTC mit 1 MOhm bei 25 °C)

Nehme diese werte und lasse sie mit der gleichen Formel umrechnen wie am Sender. Zum einem weichen die Daten m.e. zu sehr ab und es würde mich interessieren wie diese Abweichungen glätten kann….

Das andere Problem ist:

Ich gebe die werte an ein TFT-Display und an einen Warmsummer.

Gedanke War, wenn die Temperatur zu sehr abweicht soll der Summer ansprechen und das Display auch eine Aktion ausführen. Aber die werte bleiben einfach stehen und es passiert nichts weiter. Würde man dem TFT vetrauen könnte man denken das sich die Temperatur nicht verändert. Ich will aber das wenn nichts mehr empfangen wird ich das aufnehme und umsetzten kann…

HILFE !!!!!!! :-)

Marius
9 Jahre zuvor

Hallo,
Ich bin Anfänger im Umgang mit Arduinos und Programmierung.
Mein Ziel war es die (eine) Achsenposition eines Joysticks zu senden.
Dabei nutze ich zwei Arduino UNO und die folgenden Radiofrequenzmodule:
http://www.ebay.de/itm/like/401028290486?lpid=106&chn=ps&ul_noapp=true
Ich den Code auf die Arduinos geladen und die Module wie auf den Bilder gezeigt angeschlossen. Nun zeigt der Serielle Monitor des Empfängers für alle Sensoren 0 an.
Wo könnte das Problem liegen?
Funktioniert der Code nicht mit den genannten Sender und Empfänger?
Gruß Marius

10 Jahre zuvor

Rafic with the NANO and after playing with it for a while i got it to trnismat but never had success receiving using the nano Having 2 nano setups side by side on 2 computers, I have to type something in the Serial Monitor on the receive one before it will receive. It appears after reset, something isn’t set up correctly until you send it a character or two on the serial. Haven’t checked yet if it’s the serial chip on the nano, or code side not working until a char comes in.

10 Jahre zuvor

Da ich es auf deinem Bild gerade sehe. Was ist eigentlich der Unterschied zwischen einem grünen und einem blauen Arduino Uno?
Michael

Christian
10 Jahre zuvor

Dankeschön :)

Wolfgang
10 Jahre zuvor

Habe gerade feststellen müssen, dass hier die Zeichen „kleiner“ < und „größer“ > als Steuerzeichen interpretiert werden. In meinen beiden Kommentaren sollte ein Hinweis auf die Bibliothek <VirtualWire.h> stehen. Deshalb dieser Nachtrag. Ich hoffe, dass das jetzt richtig umgesetzt wird.

Wolfgang
10 Jahre zuvor

sprintf: diese Funktion dient dazu, Zahlen, die im Programm in einer binären – also für Menschen schlecht lesbaren Form – vorliegen, mit Hilfe der Umsetzungsmaske
(hier „%d,%d,%d,%d,%d,%d“) in druckbare und somit gut lesbare Zeichen umzuwandeln (siehe http://www.cplusplus.com/reference/cstdio/sprintf/).
Genau passiert hier also folgendes:
die sechs Signale an den Sensorpinnen A0-A5 (siehe http://arduino.cc/en/pmwiki.php?n=Reference/AnalogRead) werden hier durch Kommata getrennt in die Zahlen 0-1023
je nach am Sensor angelegter Spannung übersetzt und in der Variablen „Sensor1CharMsg“ abgelegt. Somit könnte z.B. in dieser Variable folgendes stehen:
„12, 254, 1000, 500, 24, 125“.

vw_send: diese Funktion ist in der Bibliothek beschrieben. Sie überträgt die mit sprintf (s.o.) erzeugte Zeichenkette an den Funksender.
Dabei wird hier im ersten Parameter „(uint8_t *)Sensor1CharMsg“ nur ein Zeigen auf den Beginn dieser Zeichenkette übergeben. Damit die Funktion nun
weiß, wieviele Zeichen sie denn übertragen muss, wird die Länge im zweiten Parameter „strlen(Sensor1CharMsg)“ übergeben. Die Funtion „strlen“ ermittelt die Länge
des angegebenen Parameters.

Hoffentlich habe ich das jetzt so verständlich beschrieben.

Stefan Hermann
Antworte an  Wolfgang
10 Jahre zuvor

Wow! Super coole Beschreibung, Wolfgang. Vielen Dank und liebe Grüße

Stefan“

Wolfgang
10 Jahre zuvor

Kann hier ein Pufferüberlauf entstehen?


// Maximum number of bytes in a message, counting the byte count and FCS
#define VW_MAX_MESSAGE_LEN 30

In der Bibliothek VirtualWire.h wird u.a. auch der Wert für VW_MAX_MESSAGE_LEN definiert (hier mit dem Wert 30).
Im Programm „Receiver“ wird nun die Zeichenvariable „StringReceived“ in der Länge von 22 Zeichen erzeugt:

char StringReceived[22];

Weiter unten wird nun diese Variable mit Inhalt gefüllt:

for (i = 0; i < buflen; i++) {
StringReceived[i] = char(buf[i]); // data to array

Kann dies nicht zu einem Buffer Overflow führen, da ja 30 Zeichen übertragen werden, das Empfangsfeld aber nur 22 Stellen groß ist?
Wäre es nicht besser, in der Definition folgendes zu schreiben:

char StringReceived[VW_MAX_MESSAGE_LEN];

Dann ist immer garantiert, dass das Empfangsfeld genauso groß wie das Sendefeld ist.