Pages: 1 [2] 3 4 5   Go Down
Author Topic: Tchibo Wetterstation 433 MHz - Dekodierung mal ganz einfach  (Read 19988 times)
0 Members and 1 Guest are viewing this topic.
Cologne
Offline Offline
God Member
*****
Karma: 11
Posts: 505
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Ich habe das oben erwähnte Programm mal für den Zweck der Messung der Implulse angepasst.
Code:
// Das ursprüngliche Programm stammte von
/*
 *  Author..... Walter Anderson
 *  E-mail..... wandrson@walteranderson.us
 * 
 *  Source: http://playground.arduino.cc/Code/InfraredReceivers
 */
#include <avr/interrupt.h>
#include <avr/io.h>

#define TIMER_RESET  TCNT1 = 0
#define SAMPLE_SIZE  128

int IRpin = 2;
unsigned int TimerValue[SAMPLE_SIZE];
char direction[SAMPLE_SIZE];
byte change_count;
long time;

void setup() {
  Serial.begin(115200);
  Serial.println("Analyze IR Remote");
  TCCR1A = 0x00;          // COM1A1=0, COM1A0=0 => Disconnect Pin OC1 from Timer/Counter 1 -- PWM11=0,PWM10=0 => PWM Operation disabled
  // ICNC1=0 => Capture Noise Canceler disabled -- ICES1=0 => Input Capture Edge Select (not used) -- CTC1=0 => Clear Timer/Counter 1 on Compare/Match
  // CS12=0 CS11=1 CS10=1 => Set prescaler to clock/64
  TCCR1B = 0x03;          // 16MHz clock with prescaler means TCNT1 increments every 4uS
  // ICIE1=0 => Timer/Counter 1, Input Capture Interrupt Enable -- OCIE1A=0 => Output Compare A Match Interrupt Enable -- OCIE1B=0 => Output Compare B Match Interrupt Enable
  // TOIE1=0 => Timer 1 Overflow Interrupt Enable
  TIMSK1 = 0x00;         
  pinMode(IRpin, INPUT);
}

void loop()
{
  Serial.println("Waiting...");
  change_count = 0;
  while(digitalRead(IRpin) == LOW) {}                                 
  TIMER_RESET;
  TimerValue[change_count] = TCNT1;
  direction[change_count++] = '1';
  while (change_count < SAMPLE_SIZE) {
    if (direction[change_count-1] == '0') {
      while(digitalRead(IRpin) == LOW) {}
      TimerValue[change_count] = TCNT1;
      direction[change_count++] = '1';
  TIMER_RESET;
    } else {
      while(digitalRead(IRpin) == HIGH) {}
      TimerValue[change_count] = TCNT1;
      direction[change_count++] = '0';
  TIMER_RESET;
    }
  }
  Serial.println("Bit stream detected!");
  change_count = 1;
  time = (long) TimerValue[change_count] * 4;
  while (change_count < SAMPLE_SIZE) {
    time = (long) TimerValue[change_count] * 4;
    Serial.print(time);
    Serial.print("\t");
    Serial.println(direction[change_count-1]);   
    change_count++;
  }
  Serial.println("Bit stream end!");
  delay(2000);
}
Wenn man Glück hat und einen gültigen Datenstrom einfangen kann, sieht das ganz gut aus. Allerdings kommt wie bereits schon gesagt auch viel Müll an. Hier mal ein gutes Beispiel.
Code:
Analyze IR Remote
Waiting...
Bit stream detected!
28 1
189448 0
12 1
240792 0
4 1
176688 0
12 1
122560 0
164 1
8112 0
152 1
1060 0
148 1
1060 0
148 1
2084 0
152 1
1052 0
156 1
1060 0
148 1
2084 0
152 1
1064 0
144 1
1064 0
148 1
1060 0
148 1
1068 0
136 1
1064 0
152 1
1056 0
156 1
1064 0
136 1
1064 0
140 1
1068 0
136 1
1072 0
144 1
1064 0
148 1
2096 0
144 1
1064 0
140 1
1068 0
144 1
2088 0
144 1
2088 0
152 1
1060 0
140 1
1072 0
140 1
2096 0
140 1
2108 0
136 1
2088 0
148 1
1060 0
148 1
2096 0
140 1
2096 0
140 1
2092 0
148 1
2092 0
144 1
2096 0
148 1
2092 0
148 1
2092 0
144 1
1072 0
136 1
8120 0
144 1
1064 0
140 1
1076 0
136 1
2088 0
148 1
1068 0
136 1
1060 0
148 1
2088 0
144 1
1064 0
140 1
1072 0
148 1
1064 0
148 1
1064 0
140 1
1068 0
128 1
1068 0
140 1
1064 0
148 1
1064 0
144 1
1072 0
136 1
1068 0
136 1
1084 0
132 1
2100 0
128 1
1068 0
140 1
1068 0
136 1
2108 0
132 1

