433 Funksteckdose mit RFM69 steuern

[David M. (thenetstriker)]

Ich versuche mit einem RFM69 (Adafruit Featherwing) 433 MHz 
Funksteckdosen zu steuern und auch die Signale der original 
Fernsteuerung empfangen zu können. Ich verwende dazu aktuell die 
RadioHead Library die ich noch etwas modifizieren musste da die Library 
nicht für diese Art Kommunikation ausgelegt ist. Ich verwende aktuell 
den das "Unlimited Length Packet Format" um die Daten zu senden und zu 
empfangen.

Ich habe auch bereis die korrekte Bitrate herausgefunden und auch das 
eine 0 als 1000 und eine 1 als 1110 geschickt wird. Mit diesen 
Informationen habe ich es auch bereits geschafft die Funksteckdose zu 
schalten. Beim Empfang habe ich aber noch Probleme. Aus irgendeinem 
Grund erhalte ich nicht die gleichen Bit's von der original 
Fernbedienung.

Ich habe die Signale von der original Fernbedienung und vom RFM69 mit 
einem HackRF One analysiert und habe im Anhang zwei Screenshots abgelegt 
wo die Signale zu sehen sind. Seltsamerweise ist das erste Bit des RFM69 
immer 1100 statt 1000, aber die Funksteckdose akzeptiert das Signal 
trotzdem. Ausserdem ist der Delay zwischen den Signalen etwas grösser. 
Das liegt wohl auch noch an der RadioHead library die zu lange wartet. 
Aber auch das schein kein Problem für die Funksteckdose zu sein. Hier 
ist mein aktueller Code um das Funksignal zu schicken:

#include <Arduino.h>
#include <SPI.h>
#include <RH_RF69.h>

#define RFM69_CS  14   // "E"
#define RFM69_RST 32   // "D"
#define RFM69_INT 33   // "B"

RH_RF69 rf69(RFM69_CS, RFM69_INT);

#define CONFIG_OOK (RH_RF69_DATAMODUL_DATAMODE_PACKET | RH_RF69_DATAMODUL_MODULATIONTYPE_OOK | RH_RF69_DATAMODUL_MODULATIONSHAPING_OOK_NONE)
#define CONFIG_NOWHITE_NOCRC_FIXED (RH_RF69_PACKETCONFIG1_DCFREE_NONE | RH_RF69_PACKETCONFIG1_ADDRESSFILTERING_NONE)

const uint8_t kbps_msb_3_0_5_5 = 0x28; // 3.055 kbps
const uint8_t kbps_lsb_3_0_5_5 = 0xEB; // 3.055 kbps
const uint8_t bandwidth_1 = 0x88; // Rx Bandwidth = 1kHz.

const uint8_t dataON[] = {
  B10001000, B10001000, B10001000, B10001000, B10001000, B10001110, B10001000, B10001110, B10001110, B10001110, B10001000, B10001110, B10000000, B00000000, B00000000, B00000000,
  };

const uint8_t dataOFF[] = {
  B10001000, B10001000, B10001000, B10001000, B10001000, B10001110, B10001000, B10001110, B10001110, B10001110, B10001110, B10001000, B10000000, B00000000, B00000000, B00000000,
  };

