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


    17 Gedanken zu „Funkübertragung von Messwerten mit dem RF Link Modul“

    1. 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

    2. 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 !!!!!!! :-)

    3. 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

    4. 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.

    5. 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.

    6. 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.

    7. 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.

    8. Hi

      Ich habe ein paar Fragen zu deinem Code:

      char Sensor1CharMsg[21];
      Warum erstellst du einen Array mit 21 Felder, wenn du nur 6 Sensordaten übertragen möchtest

      sprintf(Sensor1CharMsg, „%d,%d,%d,%d,%d,%d“,…
      Was genau macht diese Funktion, bzw für was stehen die ganzen %d, ?

      vw_send((uint8_t *)Sensor1CharMsg, strlen(Sensor1CharMsg));
      Welche Zeichen/Zahlen werden damit genau übertragen bzw was kommt dann beim Empfänger an?

      Danke schon mal im voraus :)

      Christian

    9. Hallo Julian,

      für die beschriebene Lösung brauchst Du wirklich ein Arduino pro Seite. Es gibt unzählige andere Ansätze, aber ich habe noch kein Tutorium dafür geschrieben. Wenn Du magst, google mal nach XBee. Damit geht das zum Beispiel.

      Liebe Grüße

      Stefan“

    10. Muss ich am anderen Ende auch ein Arduino haben auch wenn ich keine Messwerte übertragen will, sondern lediglich ein Relais schalten? Oder gibt es dafür sogar einen einfacheren Weg?

      1. Hi Clemens,

        schön, dass Du vorbei schaust. Wow! Die Library ja echt nach einer sauberen Lösung aus. Muss ich mir mal bei Gelegenheit genauer ansehen. Vielen Dank für die Info.

        Liebe Grüße

        Stefan“

    Die Kommentarfunktion ist deaktiviert.