Walka z pilotami - dekodowanie pilota 433MHz

[H1M4W4R1]

Wstęp

Znajomy przyniósł pilot na 433MHz, którego nie mógł doprowadzić do współpracy z rc-switch i stwierdził, że jak będę miał czas to mogę się pobawić. Tak więc minął z rok i znalazła się chwila wolnego czasu...

Wstępna analiza

Pierwszym oczywistym krokiem było określenie czy to na pewno jest pilot na 433 MHz. Bo z doświadczenia wiem, że to co mówi producent często mija się z rzeczywistością.

W ruch poszedł więc SDR# wraz z odbiornikiem RTL-SDR i anteną 315/433MHz z szuflady. Ustawiłem skanowanie w okolice 433MHz i szukałem sygnału, który jest aktywny tylko w momencie gdy kliknę przycisk.

Analiza sygnału radiowego w SDR#

Znalazłem go na 433.94MHz. Jednak czasem można zaufać opisom producentów. Następnym krokiem było szybkie trafienie na właściwą modulację - takie piloty najczęściej używają AM lub FM. W przypadku naszego pacjenta było to AM, które było drugą modulacją na liście.

Jak rozpoznać czy modulacja jest właściwa? Sygnał zmieni się z cyfrowego szumu na wyraźny sygnał binarny. Akurat nagranie poniżej nie jest idealne (widocznie wskaźnik był krzywo ustawiony przy nagrywaniu), ale daje dobry pogląd jak to powinno brzmieć.

Przykład Audio.zip

Dekodowanie sygnałów

Nagranie zostało przeniesione do Audacity i tam przeanalizowane. Sygnał składał się z impulsu synchronizacyjnego oraz 18 bitów. Krótki sygnał to bit zero, a długi to bit jeden.

Podgląd sygnału w Audacity

Spisałem sobie kombinacje bitowe na kartce papieru co potem mnie mocno ugryzło, ale nie uprzedzajmy faktów.

Następnie moduł SYN480R został podłączony do Wemosa D1 R32. Do wyprowadzenia danych wpiąłem się oscyloskopem i byłem wściekły na mieszkanie w bloku… Ilość szumu była taka, że na paśmie 433MHz cały czas coś nadaje… Uroki miasta. Tak więc trzeba było klikać jak najszybciej przyciskiem przy dużym zakresie czasowym oraz zastopować oscyloskop gdzieś w połowie trasy. Na szczęście udało się za pierwszym razem i mogłem odczytać czasy trwania sygnału.

• Impuls synchronizacyjny: 7ms stanu wysokiego, 7ms stanu niskiego.
• Bit wysoki: 1600us stanu wysokiego, 900us  stanu niskiego
• Bit niski: 700us stanu wysokiego, 2850us stanu niskiego

Walka z programem

Tutaj był duży problem. Biblioteka rc-switch za nic nie chciała zareagować na sygnał, więc trzeba było się posłużyć brutalnymi metodami (również znanymi jako przerwania). Na początku zrealizowałem detekcję sygnału synchronizacji, która przebiegła całkiem sprawnie. 

Gorzej było z dekodowaniem sygnałów. O ile posiadałem dane bitowe i czasy dla każdego z przycisków to średnio jedno na pięć przyciśnięć przycisku generowało właściwy kod, który miałem spisany… Przez godzinę głowiłem się co może być nie tak, kiedy wreszcie przypomniałem sobie, że niektóre piloty mają kilka kodów, które przerzucają przy kliknięciu… Miałem takiego pecha, że trafiłem na taki egzemplarz.

