Bitte spendet ""Kleinigkeit" an den Betrieber Bluefox, wenn es euch was gebracht hat (auch wenn nicht :-)

da wir EXTRA FÜR EUCH eine Wetterstation gekauft haben zum Dekodieren und diese eigentlich nicht brauchen!!! Aber die Community!!!

sketch für arduino zum auslesn:

! /*
! 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 740
! // minimum duration (microseconds) of a short bit pulse
! #define MINBITPULSE 250
! // 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 40
! // maximum count of data bit pulses following the start pulse
! #define MAXPULSECOUNT 70
! // 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++)<br>{
! Serial.print(validpulsbuf__);Serial.print(" ");
! sum+=validpulsbuf__;
! }
! Serial.println();
! Serial.print("H: ");
! for (i=0;i <counter;i++)<br>{
! Serial.print(validhibuf__);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++)<br>{
! if (validpulsbuf __<avg) serial.print('0');/else/serial.print('1');<br="">}
! 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)<br>shortBitDuration=MINBITPULSE;
! else
! shortBitDuration-=PULSEVARIANCE;
! longBitDuration=lowtime2+PULSEVARIANCE;
! validpulsbuf[counter]=lowtime;
! validhibuf[counter]=hitime;
! counter++;
! }
! else if (counting&&(lowtime>shortBitDuration)&&(lowtime <longbitduration))<br>{
! validpulsbuf[counter]=lowtime;
! validhibuf[counter]=hitime;
! counter++;
! if ((counter==MAXPULSECOUNT) || (hitime <minhitime))<br>{
! showBuffer();
! }
! }
! else // Low Pulse is too short
! {
! if (counting) showBuffer();
! counting=false;
! counter=0;
! }
! }
! }</minhitime))<br></longbitduration))<br></minbitpulse+pulsevariance)<br></avg)></counter;i++)<br></counter;i++)<br>____</counter;i++)<br> ___Log:

Start Bit L: 750   H: 700
Data Bits: 40
L: 512 272 268 516 276 268 276 520 516 516 276 272 516 268 284 520 272 520 516 280 516 512 272 532 524 512 268 512 512 280 268 512 512 276 516 268 276 264 516 512 
H: 220 452 464 208 456 456 456 208 212 208 456 452 216 456 452 200 452 212 208 452 208 216 456 208 192 216 456 220 212 456 452 220 216 452 208 456 456 460 216 212 
1001000111001001011011011101100110100011

Start Bit L: 760   H: 692
Data Bits: 40
L: 516 276 268 520 276 272 276 520 516 516 280 268 516 268 284 516 280 516 520 268 520 520 288 524 524 520 276 512 512 276 276 516 508 272 508 276 268 276 516 508 
H: 208 456 456 208 452 452 456 208 212 208 452 456 216 456 452 204 452 208 212 456 212 204 448 196 204 208 448 216 216 452 460 204 216 460 216 456 456 460 204 224 
1001000111001001011011011101100110100011

Start Bit L: 760   H: 692
Data Bits: 40
L: 516 276 268 512 268 280 268 512 516 516 268 280 516 268 284 524 280 512 516 268 516 520 280 508 512 516 280 516 520 264 276 516 512 280 520 280 272 280 520 520 
H: 212 456 452 220 460 456 448 220 212 212 456 452 212 452 452 200 448 212 216 456 216 204 452 216 216 212 452 208 212 456 460 208 212 452 204 452 448 456 204 212 
1001000111001001011011011101100110100011

Start Bit L: 750   H: 704
Data Bits: 40
L: 516 268 276 524 272 280 268 512 512 516 276 272 516 272 276 516 260 516 516 280 520 524 268 512 516 516 284 520 512 272 284 516 516 268 512 272 280 268 516 508 
H: 212 460 456 200 448 460 448 220 212 220 448 456 208 460 456 208 464 216 208 452 208 212 448 220 208 208 448 208 212 456 452 204 216 456 216 456 452 452 220 216 
1001000111001001011011011101100110100011

Start Bit L: 760   H: 696
Data Bits: 40
L: 512 276 268 516 268 284 276 588 516 516 272 280 516 280 272 520 268 508 516 268 516 516 276 520 512 512 280 512 516 264 284 520 516 268 516 268 284 272 516 520 
H: 212 456 456 216 456 456 444 144 204 216 456 448 208 452 456 208 456 216 216 456 212 212 456 208 212 216 452 208 216 460 456 200 216 452 216 456 452 448 216 208 
1001000111001001011011011101100110100011

! Start Bit L: 740 H: 712
! Data Bits: 40
! L: 504 272 260 508 260 276 264 508 512 512 260 268 504 268 268 508 260 508 512 264 508 268 508 512 516 512 276 508 264 512 524 268 504 264 264 508 508 508 504 272
! H: 228 456 464 224 464 464 452 220 220 212 464 464 220 468 460 212 472 216 220 464 216 464 216 220 212 212 456 216 460 220 212 452 220 464 464 220 224 216 220 464
! 1001000111001001011010111101011010011110
! Start Bit L: 750 H: 704
! Data Bits: 40
! L: 508 276 264 508 260 268 268 508 508 504 272 268 508 268 260 504 280 520 516 268 508 280 516 508 508 508 268 508 268 512 512 272 512 272 264 508 512 516 516 280
! H: 220 452 460 224 464 464 456 224 216 220 464 456 216 464 464 224 452 208 212 456 220 452 208 224 216 216 464 216 464 216 212 460 216 456 460 216 224 208 216 452
! 1001000111001001011010111101011010011110
! Start Bit L: 740 H: 704
! Data Bits: 40
! L: 508 264 272 508 264 276 260 512 512 512 268 264 520 272 280 516 272 520 516 264 508 268 512 512 512 512 264 512 264 516 512 264 512 272 268 520 516 524 516 276
! H: 224 460 460 216 460 464 456 224 212 212 464 460 216 452 452 208 452 212 208 460 224 460 220 212 212 220 460 220 460 212 224 456 220 452 460 212 208 216 200 452
! 1001000111001001011010111101011010011110
! Start Bit L: 750 H: 700
! Data Bits: 40
! L: 512 272 264 500 272 272 276 520 508 516 268 276 512 272 280 512 272 512 512 272 512 272 508 508 516 512 272 504 272 512 520 280 512 280 276 512 512 512 508 280
! H: 216 460 460 224 460 456 452 208 216 216 456 456 212 460 452 208 456 216 220 452 212 460 216 224 212 212 460 220 460 212 208 452 212 452 448 212 220 212 224 452
! 1001000111001001011010111101011010011110
! Start Bit L: 750 H: 696
! Data Bits: 40
! L: 512 264 272 516 264 280 264 512 512 512 272 264 512 264 272 512 260 520 520 272 512 268 512 512 512 516 276 520 276 520 524 272 516 268 272 512 504 512 508 276
! H: 220 460 460 212 460 456 456 220 212 220 452 460 224 456 464 212 464 216 200 460 212 460 220 212 220 212 448 212 448 212 204 448 216 456 460 212 220 220 216 460
! 1001000111001001011010111101011010011110
! Start Bit L: 750 H: 704
! Data Bits: 40
! L: 520 272 268 520 272 284 272 508 512 512 272 264 516 276 264 512 272 516 512 268 512 268 520 520 516 520 272 520 272 516 520 268 512 264 264 512 512 512 512 272
! H: 212 452 456 212 452 456 444 220 216 212 460 460 220 448 460 220 456 212 212 460 220 456 212 208 204 216 452 212 452 208 220 448 220 460 460 220 212 220 216 452
! 1001000111001001011010111101011010011110
! Start Bit L: 750 H: 700
! Data Bits: 40
! L: 504 280 268 516 268 272 268 508 512 512 272 268 516 272 268 512 264 508 520 272 520 272 520 508 516 512 264 512 272 508 516 268 516 268 264 512 512 512 516 284
! H: 220 456 456 216 456 460 452 224 216 212 460 460 208 460 456 220 460 216 216 452 212 452 212 216 208 220 460 220 452 216 224 452 216 456 460 220 212 220 212 448
! 1001000111001001011010111101011010011110
! Start Bit L: 750 H: 704
! Data Bits: 40
! L: 508 272 264 512 264 264 272 508 512 512 272 272 516 284 284 520 272 512 520 272 520 264 504 508 512 512 268 512 272 516 512 268 512 268 264 520 516 512 516 264
! H: 216 460 460 220 460 460 464 220 216 212 460 452 212 448 448 204 452 212 216 452 212 456 220 228 212 220 456 220 452 208 220 460 216 460 460 212 208 220 208 460
! 1001000111001001011010111101011010011110
! Start Bit L: 750 H: 700
! Data Bits: 40
! L: 508 276 268 520 268 284 276 524 516 516 280 272 520 280 276 520 272 508 516 268 512 268 516 508 516 520 264 516 268 516 528 272 516 280 276 524 520 520 520 276
! H: 216 456 456 216 452 456 444 204 212 208 452 452 208 452 448 208 456 212 220 456 220 456 216 220 204 216 456 220 456 208 212 444 220 444 448 208 204 212 204 456
! 1001000111001001011010111101011010011110
! Start Bit L: 750 H: 704
! Data Bits: 40
! L: 516 276 268 516 272 276 268 508 524 520 284 276 520 280 280 520 268 516 516 268 516 272 516 520 508 516 268 520 272 516 520 268 512 272 284 520 516 512 512 280
! H: 216 452 456 216 452 456 456 220 208 204 448 448 212 444 452 204 456 216 208 456 220 452 212 208 216 216 456 212 456 212 212 448 220 456 448 204 208 220 212 456
! 1001000111001001011010111101011010011110
! Start Bit L: 750 H: 704
! Data Bits: 40
! L: 512 268 276 520 276 284 276 524 520 520 284 268 516 268 276 516 276 516 516 280 516 272 516 520 516 512 272 520 280 524 524 284 524 276 284 520 520 516 516 272
! H: 220 456 456 208 448 448 448 208 204 204 448 456 216 456 456 208 456 208 212 452 208 452 216 204 216 212 456 212 444 208 200 448 204 444 452 204 208 212 208 456
! 1001000111001001011010111101011010011110
! Start Bit L: 750 H: 692
! Data Bits: 40
! L: 516 268 280 524 284 288 272 516 520 520 268 268 512 264 276 516 272 512 516 276 516 288 520 524 520 520 284 516 272 516 512 276 512 276 268 512 516 516 516 268
! H: 216 456 456 200 448 440 448 216 204 212 456 456 220 460 460 208 456 212 212 456 208 452 196 204 212 204 448 208 452 212 216 456 212 456 456 212 220 208 216 456
! 1001000111001001011010111101011010011110
! Start Bit L: 750 H: 708
! Data Bits: 40
! L: 512 268 264 512 264 272 264 512 516 516 276 268 516 268 268 512 272 520 524 276 520 272 520 524 516 512 264 508 268 516 516 268 508 268 276 512 516 512 520 280
! H: 220 456 460 220 460 460 460 224 208 208 456 456 216 456 456 220 456 212 204 444 212 452 212 208 208 212 460 224 460 216 208 456 224 456 456 212 220 212 204 456
! 1001000111001001011010111101011010011110

Lösung:

Test data for the wireless Temperature/Humidity outdoor sensor
Bresser Thermo-/Hygro-Sensor 3CH

Art. Nr.: 7009994
EAN: 4007922031194
http://www.bresser.de/Wetter/BRESSER-Thermo-Hygro-Sensor-3CH-passend-fuer-BRESSER-Thermo-Hygrometer.html

Bresser also has two other Thermo-/Hygro-Sensors types most likely using different protocols:

- Bresser Thermo-/Hygro-Sensor 5CH (7009993)
- Bresser Thermo-/Hygro-Sensor 3CH (7009994)
- Bresser Thermo-/Hygro-Sensor 3CH for Temeo (7009995)

The sensor sends 15 identical packages of 40 bits each ~60s.
The bits are PWM modulated with On Off Keying.
Transmissions also include channel code, sync id, batt-low, and test/sync.

 +----+  +----+  +--+    +--+      high
 |    |  |    |  |  |    |  |
 |    |  |    |  |  |    |  |
-+    +--+    +--+  +----+  +----  low
 ^       ^       ^       ^       ^  clock cycle
 |   1   |   1   |   0   |   0   |  translates as
 Each transmission is 40 bits long (i.e. 29 ms, 36 incl. preamble)
 Data is transmitted in pure binary values, NOT BCD-coded.
 Temperature is given in Centi-Fahrenheit and offset by 900.

Burst length is ~36ms (41 pulses + 8 syncs) * 750us.

CH1 has a period of 57 s
CH2 has a period of 67 s
CH3 has a period of 79 s

A short pulse of 250 us followed by a 500 us gap is a 0 bit,
a long pulse of 500 us followed by a 250 us gap is a 1 bit,
there is a sync preamble of pulse, gap, 750 us each, repeated 4 times.
Actual received and demodulated timings might be 2% shorter.

The data is grouped in 5 bytes / 10 nibbles

 1111 1100 | 0001 0110 | 0001 0000 | 0011 0111 | 0101 1001 0  65.1 F 55 %
 iiii iiii | bscc tttt | tttt tttt | hhhh hhhh | xxxx xxxx

- i: 8 bit random id (changes on power-loss)
- b: battery indicator (0=>OK, 1=>LOW)
- s: Test/Sync (0=>Normal, 1=>Test-Button pressed / Sync)
- c: Channel (MSB-first, valid channels are 1-3)
- t: Temperature (MSB-first, Big-endian)
     12 bit unsigned fahrenheit offset by 90 and scaled by 10
- h: Humidity (MSB-first) 8 bit relative humidity percentage
- x: checksum (byte1 + byte2 + byte3 + byte4) % 256
     Check with e.g. (byte1 + byte2 + byte3 + byte4 - byte5) % 256) = 0

````found here

>! [https://github.com/merbanan/rtl_433_tes … resser_3ch](https://github.com/merbanan/rtl_433_tests/tree/master/tests/bresser_3ch)___