next topic »

[on:]

Hallo,

ich möchte zu Testzwecken zwei RFM12-Module an einem MEGA betreiben. Geht das? Wenn ja wie?


Danke
Peter

[Reply #1 on:]

Senden nicht beide Module auf der gleichen Frequenz? Die Frequenz kann man in einem Register einstellen darum ja, Du kannst 2 Module betreiben wenn Du die Frequenzen änderst.
http://www.mikrocontroller.net/articles/RFM12

Grüße Uwe

[Reply #2 on:]

Ja sie arbeiten beide auf 434MHz. Aber geht es denn, dass Modul A das empfangen kann was Modul B zur gleichen Zeit sendet?

[Reply #3 on:]

Wenn beide nicht auf der gleichen Frequenz senden bzw empfangen dann funktioniert es. Ansonsten empfängt der Empfänge die Daten die der Sender neben ihm (auf dem Arduino) sendet und nicht die Daten des richtigen Senders.
Wie man die Frequenz innerhalb eines gewissen Bereichs ändern kann steht im Link.
Grüße Uwe

[Reply #4 on:]

Danke Uwe,

allerdings hab mir jetzt auf einem Breadboard noch ein Arduino mit einem 328 zusammen gesteckt.

Dieser hat folgenden Code (abgewandelt vom timedsend-Bsp)

Code:

/// @dir timedSend
/// Experiment with time-controlled periodic transmission.
// 2011-06-24 <jc@wippler.nl> http://opensource.org/licenses/mit-license.php

#include <JeeLib.h>

MilliTimer sendTimer;
byte pending;
word seqnum;

void setup () {
  Serial.begin(57600);
  Serial.println("\n[timedSend]");
  rf12_initialize(25, RF12_433MHZ, 4);
  pinMode(13, OUTPUT);
}

void loop () {
  if (rf12_recvDone() && rf12_crc == 0 && rf12_len == 2) {
    sendTimer.set(0);
    Serial.print(" #");
    Serial.print(seqnum);
    Serial.print(" start: ");
    Serial.print(rf12_data[0], DEC);
    Serial.print(" recvd: ");
    Serial.println(rf12_data[1], DEC);
  }
 
  if (rf12_canSend()) {
    pending = 0;
    rf12_sendStart(RF12_HDR_ACK, "hello!", 6);
   
    ++seqnum;
  }
}

Der Mega hat eine abgewandelte Version von TimedRecv-Bsp drauf.

Code:

/// @dir timedRecv
/// Experiment with time-controlled periodic reception.
// 2011-06-24 <jc@wippler.nl> http://opensource.org/licenses/mit-license.php

#include <JeeLib.h>
#include <avr/sleep.h>

struct {
  byte start;   // time at which we started listening for a packet
  byte later;   // how long we had to wait for packet to come in
} payload;

void setup () {
  rf12_initialize(26, RF12_433MHZ, 4);
  Serial.begin(57600);
  Serial.println("Receiver on");
}

void loop () {
  if (rf12_recvDone() && rf12_crc == 0) {
    // process incoming data here
    Serial.println("test");
    if (RF12_WANTS_ACK) {
      payload.later = (byte) millis() - payload.start;
     
      rf12_sendStart(RF12_ACK_REPLY, &payload, sizeof payload);
      rf12_sendWait(1); // don't power down too soon
    }
  }
}

Irgendwie klappts dennoch nicht. Ich dachte, das Setup würde etwas einfacher sein

[Reply #5 on:]

Ich bin einen Schritt weiter. Der MEGA kann vom 328er Signale empfangen. Jetzt muss ich es nur noch auslesen können... Mal schaun

[Reply #6 on:]

Wenns komplett läuft würde mich der Code interessieren. Das Thema steht bei mir ähnlich demnächst an...

[Reply #7 on:]

Versuchs mal mit dem ping-pong-Bsp.

Code:

/// @dir pingPong
/// Demo of a sketch which sends and receives packets.
// 2010-05-17 <jc@wippler.nl> http://opensource.org/licenses/mit-license.php

// with thanks to Peter G for creating a test sketch and pointing out the issue
// see http://news.jeelabs.org/2010/05/20/a-subtle-rf12-detail/

#include <JeeLib.h>

Port leds (1);
MilliTimer sendTimer;
char payload[] = "2650 says: Hello!";
byte needToSend;

char inChar=-1; // Where to store the character read
byte index = 0; // Index into array; where to store the character
static void sendLed (byte on) {
    leds.mode(OUTPUT);
    leds.digiWrite(on);
}

static void receiveLed (byte on) {
    leds.mode2(OUTPUT);
    leds.digiWrite2(!on); // inverse, because LED is tied to VCC
}

void setup () {
    Serial.begin(57600);
    Serial.println(57600);
    Serial.println("Send and Receive");
    rf12_initialize(2, RF12_433MHZ, 212);
}



void loop () {
    if (rf12_recvDone() && rf12_crc == 0) {
        receiveLed(1);
        String result;
        byte bRes;
        Serial.print("OK ");
        for (byte i = 0; i < rf12_len; ++i){
            //Serial.print(rf12_data[i], HEX);
            //inData[i] = rf12_data[i];
            //result += Serial.write(rf12_data[i]);
            Serial.write(rf12_data[i]);
            //bRes += rf12_data[i];
        }
       
        //Serial.print(payload);
        //Comp(inData, sizeof(inData);
        Serial.println();
        delay(100); // otherwise led blinking isn't visible
        receiveLed(0);
    }
   
    if (sendTimer.poll(1000))
        needToSend = 0;

    if (needToSend && rf12_canSend()) {
        needToSend = 0;
        sendLed(1);
        rf12_sendStart(0, payload, sizeof payload);
        delay(100); // otherwise led blinking isn't visible
        sendLed(0);
    }
}

Code:

Serial.write(rf12_data[i]);

gibt den Text wieder, welcher die Gegenstelle sendet. Mit dem normalen PingPong gibt es nur Zahlensalat,..bzw die payload als Bytefolge.