Spisałem więc dane odczytane z kilkunastu kliknięć i okazało się, że kody są powiązane między sobą. Są one podzielone na sekcje 6-2-6-2-2 (ilość bitów). Pierwsza i druga 2-bitowa sekcja są zanegowane, więc prawdopodobnie są używane jako sprawdzanie poprawności sygnału (lub jakiś inny magiczny wynalazek. Wszystkie pozostałe sekcje są identyczne.

#include <Arduino.h>

// -------- GPIO & ISR config --------
#define RF_PIN 26
volatile unsigned long lastEdge = 0;

// ring buffer for pulse durations
#define BUF_SIZE 256
volatile uint16_t pulseBuf[BUF_SIZE];
volatile uint8_t  pulseHead = 0;
volatile bool dataReady = false;

// -------- protocol timing (µs) --------
const unsigned long SYNC_MIN = 6500;
const unsigned long SYNC_MAX = 7500;

const unsigned long ONE_H_MIN = 1300;
const unsigned long ONE_H_MAX = 1900;
const unsigned long ONE_L_MIN =  600;
const unsigned long ONE_L_MAX = 1200;

const unsigned long ZERO_H_MIN =  400;
const unsigned long ZERO_H_MAX =  1000;
const unsigned long ZERO_L_MIN = 2550;
const unsigned long ZERO_L_MAX = 3150;

const int BIT_COUNT = 18;

// ----------------------------------------------------------
// INTERRUPT: capture duration since previous edge
// ----------------------------------------------------------
void IRAM_ATTR rf_isr() {
  unsigned long now = micros();
  unsigned long dur = now - lastEdge;
  lastEdge = now;

  pulseBuf[pulseHead++] = (uint16_t)dur;
  if (pulseHead >= BUF_SIZE) pulseHead = 0;

  // mark buffer ready when roughly full packet captured
  if (pulseHead >= BIT_COUNT * 4) dataReady = true;
}

// ----------------------------------------------------------
// Helpers
// ----------------------------------------------------------
inline bool matchSync(unsigned long h, unsigned long l) {
  return (h >= SYNC_MIN && h <= SYNC_MAX &&
          l >= SYNC_MIN && l <= SYNC_MAX);
}

inline bool matchOne(unsigned long h, unsigned long l) {
  return (h >= ONE_H_MIN && h <= ONE_H_MAX &&
          l >= ONE_L_MIN && l <= ONE_L_MAX);
}

inline bool matchZero(unsigned long h, unsigned long l) {
  return (h >= ZERO_H_MIN && h <= ZERO_H_MAX &&
          l >= ZERO_L_MIN && l <= ZERO_L_MAX);
}

// =============================================================
// Decode a frame
// =============================================================
void decodePacket(uint16_t* buf, uint16_t len) {
  // find sync pair
  int start = -1;
  for(int i = start; i <= len; i++)
  {
    if(matchSync(buf[i], buf[i+1]))
    {
      start = i + 2;
      Serial.println("SYNC!");
    }
  }

  // Prevent out of bounds
  if (start < 0) return;
  if (start + BIT_COUNT * 2 > len) return;

  // Decode
  String bits = "";
  for (int p=start; p<start+BIT_COUNT*2; p+=2) {
    unsigned long h = buf[p];
    unsigned long l = buf[p+1];

    if (h > l){
      bits += '1';
    }
    else
    {
      bits += '0';
    }          
  }

  Serial.println("Found signal from remote!");

  Serial.print("Bits: ");
  Serial.println(bits);  
}


// ----------------------------------------------------------
// setup / loop
// ----------------------------------------------------------
void setup() {
  Serial.begin(115200);
  delay(50);

  pinMode(RF_PIN, INPUT);
  attachInterrupt(digitalPinToInterrupt(RF_PIN), rf_isr, CHANGE);
}

void loop() {
  if (!dataReady) return;

  noInterrupts();
  uint16_t localBuf[BUF_SIZE];
  memcpy(localBuf, (const void*)pulseBuf, sizeof(pulseBuf));
  uint16_t len = pulseHead;
  pulseHead = 0;
  dataReady = false;
  interrupts();

  decodePacket(localBuf, len);
}

Zapisałem sobie w notatniku jak obsługiwać ten pilot i mogę go wykorzystać w jakimś przyszłym projekcie, a Wy możecie sami walczyć ze swoimi sztukami.

 

Edytowano 1 stycznia przez H1M4W4R1

[orb777]

@H1M4W4R1, ciekawy temat, fajnie opisane. Pewnie jeszcze go rozwiniesz. Robiłem coś podobnego w formie pilota kopiującego. Szum heterodyny/zbędne sygnały wyciąłem filtrem programowym. U siebie też zauważyłem w pilotach kody, które "pozornie nic nie robią". Pewnie znasz, ale wspomnę o programie "universal radio hacker (urh)". Przyspiesza zbieranie i analizę sygnałów za pomocą rtl-sdr.

Odnośnie częstotliwosci rtl-sdr. Mam v3, obie posiadają tcxo, ale jak położysz dongla np. na zimnym parapecie z kamienia to możesz zauważyć lekkie zmiany we wskazywanej częstotliwości. Testowałem sygnałem ciągłym z nanovna.

Edytowano 2 stycznia przez orb777

[H1M4W4R1]

5 minut temu, orb777 napisał:

Pewnie znasz, ale wspomnę o programie "universal radio hacker (urh)". Przyspiesza zbieranie i analizę sygnałów za pomocą rtl-sdr.

Preferuję GNURadio, ale jakoś średnio mi się chciało bawić  

[orb777]

@H1M4W4R1, spoko, czaję, grunt, że działa. U mnie biblioteki również gubiły się przy kodach przeplatanych/nakładających się i wypadało napisac coś, co znajdzie powtarzające się wzorce z tolerancją czasową. Na początku robiłem jak ty, tj. heterodyna + oscyloskop (lub analizator stanów), ale rtl-sdr + urh ułatwiły sprawę. Zauważyłem, że moduł odbiornika potrzebuje chwili czasu na "dostrojenie się" i nie wychwytuje całego przebiegu sygnału z pilota (pomija fragment z samego początku).