In Excel oder LibreOffice Calc kann man dann die Häufigkeit des Vorkommens ermitteln und daraus die Entscheidungsschwellen für die Erkennung ableiten.
Die HIGH Pegel zwischen den Datenbits sind zwischen 136 und 148us
der Synchronisierungsimpuls ist 8120us
die "0" Datenbits entsprechen 1064us
die "1" Bits entsprechen 2090us   (alles ca. Werte)
Logged

Germany S-H
Offline Offline
Faraday Member
**
Karma: 146
Posts: 3032
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Wenn man Glück hat und einen gültigen Datenstrom einfangen kann, sieht das ganz gut aus. Allerdings kommt wie bereits schon gesagt auch viel Müll an.

Ich glaube, ich möchte zur Vorab-Analyse von Wettersensoren lieber etwas, das mir die gültigen Datenströme automatisch einfängt und dabei nur möglichst wenig Datenmüll ausgibt.

Im besten Fall sollen nur die Wettersensoren selbst, eventuell Fragmente von den Wettersensoren aus der Nachbarschaft, die nur bruchstückhaft empfangen werden weil sie eigentlich außer Reichweite sind, und nur ganz wenig Datenmüll empfangen werden.

Und es soll rein mit Arduino funktionieren, ohne Umweg über Soundkarte oder externe Programme.

Mal schauen, was ich mir dazu selbst programmieren kann.
Logged

Cologne
Offline Offline
God Member
*****
Karma: 11
Posts: 505
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Mal schauen, was ich mir dazu selbst programmieren kann.

Super, ich bin sehr gespannt!
Logged

Germany S-H
Offline Offline
Faraday Member
**
Karma: 146
Posts: 3032
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Die HIGH Pegel zwischen den Datenbits sind zwischen 136 und 148us
der Synchronisierungsimpuls ist 8120us
die "0" Datenbits entsprechen 1064us
die "1" Bits entsprechen 2090us   (alles ca. Werte)

So, ich habe nun nochmal etwas an den Datentelegrammen verschiedener 433 MHz Sensoren geforscht und mein Vorauswertungsprogramm für Datenpakete zeigt erste Zuckungen.

Meine Sensoren liefern allesamt längere Impulse als Dein Tchibo-Sensor, die Werte liegen mehr bei:
HIGH Pegel zwischen den Bits: 475 us
Startbit/Sync bei ca. 9000 us
die "0" Datenbits entsprechen 2000us
die "1" Bits entsprechen 4000us

Die High-Pegel von "Datenmüll" scheinen sehr oft bei weniger als 50 us zu liegen.

Ich glaube, da werde ich mir mal ein paar plausible Grenzwerte setzen, z.B.:
HIGH Pegel zwischen den Bits: mindestens 50 us oder länger
Startbit mindestens 5000 us oder länger
"0" Datenbits mindestens 500 us oder länger
"1" Bits länger als "0" Bits
Anzahl der Datenbits: 20 oder mehr
Und dann versuchen, was dann noch übrig bleibt an Bits einigermaßen vernünftig aus dem Äther zu fischen und als "Vorauswertung" auszugeben.

Merkwürdigerweise scheine ich verschiedene Sensoren zu haben, die ziemlich ähnliche aber trotzdem verschiedene Protokolle aussenden (identische Bit-Längen und 36-Bit Datenpakete), und trotzdem weiß die  zum Sensor gehörende Basisstation, welche 36 Bits zu ihr gehören und zeigt korrekt an. Das müssen die Basisstationen dann wohl anhand von "Stationsnummern" und "Prüfsummen" unterscheiden können, welche Daten für sie bestimmt sind - und welche nicht.

Nachtrag: Ich werde es auch gleich noch kompatibel zur Erkennung von Funktelegrammen machen, die von Fernbedienungen für Funksteckdosen ausgesendet werden. Die Bitfolgen für die Steuerung von Funksteckdosen sind meisten wesentlich kürzer als die von Wettersensoren. Hier getestet mehr bei 20 Bit (Funksteckdose) statt 36 Bit (Funk-Thermometer). Außerdem ist das Startbit für die Funksteckdosen unheimlich lang: 80000 us. Das ist länger als es in einen Integer hineinpasst, da werde ich mir noch etwas einfallen lassen. Und den Sketch dann mal posten.
« Last Edit: December 18, 2012, 07:14:01 am by jurs » Logged

