RFM01 & RFM02 - Eigenartiger Empfang

[Raphael S. (stonetronics)]

Hallo liebe uC.net-Gemeinde!

Das ist mein erster post. Ich versuche die Schaltung für die Funkmodule 
RFM01 und RFM02 aus diesem Beitrag 
Beitrag "RFM01 und RFM02" auf einem arduino 
nachzubauen.
Dazu verwende ich eine Arduino Mega (ATMega2560) an dem ich beide Module 
per SPI, Interrupt-Leitungen, etc wie im obigen Post anschließe.

Den konfigurations-code habe ich mit den Datenblättern der 
HopeRF-Website abgeglichen
http://www.hoperf.de/rf/module/fsk/RFM01.htm
http://www.hoperf.de/rf/module/fsk/RFM02.htm

Nun kann ich zwar über das RFM02 etwas senden und das RFM01 empfängt 
auch, jedoch sind die empfangenen Daten nicht entzifferbar.

Ich habe den sender mit einem RTL-SDR im spektraldiagramm nachgemessen 
und etwas empfangen können, allerdings sind meine gnuradio-skills noch 
nicht fortgeschritten genug, um einen funktionierenden BFSK-demodulator 
zu bauen. Bild hierzu folgt.

Hat irgendjemand schon ähnliche probleme mit diesen modulen gehabt?
Wo ist mein Fehler? Es sollte alles richtig konfiguriert sein

Empfangene Daten:

rfm02 sending something
output:
0
0
rfm01 data available: 64 //dieses byte sollte die daten enthalten - keine sinnvollen daten, da das byte sich dauernd änderd bei konstantem input (durchgehend character a geschickt)
rfm01 output:
199|64
0|133
0|135
0|133
0|135
0|133
0|133
0|135
255|255
0|0

mein code:

#include "SPI.h"


unsigned short int spiTransfer16(unsigned char nSEL, unsigned short int a)
{
  unsigned short int ret = 0;
  digitalWrite(nSEL, LOW); //chip select low
  ret = SPI.transfer16(a);
  digitalWrite(nSEL, HIGH); //chip select high
  delay(1); //wait 1 ms before transmitting the next word
  return ret;
}

unsigned char spiTransfer(unsigned char nSEL, unsigned char a)
{
  unsigned char ret = 0;
  digitalWrite(nSEL, LOW); //chip select low
  ret = SPI.transfer(a);
  digitalWrite(nSEL, HIGH); //chip select high
  delayMicroseconds(20); //wait 20us before transmitting the next word
  return ret;
}

class RFM01
{
  private:
    int nSel = 0;
    int nIRQ = 0;

    char receivedChar = '0';
    unsigned short int output[10];

  public:
    RFM01(int nSelPin, int nIRQPin)
    {
      nSel = nSelPin;
      nIRQ = nIRQPin;
    }
    
    void init( void )
    {
      pinMode(nSel, OUTPUT);
      digitalWrite(nSel, HIGH);
      pinMode(nIRQ, INPUT);


      SPI.begin();

      SPI.beginTransaction(SPISettings(140000, MSBFIRST, SPI_MODE0));
      output[0] = spiTransfer16(nSel, 0x0000); //initial transfer -status read
      output[1] = spiTransfer16(nSel, 0x89FB); //config setting - 433MHz, crystal active, 16pF crystal CAP, 134kHz Baseband Bandwidth, module on
      output[2] = spiTransfer16(nSel, 0xA640); //434Mhz center freq
      output[3] = spiTransfer16(nSel, 0xC847); //2.4kbps
      output[4] = spiTransfer16(nSel, 0xC69B); //AFC
      output[5] = spiTransfer16(nSel, 0xC42A); //clock recovery manual ctl, digital filter, DQD = 4
      output[6] = spiTransfer16(nSel, 0xCE84); //use FIFO
      output[7] = spiTransfer16(nSel, 0xCE87); //sync
      output[8] = spiTransfer16(nSel, 0xC081); //activate rx, 0db gain, enable
      SPI.endTransaction();
    }

    bool hasData( void )
    {
      if (!digitalRead(nIRQ))
      {
        return true;
      }

      return false;
    }

    unsigned char read8( void )
    {
      SPI.beginTransaction(SPISettings(140000, MSBFIRST, SPI_MODE0));
      output[0] = spiTransfer16(nSel, 0x0000); //read status byte
      output[1] = spiTransfer(nSel, 0x00); //read input byte
      output[2] = spiTransfer(nSel, 0x00); //read input byte
      output[3] = spiTransfer(nSel, 0x00); //read input byte
      output[4] = spiTransfer(nSel, 0x00); //read input byte
      output[5] = spiTransfer(nSel, 0x00); //read input byte
      output[6] = spiTransfer(nSel, 0x00); //read input byte
      output[7] = spiTransfer(nSel, 0x00); //read input byte
      output[8] = spiTransfer16(nSel, 0xCE84); //use FIFO
      output[9] = spiTransfer16(nSel, 0xCE87); //sync
      SPI.endTransaction();

      receivedChar = (char) output[0];

      return (unsigned char) output[0];
    }