void setup() 
{
  Serial.begin(115200);
  while (!Serial);

  pinMode(RFM69_RST, OUTPUT);

  // manual reset
  digitalWrite(RFM69_RST, HIGH);
  delay(10);
  digitalWrite(RFM69_RST, LOW);
  delay(10);

  if (!rf69.init())
    Serial.println("init failed");

  if (!rf69.setFrequency(433.85))
    Serial.println("setFrequency failed");

  rf69.setTxPower(20, true);

  RH_RF69::ModemConfig config = {
    CONFIG_OOK,                                           ///< Value for register RH_RF69_REG_02_DATAMODUL "ModulationType"
    kbps_msb_3_0_5_5,                                     ///< Value for register RH_RF69_REG_03_BITRATEMSB "Datarate" 20.0
    kbps_lsb_3_0_5_5,                                     ///< Value for register RH_RF69_REG_04_BITRATELSB not used, default value 0x0B
    0x00,                                                 ///< Value for register RH_RF69_REG_05_FDEVMSB "Deviation" not used, default value
    0x52,                                                 ///< Value for register RH_RF69_REG_06_FDEVLSB not used, default value
    bandwidth_1,                                          ///< Value for register RH_RF69_REG_19_RXBW "Bandwidth"
    0x8B,                                                 ///< Value for register RH_RF69_REG_1A_AFCBW "AfcBandwidth" default value
    CONFIG_NOWHITE_NOCRC_FIXED};                          ///< Value for register RH_RF69_REG_37_PACKETCONFIG1

  rf69.setModemRegisters(&config);

  // Disable preamble
  rf69.spiWrite(RH_RF69_REG_2C_PREAMBLEMSB, 0x00);
  rf69.spiWrite(RH_RF69_REG_2D_PREAMBLELSB, 0x00);

  // Disable sync words
  rf69.spiWrite(RH_RF69_REG_2E_SYNCCONFIG, B01000000);

  // Set payload length to our packet size
  rf69.spiWrite(RH_RF69_REG_38_PAYLOADLENGTH, 0);
}

void loop()
{
  rf69.sendRaw(dataON, sizeof(dataON));
  rf69.waitPacketSent();
}

Die SendRaw Funktion habe ich selber in die RadioHead Library eingebaut 
und sieht so aus:

bool RH_RF69::sendRaw(const uint8_t* data, uint8_t len)
{
    if (len > RH_RF69_MAX_MESSAGE_LEN)
  return false;

    waitPacketSent(); // Make sure we dont interrupt an outgoing message
    setModeIdle(); // Prevent RX while filling the fifo

    if (!waitCAD()) 
  return false;  // Check channel activity

    ATOMIC_BLOCK_START;
    digitalWrite(_slaveSelectPin, LOW);
    _spi.transfer(RH_RF69_REG_00_FIFO | RH_RF69_SPI_WRITE_MASK); // Send the start address with the write mask on
    // Now the payload
    while (len--)
  _spi.transfer(*data++);
    digitalWrite(_slaveSelectPin, HIGH);
    ATOMIC_BLOCK_END;

    setModeTx(); // Start the transmitter
    return true;
}

Für den Empfang verwende ich folgend Code im loop:

    setOpMode(RH_RF69_OPMODE_MODE_RX);
    uint8_t buf[sizeof(RH_RF69_MAX_MESSAGE_LEN)]; // RH_RF69_MAX_MESSAGE_LEN
    uint8_t len = sizeof(buf);

    uint8_t readLength = rf69.readFifoTest(buf, len);
    //Serial.print("got reply: ");
    for (int i = 0; i < readLength; i++) {
      if (buf[i] != 255)
        Serial.print(buf[i], BIN);
    }

Die readFifoTest methode habe ich wieder selber in die RadioHead Library 
eingebaut:

uint8_t RH_RF69::readFifoTest(uint8_t* buffer, uint8_t length) {
    uint8_t bufferLength = 0;

    while (length > 0) {
        uint8_t irqflags2 = spiRead(RH_RF69_REG_28_IRQFLAGS2);

        if (irqflags2 & RH_RF69_IRQFLAGS2_FIFONOTEMPTY)
        {
            digitalWrite(_slaveSelectPin, LOW);

            _spi.beginTransaction();
            _spi.transfer(RH_RF69_REG_00_FIFO); // Send the start address with the write mask off

            buffer[bufferLength] = _spi.transfer(0);
            bufferLength++;
            length -= 1;

            _spi.endTransaction();
            digitalWrite(_slaveSelectPin, HIGH);
        }

        YIELD;
    }

    return bufferLength;
}

Hat mir vielleicht jemand einen Tipp was ich hier falsch mache?

[Christian S. (roehrenvorheizer)]

Hallo,


ich möchte mal hier aus meinem virtuellen Elfenbeinturm heraus kund tun, 
was mir einfällt:

Wir haben es wie öfter mal mit einer Frage zu einem gängigen Funkmodul 
zu tun, die auf wenig/gar keine Resonanz stößt. Die Frage ist bereits 
ziemlich ausführlich formuliert und mit Codebeispiel angereichert. 
Zusätzlich wird der Datenstrom gezeigt. Trotzdem hat niemand eine Idee 
dazu.