Germany S-H
Offline Offline
Faraday Member
**
Karma: 146
Posts: 3032
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

So ein Mist, jetzt wollte ich meinen Funkanalyes-Sketch für 433MHz-Funkgerätschaften wie handelsübliche Funk-Thermometer und Funk-Steckdosen posten, schreibe noch sehr ausführlichen Text dazu, Anwendung, Funktionsweise, Hintergründe, und dann meldet das Forum beim Posten des vollständig ausgearbeiteten Beitrags einen Fehler: Kompletter Beitrag weg!

Jetzt poste ich einfach nur mal den Code des Sketches.
Code:
/*
  Sketch zur Vorab-Analyse unbekannter 433-MHZ-Wettersensoren
  und Fernbedienungen von 433MHz-Funksteckdosen
  Inspiriert durch Beiträge im Arduino-Forum:
  http://arduino.cc/forum/index.php/topic,119739.0.html
  http://arduino.cc/forum/index.php/topic,136836.0.html
 
  Hardware:
  1. Arduino-Board mit 433 MHz Regenerativempfänger für ASK/OOK,
  angeschlossen an einem interruptfähigen Pin.
  2. Funksensor entweder eines 433 MHz Funkthermometers
  oder Funk-Wetterstation oder Steckdosen-Funkfernbedienung
 
  Analysiert werden können Sensoren mit folgendem Funkprotokoll:
  - extra langes Startbit (extra langer LOW Pulse am Receiver)
  - langes 1-Datenbit  (langer LOW Pulse am Receiver)
  - kurzes 0-Datenbit  (kurzer LOW Pulse am Receiver)
  - sehr kurze Trenn-Impulse zwischen den Datenbits (sehr kurze HIGH-Impulse am Receiver)
  - 20 bis 50 Datenbits pro Datenpaket
  Diese Art Funkprotokoll trifft auf die meisten billigen 433 MHZ
  Funkthermometer, Funk-Wetterstationen und Funk-Steckdosen zu.
 
  Ausgabe ueber den seriellen Monitor
  Je erkanntem Datenpaket am Receiver wird ausgegeben:
  - Länge des Startbits (Mikrosekunden LOW) und des nachfolgenden HIGH-Impulses
  - Anzahl der erkannten Datenbits im Datenpaket
  - Länge aller erkannten Datenbits (Mikrosekunden LOW)
  - Länge der zwischen den Datenbits erkannten Pausen (Mikrosekunden HIGH)
  - die als 0/1-Bitstrom decodierten Datenbits des Datenpakets
 
  Nur Vorab-Analyse des Timings im Funkprotokoll!
  In einem weiteren Schritt muss dann die Bedeutung der Bits
  und die Umsetzung in Messwerte erst noch detalliert decodiert werden,
  dieser Sketch erkennt nur das Timing und die Groesse der Datenpakete!
*/

// connect data pin of rx433 module to a pin that can handle hardware interrupts
// with an Arduino UNO this is digital I/O pin 2 or 3 only
#define RX433DATAPIN 2

// hardware interrupt connected to the pin
// with Arduino UNO interrupt-0 belongs to pin-2, interrupt-1 to pin-3
#define RX433INTERRUPT 0

// Set speed of serial in Arduino IDE to the following value
#define SERIALSPEED 115200

// Now make some suggestions about pulse lengths that may be detected
// minimum duration (microseconds) of the start pulse
#define MINSTARTPULSE 4500

// minimum duration (microseconds) of a short bit pulse
#define MINBITPULSE 450

// minimum duration (microseconds) of a HIGH pulse between valid bits
#define MINHITIME 50

// variance between pulses that should have the same duration
#define PULSEVARIANCE 250

// minimum count of data bit pulses following the start pulse
#define MINPULSECOUNT 20

// maximum count of data bit pulses following the start pulse
#define MAXPULSECOUNT 50

// buffer sizes for buffering pulses in the interrupt handler
#define PBSIZE 216

void setup()
{
  Serial.begin(115200);
  Serial.println();
  Serial.println("Start!");
  pinMode(RX433DATAPIN, INPUT);
  attachInterrupt(RX433INTERRUPT, rx433Handler, CHANGE);
}

volatile unsigned int pulsbuf[PBSIZE]; // ring buffer storing LOW pulse lengths
volatile unsigned int hibuf[PBSIZE]; // ring buffer storing HIGH pulse lengths
unsigned int validpulsbuf[MAXPULSECOUNT]; // linear buffer storing valid LOW pulses
unsigned int validhibuf[MAXPULSECOUNT];  // linear buffer storing valid HIGH pulses