    void putOutOutPut( int s )
    {
      for (int i = 0; i < s; i++)
      {
        Serial.print((output[i]&0xFF00)>>8);
        Serial.print("|");
        Serial.println(output[i]&0x00FF);
      }
    }

    char getReceivedChar( void )
    {
      return receivedChar;
    }
};

class RFM02
{
  private:

    int nSel = 0;
    int nIRQ = 0;
    int FSK = 0;

    unsigned short int output[10]; 
    
  public:

    RFM02(int nSelPin, int nIRQPin, int FSKPin)
    {
      nSel = nSelPin;
      nIRQ = nIRQPin;
      FSK = FSKPin;
    }

    void init( void )
    {
      pinMode(nSel, OUTPUT);
      digitalWrite(nSel, HIGH);
      pinMode(nIRQ, INPUT);
      pinMode(FSK, OUTPUT);
      digitalWrite(FSK, LOW);

      SPI.begin();

      SPI.beginTransaction(SPISettings(140000, MSBFIRST, SPI_MODE0));
      output[0] = spiTransfer16(nSel, 0xCC00); //initial transfer - read status register
      output[1] = spiTransfer16(nSel, 0x8B81); //433MHz Freqency band, clock frequency = 2 MHz, big crystal cap, 
      output[2] = spiTransfer16(nSel, 0xA640); //434Mhz center freq
      output[3] = spiTransfer16(nSel, 0xC823); //data rate = 9578,5 bps
      output[4] = spiTransfer16(nSel, 0xD040); //RATE/2  //measured rate 2.4kbps
      output[5] = spiTransfer16(nSel, 0xC220); //tx bit sync on
      output[6] = spiTransfer16(nSel, 0xC001); //pwer management command
      
      SPI.endTransaction();
    }

    void putByte(unsigned char c)
    {
      unsigned char i = 0;
      for (i = 0; i < 8; i ++)
      {
        while (!digitalRead(nIRQ));
        while (digitalRead(nIRQ));
        if (c & 0x80)
        {
          digitalWrite(FSK, HIGH);
        } else {
          digitalWrite(FSK, LOW);
        }
        c = c<<1;
      }
    }

    void send8(unsigned char c)
    {
      output[0] = spiTransfer16(nSel, 0xC039); //Power mgmt, activate crystal, synthesizer, power amp  
            
      putByte(0xAA); //preamble
      putByte(0xAA); //preamble
      putByte(0xAA); //preamble
      putByte(0x2D); //sync word
      putByte(0xD4); //sync word
      putByte(c);    //data byte
      putByte(c);    //data byte
      putByte(0xAA); //schlusswort
      delayMicroseconds(1); // 1us delay
      output[2] = spiTransfer16(nSel, 0xC001); //deactivate tx
    }

    void putOutOutPut( int s )
    {
      for (int i = 0; i < s; i++)
      {
        Serial.println(output[i]);
      }
    }
};

#define DATASIZE 50

RFM01 rfm01(44, 18);
RFM02 rfm02(45, 19, 43);

char inputData[DATASIZE];
int inputDataIterator = 0;

void setup() {
  delay(200); //rfm modules need at least 150ms on start up before being talked to over spi
  Serial.begin(57600);
  Serial.println("Serial is working");

  Serial.println("init rfm01...");
  rfm01.init();

  Serial.println("output:");
  rfm01.putOutOutPut(9);

  Serial.println("init rfm02...");
  rfm02.init();

  Serial.println("output:");
  rfm01.putOutOutPut(7);

}

void loop() {
  unsigned char input = 0;

  if (rfm01.hasData())
  {
    Serial.print("rfm01 data available: ");
    input = rfm01.read8();
    delay(5);
    Serial.println(input);
    Serial.println("rfm01 output:");
    rfm01.putOutOutPut(10);
    inputData[inputDataIterator] = rfm01.getReceivedChar();
    if ((inputDataIterator++) == DATASIZE)
    {
      inputDataIterator = 0;
      Serial.println("Received Data as string:");
      for (int u = 0; u< DATASIZE; u++)
      {
        Serial.print(inputData[u]);
      }
      Serial.println("");
    }
      
  }

  if (Serial.available())
  {
    Serial.println("rfm02 sending something");
    Serial.read();
    rfm02.send8(127);
    Serial.println("output:");
    rfm02.putOutOutPut(2);
  }

}

[Raphael S. (stonetronics)]

In diesem bild ist das Empfangene Spektrum des RFM02 Senders. Es wurde 
mit einem RTL-SDR und SDR# aufgenommen.