Ich selbst kann mit dem Arduino-Code nicht viel anfangen, da ich die 
Arduino-Welt nicht kenne. Leider fehlen Kommentare hinter den 
Codezeilen, die anderen verdeutlichen können, was die einzelnen Zeilen 
bewirken sollen. Nützlich wäre vielleicht auch, die eingestellten 
Registerwerte separat binär oder als hex anzugeben, am besten gleich mit 
verbaler Erklärung, was eingestellt wurde. Hilfreich wäre noch eine 
kurze Beschreibung der Funktionsweise, also hier unbegrenzte Paketlänge 
zusammen mit Fifo-Benutzung.

MfG

[Gehirnchirurg (Gast)]

Bei diesen Funkasics die auch OOK können und per Registereinstellungen 
konfiguriert werden hat das bei mir auch nie hingehauen. Schaut man sich 
genauer an was die senden ist es ein Pulsetrain, lauter kleine Pulse, 
die ein HIGH "nachbilden". Manche Empfänger kommen damit nicht zurecht. 
Ich glaube in einem Datenblatt von einem Silabs, TI oder Hope steht das 
auch drinn, dieser OOK Modus in diesen Funkasics ist eher mit Vorsicht 
zu geniesen. Manche haben einen RAW-Modus, der der sich dann wie die 
Primitivmodule verhält, da gab es glaube ich aber auch Einschränkungen, 
dient nur zum Testen nicht zur Datenübertragung.

Mit den Primitivmodulen die nur einen TX-Pin haben den man HIGH und LOW 
schaltet ging es immer auf Anhieb. Die schalten einfach die 
Trägerfreuquenz ein solange der Pin HIGH ist, Pulsetrains gibts dort 
nicht.


Vielleicht hast du das Modul auch nicht sauber konfiguriert, ich bin 
jetzt zu faul nachzuschauen aber manchen haben noch Datawhitening, 
kleben nen CRC automatisch ran, machen Manchester,... Das meiste davon 
ist im OOK-Modus sowieso nicht verfügbar aber schau trtzdem mal ins 
Datenblatt.

Wenn am Anfang das Bit nicht ankommt stimmt evt. was mit dem timing 
nicht oder off-by-one Fehler, hatte ich auch schon.

[Johannes S. (Gast)]

Ich habe sowohl mit RFM12 als auch RFM69 FS20 Code gesendet und 
empfangen, das geht. Beim RFM69 habe ich das über einen Datenpin des 
Moduls gemacht, für nur über SW hatte ich keine Möglichkeit gesehen. 
Bzw. nur wie vom Vorredner genannt diese ähnliche Modulation.
Code für MBed, müsste ich nochmal raussuchen.

[Stefan S. (energizer)]

Hallo David,

ich habe mich mit genau diesem Thema vor einiger Zeit recht intensiv 
befasst; der Empfang solcher Signale klappt gut mit dem RFM69, wenn man 
einige Gegebenheiten beachtet:
- Man muss "oversamplen", d. h. mit deutlich größerer Bitrate abtasten 
so dass die kürzesten Impulse mindestens 4 Bit lang sind. Ich verwende 
20 kbit/s.
- Die Bandbreite sollte relativ groß gewählt werden weil die 
Fernbedienungen in der Frequenz stark schwanken. Ich verwende 300 kHz.
- Der OOK Decoder muss passend parametriert werden. Ich verwende 
Threshtype peak, Threashstep 0,5 dB, und ThreashDec once every 8 chips

Ich empfange durchgehend und suche in den empfangenen Daten nach einer 
ausreichend langen Folge von 0en die den Syncpulse darstellen.

P. S. Das dargestellte Protokoll scheint zu den Logilight oder emylo 
Systemen zu gehören, also Bit0 = 1000, Bit1 = 1110. 24 Bit und ein 
Syncpulse ergeben ein ganzes Frame.

Schöne Grüße
Stefan

[David M. (thenetstriker)]