volatile byte pbread,pbwrite;  // read and write index into ring buffer

void rx433Handler()
{
  static long rx433LineUp, rx433LineDown;
  long LowVal, HighVal;
  int rx433State = digitalRead(RX433DATAPIN); // current pin state
  if (rx433State) // pin is now HIGH
  {
    rx433LineUp=micros(); // line went HIGH after being LOW at this time
    LowVal=rx433LineUp - rx433LineDown; // calculate the LOW pulse time
    if (LowVal>MINBITPULSE)
    { // store pulse in ring buffer only if duration is longer than MINBITPULSE
      // To be able to store startpulses of more than Maxint duration, we dont't store the actual time,
     // but we store  MINSTARTPULSE+LowVal/10, be sure to calculate back showing the startpulse length!
      if (LowVal>MINSTARTPULSE) LowVal=MINSTARTPULSE+LowVal/10; // we will store this as unsigned int, so do range checking

      pulsbuf[pbwrite]=LowVal; // store the LOW pulse length
      pbwrite++;  // advance write pointer in ringbuffer
      if (pbwrite>=PBSIZE) pbwrite=0; // ring buffer is at its end
    } 
  }
  else
  {
    rx433LineDown=micros(); // line went LOW after being HIGH
    HighVal=rx433LineDown - rx433LineUp; // calculate the HIGH pulse time
    if (HighVal>31999) HighVal=31999; // we will store this as unsigned int
    hibuf[pbwrite]=HighVal; // store the HIGH pulse length
  }
}


boolean counting;
byte i,counter;
int startBitDurationL,startBitDurationH,shortBitDuration,longBitDuration;

void showBuffer()
// this function will show the results on the serial monitor
// output will be shown if more bits than MINPULSECOUNT have been collected
{
  long sum;
  int avg;
  sum=0;
  if (counter>=MINPULSECOUNT)
  { // only show buffer contents if it has enough bits in it
    Serial.println();
    Serial.print("Start Bit L: "); Serial.print((startBitDurationL-MINSTARTPULSE)*10L);
    Serial.print("   H: ");Serial.println(startBitDurationH);
    Serial.print("Data Bits: ");Serial.println(counter);
    Serial.print("L: ");
    for (i=0;i<counter;i++)
    {
      Serial.print(validpulsbuf[i]);Serial.print(" ");
      sum+=validpulsbuf[i];
    }
    Serial.println();

    Serial.print("H: ");
    for (i=0;i<counter;i++)
    {
      Serial.print(validhibuf[i]);Serial.print(" ");
    }
    Serial.println();

    avg=sum/counter; // calculate the average pulse length
    // then assume that 0-bits are shorter than avg, 1-bits are longer than avg
    for (i=0;i<counter;i++)
    {
      if (validpulsbuf[i]<avg) Serial.print('0'); else Serial.print('1');
    }
    Serial.println();
 
  }
  counting=false;
  counter=0;
}
 
void loop()
{
  long lowtime, hitime;
  if (pbread!=pbwrite) // check for data in ring buffer
  {
    lowtime=pulsbuf[pbread]; // read data from ring buffer
    hitime=hibuf[pbread];
    cli(); // Interrupts off while changing the read pointer for the ringbuffer
    pbread++;
    if (pbread>=PBSIZE) pbread=0;
    sei(); // Interrupts on again
    if (lowtime>MINSTARTPULSE) // we found a valid startbit!
    {
      if (counting) showBuffer(); // new buffer starts while old is still counting, show it first     
      startBitDurationL=lowtime;
      startBitDurationH=hitime;
      counting=true;     // then start collecting bits
      counter=0;         // no data bits yet
    }
    else if (counting && (counter==0)) // we now see the first data bit
    { // this may be a 0-bit or a 1-bit, so make some assumption about max/min lengths of data bits that will follow
      shortBitDuration=lowtime/2;
      if (shortBitDuration<MINBITPULSE+PULSEVARIANCE)
        shortBitDuration=MINBITPULSE;
      else 
        shortBitDuration-=PULSEVARIANCE;
      longBitDuration=lowtime*2+PULSEVARIANCE;
      validpulsbuf[counter]=lowtime;
      validhibuf[counter]=hitime;
      counter++;
    }
    else if (counting&&(lowtime>shortBitDuration)&&(lowtime<longBitDuration))
    {
      validpulsbuf[counter]=lowtime;
      validhibuf[counter]=hitime;
      counter++;
      if ((counter==MAXPULSECOUNT) || (hitime<MINHITIME))
      {
        showBuffer();
      } 
    }
    else // Low Pulse is too short
    {
      if (counting) showBuffer();
      counting=false;
      counter=0;
    } 
  }
}