Danke für die vielen Rückmeldungen. Den CRC check, Datawhitening und 
Machchester habe ich bereits deaktiviert. Daran kann es eigentlich nicht 
liegen. Ich habe nun noch die Bandbreite auf 255 khz erhöht (Scheint das 
maximum zu sein bei OOK) und habe die Threshold decay time auf once 
every 8 chips gestellt. Leider erhalte ich aber immer noch nicht die 
korrekten bytes. Ich habe auch versucht die Bitrate 4 mal höher 
einzustellen, aber leider gibt auch das keine brauchbaren Resultate. 
Hier sind meine aktuellen Registereinstellungen:

00 00
01 04
02 08
03 28
04 EB
05 00
06 52
07 6C
08 76
09 66
0A 41
0B 40
0C 02
0D 92
0E F5
0F 20
10 24
11 7F
12 09
13 1A
14 40
15 B0
16 7B
17 9B
18 08
19 81
1A 8B
1B 43
1C 80
1D 06
1E 10
1F 00
20 00
21 00
22 00
23 02
24 FF
25 00
26 05
27 80
28 00
29 FF
2A 00
2B 00
2C 00
2D 00
2E 40
2F 2D
30 D4
31 00
32 00
33 00
34 00
35 00
36 00
37 00
38 00
39 00
3A 00
3B 00
3C 8F
3D 02
3E 00
3F 00
40 00
41 00
42 00
43 00
44 00
45 00
46 00
47 00
48 00
49 00
4A 00
4B 00
4C 00
4D 00
4E 01
4F 00
58 1B
6F 30
71 00

Die Registereinstellungen können auf dieser Seite übersetzt und geändert 
werden: https://dimhoff.github.io/sx1231_calculator.html
Die Werte können einfach unten in das Textfeld eingegeben werden und 
dann importiert werden. Was könnte ich hier noch anpassen um den Empfang 
zu verbessern?

[Wolle G. (wolleg)]

Christian S. schrieb:
> Leider fehlen Kommentare hinter den  Codezeilen, die anderen verdeutlichen
> können, was die einzelnen Zeilen bewirken sollen.
Sehe ich auch so. (für mich vorzugsweise auf deutsch)
Da ich gerade angefangen habe, mich mit RFM69 zu beschäftigen und zu 
programmieren, bin ich besonders scharf auf Beispiele. RFM69 soll mit µC 
MSP430Fxxxx angesteuert werden.
Vielleicht fällt auch noch für mich etwas ab, falls jemand ein 
funktionstüchtiges Beispiel übrig hat.

[Bernd B. (berbog)]

Hallo Wolle

Bist du mittlerweile fündig geworden auf der Suche nach einem 
brauchbaren Beispiel?
Ich versuche mich auch bisher erfolglos.

Gruß und Danke Bernd

[Peter (Gast)]

Hallo,

bin ebenfalls wieder auf der Suche nach einer Lösung (FHT 868Mhz) 
mittels RFM12 oder besser RFM69. Leider bin ich unwissend in Sachen 
Hochfrequenztechnik.

Finde nur Programme die nicht erklärend sind, selbst RFM12 Programme, 
die nicht funktionieren.

Während die ELV Platine wie RX868- funktioniert und die ganze Etage 
protokolliert, aber sind einfach zu teuer.

Scheinbar haben alle Probleme in "rauer Umgebung" wie Handys usw.... im 
Raum sehr große Probleme.

Währe vielleicht schön, das die Leute bei denen es geklappt hat 
konkreter werden was Sie gemacht haben.

[Karl (Gast)]

Was suchst du denn für eine Lösung ?

[Peter (Gast)]

Hallo,
etwas zu spät gesehen, das Du geantwortet hast.

Ich habe eine scheinbar funktionierende Decodierung des ELV OOK Signals.
Will diese Ventileinstellwerte abfangen um evtl. daraus eine 
Bedarfsregelung der Heizung zu erstellen.

Dies wollte ich jetzt auf RFM12 bzw. evtl. auf RFM69 umsetzen. Dies 
funktioniert nun überhaupt nicht (RFM12).

Ich habe einige Programme gefunden allerdings schon älter, ohne Erfolg. 
Ich weis nicht ob es zwingend notwendig ist, das der Kondensator 4,7n 
auf 150pF geändert werden muss (OOK).

Das empfange Signal hat nichts mit dem erwarteten Signal zutun. Bin da 
ratlos.

Danke