Ich habe jetzt keine Lust mehr, da nochmal zwanzig Minuten lang was zu schreiben und dann frisst das Forum den Text auf.
:-(

Wer Fragen hat, kann ja fragen.
Feedback erwünscht!
Logged

Cologne
Offline Offline
God Member
*****
Karma: 11
Posts: 505
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Hallo jurs,
super ! Musste ich natürlich direkt mit meinem Sensor ausprobieren. Hier die ersten Datensequenzen, wie sie auf dem seriellen Monitor ausgegeben werden. Hat auf Anhieb geklappt.
Code:
Start!

Start Bit L: 8030   H: 208
Data Bits: 36
L: 1012 1012 2008 2016 2024 2016 1012 2016 1004 1012 1008 1016 1004 1012 1000 1012 1000 2028 996 1016 2020 1008 2016 2020 1008 1012 1012 1004 1020 2012 1012 996 1020 2016 2012 2016
H: 188 180 188 184 184 180 184 184 180 184 184 184 184 180 184 184 184 188 184 180 184 188 184 176 184 180 184 180 180 184 184 184 184 184 180 184
001111010000000001001011000001000111

Start Bit L: 8070   H: 184
Data Bits: 36
L: 1012 996 2016 2028 2012 2028 1020 2016 1020 1020 1020 1020 1016 1020 1016 1012 1008 2024 1012 1012 2036 1020 2016 2012 1020 996 1012 1012 1008 2016 1012 1012 1004 2020 2016 2028
H: 180 184 184 184 180 184 168 172 192 172 168 172 172 172 176 180 184 180 176 180 172 172 172 184 184 184 184 184 184 176 184 184 184 180 180 184
001111010000000001001011000001000111

Start Bit L: 8060   H: 180
Data Bits: 36
L: 1012 1008 2012 2020 2020 2020 1012 2024 1012 1016 1012 1008 1024 1004 1012 1016 1004 2024 1012 1016 2024 1008 2028 2016 1004 1012 1016 1000 1020 2012 1000 1012 1016 2012 2012 2012
H: 184 184 188 184 180 180 184 180 176 176 180 180 172 180 180 180 184 180 176 180 180 184 172 184 184 184 180 180 180 184 184 184 184 188 184 188
001111010000000001001011000001000111
000001000111 Temperatur 7.1
01001011 Feuchte 75%
Die Daten meiner Fernbedienung für Funksteckdosen werden allerdings nicht dekodiert - die Anzeige bleibt leer.
Logged

Offline Offline
Newbie
*
Karma: 0
Posts: 28
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Die Daten meiner Fernbedienung für Funksteckdosen werden allerdings nicht dekodiert - die Anzeige bleibt leer.

Um Funksteckdosen auszulesen und anzustreuern nutze ich immer RCSwitch (http://code.google.com/p/rc-switch/)
Da kommt dann sowas raus http://www.the-intruder.net/funksteckdosen-von-rev-uber-arduino-ansteuern/
Klappt bis jetzt immer! smiley-wink
« Last Edit: December 18, 2012, 01:49:10 pm by Shojo » Logged

Germany S-H
Offline Offline
Faraday Member
**
Karma: 146
Posts: 3032
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Hallo jurs,
super ! Musste ich natürlich direkt mit meinem Sensor ausprobieren. Hier die ersten Datensequenzen, wie sie auf dem seriellen Monitor ausgegeben werden. Hat auf Anhieb geklappt.

So dachte ich mir das, dass es eben möglichst universell funktioniert und Daten verschiedener Sensoren zur Anzeige bringt.

Danke für die Rückmeldung!

Die Daten meiner Fernbedienung für Funksteckdosen werden allerdings nicht dekodiert - die Anzeige bleibt leer.

Hast Du geprüft, ob die Fernbedienung auch auf 433 MHz sendet?

Hm, also bei mir funktioniert es mit einer Fernbedienung für ein "Quigg" Funksteckdosen-Set, und danach habe ich die Variable für die untere Datenbitzahl auf 20 gesetzt. Möglicherweise gibt es Funksteckdosen, die weniger als 20 Bit senden. Vielleicht mal probieren:
#define MINPULSECOUNT 14
oder eine andere Zahl unter 20. Da Funksteckdosen nur ein/aus Befehle erhalten könnte es sein, dass es vielleicht auch bei einem Hersteller weniger als 20 übertragene Datenbits sind.

Wie teuer waren die Funksteckdosen? Wenn sie überdurchschnittlich viel gekostet haben, bestünde auf 433 MHz auch die Möglichkeit, dass sie ihr Signal mit Frequenzmodulation statt mit Amplitudenmodulation modulieren. In dem Fall würde man zum Empfangen andere Empfänger benötigen (FM Receiver). Und auch mit Amplitudenmodulation sind andere Übertragungsverfahren denkbar, die ohne das extralange Startbit im Funkprotokoll auskommen, da müßte mein Sketch dann ebenfalls passen.

Ist vielleicht irgendein Hersteller erkennbar, der Deine Funksteckdosen produziert hat?
(Manchmal kann man Details dann im Internet googeln.)

Um Funksteckdosen auszulesen und anzustreuern nutze ich immer RCSwitch (http://code.google.com/p/rc-switch/)
Da kommt dann sowas raus http://www.the-intruder.net/funksteckdosen-von-rev-uber-arduino-ansteuern/
Klappt bis jetzt immer! smiley-wink

REV-Funksteckdosen scheinen das Nexa-Protokoll zu verwenden, das hier dargestellt wird:
http://svn.telldus.com/svn/rf_ctrl/nexa_2_6_driver/trunk/NexaProtocol.txt

Dieses Protokoll kann von meinem Sketch gleich aus mehreren Gründen momentan nicht erkannt werden:
a) Das Protokoll startet nicht mit einem besonders langen LOW Impuls als Startbit
b) Die kürzesten LOW-Impulse im Protokoll sind nur 350 us lang, ich gehe standardmäßig von mindestens 450 us Bitdauer aus
#define MINBITPULSE 450

Mit einigen Änderungen müßte es machbar sein, auch die REV-Datenpakete irgendwie einzufangen. Die haben zwar keinen extralangen LOW-Impuls am Anfang, dafür aber einen extralangen LOW-Impuls am Ende des Datenpakets. Da die Datenpakete viermal wiederholt werden, könnte man so den Sync-Impuls am Ende des ersten Pakets als Startbit des zweiten Pakets auffassen. So bekäme man dann zwar nur maximal 3 der 4 gesendeten Pakete eingefangen, aber immerhin sollte es möglich sein.

Leider habe ich keine Möglichkeiten zum Testen, wenn ich die notwendigen Änderungen einbauen würde.

erni-berni, sind Deines vielleicht REV-Funksteckdosen (oder kompatible wie Nexa, Proove oder ARC Technology)?
« Last Edit: December 18, 2012, 03:14:28 pm by jurs » Logged

Cologne
Offline Offline
God Member
*****
Karma: 11
Posts: 505
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Hallo jurs,
das Thema Funksteckdosen lässt sich abkürzen. Meine sind von Bahr und waren sehr günstig (Praktiker Angebot 4,99 für 3 Stück !!), Hersteller ELRO und 433 MHz. Das Protokoll entspricht dem PT2262 Protokoll, das sui in seiner Library dekodiert (http://blog.sui.li/2011/04/12/low-cost-funksteckdosen-arduino/). Die Library wird ja auch erwähnt.
Dieses Protokoll dieser Steckdosen arbeitet vollkommen anders als die Sensoren.
Du müsstest also den Dekodier-Algorithmus der RCSwitch Lib in dein Programm einbauen.
Logged

Germany S-H
Offline Offline
Faraday Member
**
Karma: 146
Posts: 3032
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

das Thema Funksteckdosen lässt sich abkürzen. Meine sind von Bahr und waren sehr günstig (Praktiker Angebot 4,99 für 3 Stück !!), Hersteller ELRO und 433 MHz. Das Protokoll entspricht dem PT2262 Protokoll, das sui in seiner Library dekodiert (http://blog.sui.li/2011/04/12/low-cost-funksteckdosen-arduino/).

OK, das ist haargenau dasselbe wie das von mir ein Posting darüber verlinkte Nexa-Protokoll, das ein Hersteller Taiwan verwendet und das offensichtlich in ganz vielen Funksteckdosen weltweit zum Einsatz kommt, auf die vom taiwanesischen Hersteller ganz unterschiedliche Handelsmarken draufgepinselt werden.

Dieses Protokoll dieser Steckdosen arbeitet vollkommen anders als die Sensoren.

Ja, die Funk-Wettersensoren senden eine einfache Bitlängencodierung, d.h. die Länge eines einzelnen Bits entscheidet, ob es ein 0-Bit oder ein 1-Bit ist, und zwar ist das Bit immer nur durch die Länge der LOW-Zeit zwischen zwei HIGH-Impulsen bestimmt.

Im Nexa-Protokoll für die/viele Funksteckdosen sind es dagegen nicht einzelne High- oder Low-Impulse, in deren Dauer das Bit steckt, sondern jedes Bit wird mit zwei High- und zwei Low-Impulsen übertragen, insgesamt vier Flankenwechsel für ein Bit.

Du müsstest also den Dekodier-Algorithmus der RCSwitch Lib in dein Programm einbauen.

Nö, das soll ja nur ein Vorab-Analyseprogramm sein. Das soll nur generell ermitteln, was so an 433MHz Datenpaketen in der Luft unterwegs ist. Und zwar um das Timing der Bits unbekannter Sensoren herauszubekommen.

Bei den Funksteckdosen mit Nexa, REV, Proove, ARC-Technology, ELRO, PT2262 braucht man die Timings der Datenpakete ja gar nicht mehr herauszufinden: Die werden/wurden ja überhaupt nur mit zwei Timings hergestellt: Früher mit 650 us, heute mit 350 us Periodendauer T. Das sind dann ja eigentlich keine "unbekannten Sensoren" (auch wenn ein unbekannter Name draufsteht), sondern das Timing ist bekannt und welche Library man zur Dekodierung ansetzen kann.

Mal schauen, wenn ich beim Praktiker/Max Bahr mal günstig eine dieser Funksteckdosen bekommen kann, ob ich das Analyse-Programm dann nicht wenigstens noch so weit aufbohre, dass es anzeigen kann:
- Funksteckdosen-Datenpaket erkannt
Logged

Germany, BW
Offline Offline
Sr. Member
****
Karma: 7
Posts: 302
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Hallo ihr Code- Experten!

Bin seit längerer Zeit beim Auswerten meiner 433MHz Temp-Sensoren mit dem RFM12 (OOK).
Das Erkennen der drei unterschiedlichen Typen klappt hervorragend.

Der Empfänger schnappt aber auch noch andere Signale auf, an denen ich mich jetzt auch noch üben will.
Ist in dem Bild die Manchester-Codierung zu sehen? Vielleicht sieht es einer gleich und ich kann mir die Knobelei sparen...

Code:
1120
-804
1164
-788
1104
-332
632
-844
620
-328
1176
-804
1164
-304
612
-360
616
-348
628
-848
604
-360
-356
1152
-816
604
-328
-316
604
-872
1108
-832
604
-356
632
-344
1148
-804
632
-316
632
-360
1148
-300
644
-848
1136
-804
1104
-328
632
-360
632
-328
648
-832
632
-316
660
-328
1148
-304
632
-344
632
-344
616
-360
616
-360
616
-864
1108
-840
1120
-820
1104
-328
620
-356
604
-372
632
-852
600
-356
632
-332
1120
-344
632
-344
604
-372
588
-388
616
-344
632
-852
1128
-820
600
-348
660
-316
632
-328
644
-348
616
-344
660
-316
644
-332
632
-344
616
-360
616
-360
632
-344
620
-340
632
-344
620
-356
620
-356
604
-376
616
-344
644
-332
616
-360
616
-360
616
-344
632
-360
620
-324
648
-344
632
-328
632
-360
616
-344
632
-344
620
-372
632
-328
632
-344
648
-316
632
-344
616
-372
1108
-860
1104
-320
644
-328
648
-332
644
-832
632
-328
616
-348
1148
-832
1120
-816
616
-332
632
-344
632
-344
1148
-300
664
-828
576
10236
1076
-832
1148
-804
1120
-316
616
-360
632
-848
616
-344
1176
-776
616
-344
1148
-304
644
-332
632
-344
644
-832
604
-360
652
-324
1132
-832
604
-344
1148
-300
632
1160
-780
612
-344
620
-356
1120
-832
620
-344
632
-356
604
-360
1132
-832
1096
-844
1120
-332
600
-360
644
-332
628
-864
0
-360
616
-364
1128
-316
616
-360
660
-300
648
-344
632
-328
620
-872
1120
-820
1132
-804
1148
-304
600
-376
616
-364
628
-860
604
-344
616
-348
1132
-312
632
-360
632
-344
604
-372
588
-380
596
-876
1120
-816
604
-360
644
-316
632
-360
616
-360
644
-332
616
-360
620
-356
616
-360
616
-344
632
-344
616
-348
616
-372
588
-372
632
-348
628
-344
620
-356
620
-344
644
-332
616
-360
632
-344
616
-360
632
-344
632
-328
652
-312
644
-344
632
-344
632
-332
600
-376
628
-360
616
-348
616
-360
628
-332
648
-328
632
-348
1160
-804
1116
-332
616
-360
604
-356
632
-860
576
-372
1148
-304
644
-848
588
-360
1104
-860
1108
-328
648
-832
600
-344
632
-344
648
10652
1104
-820
1132
-804
1148
-300
652
-312
624
-868
588
-360
1164
-800
640
-308
1148
-316
620
-356
620
-356
620
-860
588
-360
628
-348
1148
-816
604
-360
1132
-316
632
-848
1148
-804
600
-344
648
-328
1164
-804
604
-356
632
-332
1148
-816
604
-360
1148
-816
1120
-316
632
-344
616
-360
660
-820
600
-360
616
-344
1152
-312
648
-328
620
-356
620
-344
632
-356
604
-860
1120
-832
1120
-820
1120
-328
632
-344
616
-348
632
-860
588
-360
616
-360
1148
-284
648
-344
616
-360
632
-344
644
-332
632
-844
1120
-820
604
-356
632
-332
644
-344
620
-344
644
-332
632
-344
648
-328
600
-360
616
-360
632
-360
616
-344
644
-332
604
-372
616
-348
628
-344
620
-356
620
-372
604
-356
620
-344
616
-372
608
-356
632
-344
632
-344
632
-344
632
-328
632
-344
616
-376
588
-372
616
-360
616
-360
616
-344
632
-344
648
-328
620
-344
1164
-816
1136
-300
632
-344
616
-360
616
-860
604
-344
648
-328
632
-332
660
-328
-316
616
-876
588
-360
1148
-316
628
-836
600
-376
616


* Sensor2.png (17.27 KB, 1748x436 - viewed 129 times.)
« Last Edit: February 27, 2013, 09:20:35 am by mde110 » Logged

Germany S-H
Offline Offline
Faraday Member
**
Karma: 146
Posts: 3032
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Ist in dem Bild die Manchester-Codierung zu sehen?

Auf jeden Fall ist es keine einfache Bitbreitencodierung.

Aber eine typische Manchestercodierung ist es auch nicht. Bei einem typischen Manchestercode hast Du zwei verschiedene High-Längen und zwei verschiedene Low-Längen, aber diese sind jeweils gleich.

Du hast zwar auch je zwei verschiedene High-Längen und zwei verschiedene Low-Längen, aber diese sind jeweils verschieden lang.

High: ca. 1100 und ca. 630
Low: ca. 820 und ca. 330

In der Summe scheinen der lange High-Impuls und der kurze Low-Impuls sowie der kurze High-Impuls und der lange Low-Impuls den gleichen Wert zu ergeben:
1100 + 330 = 1430
630 + 820 = 1450

Aber es ist ja nicht so, daß immer ein kurzer Low-Impuls auf einen langen High-Impuls folgt und umgekehrt.
Ich habe keine Ahnung, was das für eine Codierung sein könnte.
Logged

Offline Offline
Newbie
*
Karma: 0
Posts: 15
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Hi zusammen,

ich finde euren Artikel sehr interessant. Welchen Sender und Empfänger habt ihr benutzt?
Ich habe z.b. so einen gefunden:
http://www.amazon.de/433Mhz-Transmitter-Module-Receiver-Arduino/dp/B00BNVN2VY/ref=aag_m_pw_dp?ie=UTF8&m=A3UEOXUM88DBUH

Würde gerne meine im Bad fest verbauten Lüfter damit ansteuern. Deshalb hatte ich auch schon mal über
http://www.amazon.de/Elro-AB440IS-Funk-Einbauschalter/dp/B005552HDI/ref=pd_sim_diy_3
nachgedacht.

Eigentlich sind die Infos so interessant, dass man sie gesammelt auf einer Info Seite posten sollte (und nicht "verteilt" über mehrere Threats)...

Vielen Dank für Infos,
Bernhard
Logged

arduino uno R3 1.024; dht22; Conrad relaiskarte; 20x4 hitachi auf rgb-shield mit 2 wires only

Germany S-H
Offline Offline
Faraday Member
**
Karma: 146
Posts: 3032
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

ich finde euren Artikel sehr interessant. Welchen Sender und Empfänger habt ihr benutzt?
Ich habe z.b. so einen gefunden:

Ja, genau solche verwende ich auch.

Allerdings bekommst Du für den Preis des Amazon Versenders bei Direktbestellung in China die fünffache Menge (also 5 Sender und 5 Empfänger) für den Preis, den der Amazon Versender bereits für nur ein Pärchen haben möchte.

Das sind die allerbilligsten, die es für 433 MHz gibt.
Logged

Germany, BW
Offline Offline
Sr. Member
****
Karma: 7
Posts: 302
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Ich verwende das RFM12 und TFA 30.3125 Außensender.
Logged

Pages: 1 [2] 3 4 5   Go Up
Jump to: