433 MHz RF - Temperature and humidity sensor

Yeah, the problem is I'm afraid of connecting 'data' pin to my soundcard without circuit for it.
And I couldn't fine any circuit except oscilloscope one (which I don't have all parts for).

Do you have any of these available? I have some old laptop with linux that I could play with.

Hi,
I've done this job a year ago and I used arduino for decoding

First you have to prepare the hardware:

  • open your sensor
  • find the modulator input
  • feed it into arduino with proper level change (I assume 0-3v => 0-5v)

The code I used was something like:

#define samples 700 //max 700
byte ms[samples];
boolean values[samples]; 
void setup() {                
  pinMode(13, OUTPUT);     
  pinMode(2, INPUT);
  Serial.begin(2400);  
}
long lastChange, maxTime = 0;
bool previousValue;
void loop() {
  for (int i = 0; i < samples; i++)
  {
    values[i] = false;
    ms[i] = 0;
  }
  long start = micros();
  for (int i = 0; i <= samples; i++)
  {
    if (i == samples) i = 0;
    digitalWrite(13, (values[i] = digitalRead(2)));
    ms[i] = (byte)((micros() - start)/10);
    start = micros();
    while (values[i] == digitalRead(2))
    {}
    if((micros()-start) > 50000)
    {
      for (int k = i + 1; k < samples; k++)
      {
        Serial.print(k);
        Serial.print(":");
        Serial.print((int)ms[k]);
        Serial.print(":");
        Serial.println((values[k]?"true":"false"));
      }
      for (int k = 0; k <= i; k++)
      {
        Serial.print(k);
        Serial.print(":");
        Serial.print((int)ms[k]);
        Serial.print(":");
        Serial.println((values[k]?"true":"false"));
      }
      break;
    }
  }
  digitalWrite(13, LOW);
  delay(1000);
  digitalWrite(13, HIGH);
  delay(1000);
  digitalWrite(13, LOW);
  delay(10000);
}

After you manage to isolate one packet, take 2 consecutive readings with just one unit (in the least significant digit) difference in temperature or humidity. If your streams have one difference you don't have CRC, if you have 2 or mode differences you might have something like 011+1=100 or CRC or both. Here you need some luck.

After some hours of reverse engineering I come with the following code:

#define nobits 36
#define initialstring "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
#define	syncmin	6400
#define	syncmax	9600
#define	separatormin 256
#define	separatormax	384
#define	lowmin	768
#define	lowmax	1152
#define	highmin	1536
#define	highmax	2304
#define baudspeed 115200
#define receiverpin 2
#define ledpin 13
#define sensorid "10001000"
#define rflisteninterval 50
float temperature = 0;
int humidity = 0;
unsigned long lastReadMills = 0;
boolean lowBatt = false;
boolean requestedTransmission = false;
boolean invalidTransmission = false;
String lastReceivedCode = "";

void setup() {                
  pinMode(ledpin, OUTPUT);     
  pinMode(receiverpin, INPUT);
  digitalWrite(receiverpin, HIGH);
  Serial.begin(baudspeed);
}

void loop()
{
  if(RFListened())
  {
    //other processing
  }
}
boolean RFListened()
{
  if(((millis()-lastReadMills)/1000>rflisteninterval)||(millis()<lastReadMills))
  {
    GetWeatherData();
    if((millis()==lastReadMills)&&(lastReadMills!=0))
    {
        if (lowBatt) Serial.print("Battery low; ");
        if (requestedTransmission) Serial.print("Requested transmission; ");
        if (invalidTransmission)
        {
          Serial.println("Non temperature/humidity data; ");
          return false;
        }
        else
        {
          Serial.print(lastReadMills/1000);
          Serial.print("s; ");
          Serial.print(temperature);
          Serial.print("C; ");
          Serial.print(humidity);
          Serial.println("%");
          return true;
        }
    }
    return false;
  }
  else
  {
    return true;
  }
}

void GetWeatherData()
{
  String receivedCode = ReceiveCode();
  if (receivedCode!="")
  {
    if (receivedCode==lastReceivedCode)
    {
      lowBatt = (receivedCode.charAt(8)=='1');
      requestedTransmission = (receivedCode.charAt(11)=='1');
      invalidTransmission = !((receivedCode.charAt(9)=='0')||(receivedCode.charAt(10)=='0'));
      if (!invalidTransmission)
      {
        temperature = (receivedCode.charAt(24)=='1'?1:0)*2048 +
          (receivedCode.charAt(25)=='1'?1:0)*1024 +
          (receivedCode.charAt(26)=='1'?1:0)*512 +
          (receivedCode.charAt(27)=='1'?1:0)*256 +
          (receivedCode.charAt(28)=='1'?1:0)*128 +
          (receivedCode.charAt(29)=='1'?1:0)*64 +
          (receivedCode.charAt(30)=='1'?1:0)*32 +
          (receivedCode.charAt(31)=='1'?1:0)*16 +
          (receivedCode.charAt(32)=='1'?1:0)*8 +
          (receivedCode.charAt(33)=='1'?1:0)*4 +
          (receivedCode.charAt(34)=='1'?1:0)*2 +
          (receivedCode.charAt(35)=='1'?1:0);
         temperature = temperature /10;
         humidity = (receivedCode.charAt(16)=='1'?1:0)*128 +
           (receivedCode.charAt(17)=='1'?1:0)*64 +
           (receivedCode.charAt(18)=='1'?1:0)*32 +
           (receivedCode.charAt(19)=='1'?1:0)*16 +
           (receivedCode.charAt(20)=='1'?1:0)*8 +
           (receivedCode.charAt(21)=='1'?1:0)*4 +
           (receivedCode.charAt(22)=='1'?1:0)*2 +
           (receivedCode.charAt(23)=='1'?1:0);
         lastReadMills = millis();
      }
    }
    else
      lastReceivedCode = receivedCode;
  }
}

String ReceiveCode()
{
  String receivedCode = initialstring;
  long startMicros = micros(), endMicros;
  if (digitalRead(receiverpin)) return "";
  while(!digitalRead(receiverpin))
  {
    if ((micros()-startMicros)>syncmax)
      return "";
  }
  if ((micros()-startMicros)<syncmin)
    return "";
  startMicros = micros();
  while(digitalRead(receiverpin))
  {
    if ((micros()-startMicros)>separatormax)
      return "";
  }
  if ((micros()-startMicros)<separatormin)
    return "";
  for(int i = 0; i < nobits; i++)
  {
    startMicros = micros();    
    while(!digitalRead(receiverpin))
    {
      if ((micros()-startMicros)>highmax)
        return receivedCode;
    }
    endMicros = micros();
    if(((endMicros-startMicros)>lowmin)&&((endMicros-startMicros)<lowmax))
      receivedCode.setCharAt(i,'0');
    else
      if(((endMicros-startMicros)>highmin)&&((endMicros-startMicros)<highmax))
        receivedCode.setCharAt(i,'1');
      else
        return "";
    startMicros = micros();
    while(digitalRead(receiverpin))
    {
      if ((micros()-startMicros)>separatormax)
        return "";
    }
    if ((micros()-startMicros)<separatormin)
      return "";
  }
  //Serial.println(receivedCode);
  if (receivedCode.substring(0,8)==sensorid)
    return receivedCode;
  else
    return "";
}

This will not fit your sensor since, as I see in the image it has a configurable channel. Mine has a random signature generated at power on.

Thank you very much for your post!
Just tell me please - where is the 'modulator input' on this picture?
Do you mean output for the 433 transciever?

Did you manage to get this working? I did a quick hunt online for a similar looking wireless sender so I could hack it but found nothing suitable & cheap. I'm in the process of converting the audio captures joshhawk did for me in his thread into logic level samples so I can attempt to write an interrupt based receiver routine. I'm getting bit-streams from the one sample I have converted but time will tell if it's correct.

I haven't managed to get it working yet, I was a little short in time last week.
I'll might try soon, of course If I don't burn my soundcard. :slight_smile:

I hope you'll get your alogyrthm to work. The hardest part is to harvest data to decode as I see...

To have any real chance of helping you need to capture a transmission from your sensor and post it up here. It seems every make of sensor has a different way of transmitting the data.
I have knocked together a bit of test code that I just posted here Help me decode this 434mhz signal...? - #28 by Riva - Project Guidance - Arduino Forum As I don't have such a device to test it with it's really a shot in the dark.

I have also contacted the original thread poster joshhawk and he said the attached code below worked for his sensor. Hopefully yours is the same.

Some Code.ino (8.8 KB)

I might try to build voltage divider tonight.
I'm not sure how to do it by soldering into the sensor board, so I don't get signals from other sensors.
And I don't want to break the mic-in port in laptop (I don't have line-in in there).

Any suggestions?
I'll get knowledge from here: http://davehouston.net/learn.htm which shows the 39K and 10K resistors.

Ideally you would tap into the data feeding the transmitter but I have no idea what point that would be on the pictures you posted without testing with a scope. There is a data line (yellow wire) that goes to another PCB. What does this PCB look like?

If you don't have a line level input on your laptop then the voltage divider you linked to is not much use.

I might try on desktop PC, but I dont want to burn it so I have to be sure that those resistors are ok.

The yellow data wire is going straight to RF-transmitter module (it has a visible antenna also).

andriej:
I might try on desktop PC, but I dont want to burn it so I have to be sure that those resistors are ok.

The yellow data wire is going straight to RF-transmitter module (it has a visible antenna also).

For a 5V input the 39K/10K you refer to gives a 1.02V output that should be okay. If you prefer to be cautious then try a 48K/10K that will drop the output to about 0.86V

Sounds like the yellow data wire may be a place to tap in, depends how smart the transmitter is as to if the data is raw transmitter on/off or a micro interface. Can you measure voltage when the unit transmits to be sure voltage is 0-5V range.

I tried to wire in to the transmitter - it sends same sound as the RF reciever gets, just much more quiet.
I'll be trying to pin to it now as it gives lower voltage. I couldnt get voltage divider to work, i get very noisy sound.
I managed to record one "test" button before my ears exploded ;-)) it's in attachment.

If you somehow manage to get code working for it (so i can harvest data from sensor), we might start debugging.
http://dl.dropbox.com/u/619007/rf_oneread.wav - but it sounds corrupted near the one below.
Yep, managed to get few "normal" reads without the "transmit" button. It seems like it's send every minute.
https://dl.dropbox.com/u/619007/few_reads_around24c_23wh_ch2.zip
temperature (i couldnt see the lcd while holding cable) was around 24.xC, humidity 23% and it was sent on second channel (and sensor have 1-2-3 CH option).
I didnt cut or modify the file - it's straight from audacity.

I hope it helps to get the "header" pulse for sketch...

I played it back slowed down few times - it sounds liek it sends 6 "pulses" every time. So it's like 6 (same?) messages for weather station, very near to each other.

You have managed to record some very clean signals. Do you have a receiver connected to your arduino or did you capture from the transmitter?
I have tidied up the wav file by splitting the 3x bursts you captured onto separate tracks and removing the long silences. I have attached the audacity project file so you can look at it. To have any real chance of decoding the data you really need to note the precise temperature/humidity of each sample you capture and try to capture over a large range of values.
The transmitter is repeating the data readings 6 times per burst transmission. Below is what one reading may decode to (I say may because the 0/1 bits may need inverting)

Sync 000101011110011 000011101101001000100100010 End
Sync 000101011110011 001011101101000000100100001 End
Sync 000101011110011 100011101101001000100101001 End

The first 15 bits are the same for all readings but may contain a channel number. You can confirm this by capturing data with the switch set to different channels.

few_reads_around24c_23wh_ch2.zip (246 KB)

I did it very simple way - one channel of jack [line-in] was held by yellow (DATA) cable. Other one was GND near battery.
I've used 2xRCA->stereo jack cable.

Hopefully I'll record some more (I have problems with sticking the wires to RCAs ;-)) and get readings also for CH1 and CH3 to see what's the difference.
At this point, with the pattern above - is it possible to modify your code to get the 0 and 1's from Serial with Arduino?
It'd be much easier to note down values of Temp. and Hum. using a notepad and ctrl-c ctrl-v. :slight_smile: Even from a fridge etc.

After a bit of messing about I managed to capture your wav samples to logic level so I could play them back to test the modified code. Attached is the modified sketch to suit your transmission timebase that reads in the 42 bits but displays them as 64 bit data. I have also attached the logic level files that you can load and view with Scanalogic-2 software from here http://www.ikalogic.com/ikalogic-products/scanalogic-2/ You don't need the analyser hardware to view the files.

WeatherRF2.ino (5.89 KB)

Unknown01.sst (4.4 KB)

Unknown02.sst (4.46 KB)

Unknown03.sst (4.45 KB)

Thank you for the code! It works and output i present below is exactly copy-paste from it!
Now it's much easier to get probes.

Here's the easy-to-read Google Doc version EZ6 Meteo Temp&Humi Sensor - Google Docs of what I already manage to get to know about the sensor.
I already see the channel bits (000-1, 001-2, 010-3).

I have to wire up antenna to the reciever so I get all the signals (I had to get the transmitter close to arduino to get all readings one by one).
Those with "???" are not-quite-sure about temperature values, all other ones are written from LCD. Those with "(no force)" came from transmitter as it was sending data WITHOUT me pushing the button.

TT RH
5.7*C 94%  0000000000000000000000000101011101011011001001011110010110011110 ???
7,1*C 93%  0000000000000000000000000101011101010011010001011101010110011000
7,3*C 92%  0000000000000000000000000101011101010111010001011100010110010110
7,3*C 92%  0000000000000000000000000101011101010111010001011100010110010110
8.1*C 91%  0000000000000000000000000101011110010101010101011011010110010001
9.0*C 90%  0000000000000000000000000101011110010101010101011011010100011001 ???
9.0*C 90%  0000000000000000000000000101011110010110011001011010010110011000
9.2*C 88%  0000000000000000000000000101011110011001011001011000010110010110
10.3*C 85% 0000000000000000000000000101011110011110011101010101010100010001
10.6*C 85% 0000000000000000000000000101011110010010100001010101010110011010
10.9*C 84% 0000000000000000000000000101011110011001100001010100010110010000
11.8*C 83% 0000000000000000000000000101011110011000100101010011010110011100
11.9*C 83% 0000000000000000000000000101011110011011100101010011010110010110
12.2*C 81% 0000000000000000000000000101011110010000101001010001010110010101
12.6*C 79% 0000000000000000000000000101011110010110101001011111010010010010
13.2*C 75% 0000000000000000000000000101011110010001101101011011010010010110
13.4*C 75% 0000000000000000000000000101011110010110101101011011010010010111
13.7*C 75% 0000000000000000000000000101011110011010101101011011010000010001 (no force)
13.9*C 75% 0000000000000000000000000101011110011110101101011011010010010010
14.2*C 75% 0000000000000000000000000101011110010011110001011011010000011100 (no force)
14.4*C 75% 0000000000000000000000000101011110010111110001011011010010011111
14.6*C 75% 0000000000000000000000000101011110011011110001011011010010010001
14.6*C 75% 0000000000000000000000000101011110011011110001011011010000011001 (no force)
14.8*C 75% 0000000000000000000000000101011110011111110001011011010010011010
15.1*C 73% 0000000000000000000000000101011110010100110101011010010010010010 ???
15.3*C 73% 0000000000000000000000000101011110010111110101011001010010010111
16.2*C 67% 0000000000000000000000000101011110010111111001010011010010010101
16.6*C 64% 0000000000000000000000000101011110011111111001010000010000010111 (no force)
16.9*C 66% 0000000000000000000000000101011110010101111101010010010000010110 (no force)
17.2*C 65% 0000000000000000000000000101011110011010111101010001010000011101
17.4*C 64% 0000000000000000000000000101011110011110111101010000010000010011 (no force)
17.6*C 63% 0000000000000000000000000101011110010000000001101111001100010001
17.7*C 61% 0000000000000000000000000101011110010011000001101101001110011001
17.9*C 60% 0000000000000000000000000101011110010111000001101100001100011111
CH 1 -----------
18.0*C 58% 0000000000000000000000000101011110001000000001101010001110010100
18.2*C 58% 0000000000000000000000000101011110001100000001101010001100010111
CH 3 -----------
18.4*C 59% 0000000000000000000000000101011110101111000001101011001110010111
18.6*C 57% 0000000000000000000000000101011110100010000101101001001110010111
18.7*C 56% 0000000000000000000000000101011110100101000101101000001110010011

CH 2 -----------
19.0*C 56% 0000000000000000000000000101011110011010000101101000001110011010
19.2*C 56% 0000000000000000000000000101011110011101000101101000001110011011
19.2*C 56% 0000000000000000000000000101011110011101000101101000001100010011
19.3*C 56% 0000000000000000000000000101011110010000001001101000001110010101
19.5*C 55% 0000000000000000000000000101011110010011001001100111001100010001
19.7*C 55% 0000000000000000000000000101011110010110001001100111001110010100
19.8*C 54% 0000000000000000000000000101011110011000001001100110001110010011
19.9*C 55% 0000000000000000000000000101011110011010001001100111001110011010
20.0*C 55% 0000000000000000000000000101011110011100001001100111001110011101
20.1*C 54% 0000000000000000000000000101011110011110001001100110001110010100
20.1*C 54% 0000000000000000000000000101011110011110001001100110001110010100

I see some pattern, but can't decode it successfully yet.
What are those 'leading' zeroes?

Few more - next to each other and forced-nonforced readings from CH2.

20.1*C 47% 0000000000000000000000000101011110011101001001101111001010010110
20.1*C 47% 0000000000000000000000000101011110011101001001101111001000011110
20.1*C 48% 0000000000000000000000000101011110011110001001100000001100010001
 (no force)
20.2*C 48% 0000000000000000000000000101011110011111001001100000001110011111
20.2*C 47% 0000000000000000000000000101011110010000001101101111001010011100

Here are the CH1-2-3 differencies. The temperature changed slightly but it's possible to see where it happened in binary code.

20.0*c 44% 0000000000000000000000000101011110011100001001101100001000010111 CH2
20.0*C 44% 0000000000000000000000000101011110001100001001101100001000011101 CH1
20.1*C 44% 0000000000000000000000000101011110101110001001101100001010011110 CH3

and also other one - better to see:

20.5*C 44% [pulse] 101011110000101001101101100001010010100 CH1
20.5*C 44% [pulse] 101011110010101001101101100001010011110 CH2
20.5*C 44% [pulse] 101011110100101001101101100001010010011 CH3

I also tried to change battery to older one (to see the battery indicator) and I'm afraid I cant understand anything now...
Look at the pulse difference:

BATTERY + OLD NI-MH accu BATTERY [station DOESNT show this as a 'weak battery']
0000000000000000000000000010111110010010001101100111001000001010
USED BATTERY
0000000000000000000000001010110100011100001101100101001010001010
ONE USED AND ONE GOOD BATTERY
0000000000000000000000001111010100010111010001100100001010001011
AND BACK TO GOOD BATTERY (pair which I used for all measures)
0000000000000000000000001010010000011100010001100011001010000110

Another update.
Sensor and application has been on for hour or so, I didn't write down values.
These are the one printed - it looks like every column changes.
The last value is around 22.3*C 29%.

0000000000000000000000001010010000011100010001100011001010000110
0000000000000000000000001010010000011100010001100011001010000110
0000000000000000000000001010010000011100010001100011001010000110
0000000000000000000000001010010000011100010001100011001010000110
0000000000000000000000001010010000011100010001100011001010000110
0000000000000000000000001010010000011100010001100011001000001110
0000000000000000000000001010010000011100010001100001001000000100
0000000000000000000000001010010000011100010001100001001000000100
0000000000000000000000001010010000011100010001100001001000000100
0000000000000000000000001010010000011100010001100001001000000100
0000000000000000000000001010010000011100010001100000001000000001
0000000000000000000000001010010000011100010001100000001000000001
0000000000000000000000001010010000011101010001101111000100000100
0000000000000000000000001010010000011101010001101111000100000100
0000000000000000000000001010010000011101010001101111000100000100
0000000000000000000000001010010000011101010001101111000100000100
0000000000000000000000001010010000011110010001101110000100001011
0000000000000000000000001010010010011110010001101110000100000100
0000000000000000000000001010010010011110010001101110000100000100
0000000000000000000000001010010010011110010001101110000100000100
0000000000000000000000001010010010010000010101101110000100000100
0000000000000000000000001010010010010000010101101110000100000100
0000000000000000000000001010010010010000010101101111000100000001
0000000000000000000000001010010010010000010101101110000100000100
0000000000000000000000001010010010010000010101101110000100000100
0000000000000000000000001010010010010000010101101110000100000100
0000000000000000000000001010010010010001010101101110000100000010
0000000000000000000000001010010010010010010101101110000100001000
0000000000000000000000001010010010010010010101101110000100001000
0000000000000000000000001010010010010010010101101110000100001000
0000000000000000000000001010010010010010010101101110000100001000
0000000000000000000000001010010010010011010101101110000100001110
0000000000000000000000001010010010010100010101101101000100000000
0000000000000000000000001010010010010110010101101101000100001100

What are those 'leading' zeroes?

You transmitter sends 42 bits but the subroutine to display the data as binary only does 32 chunks so 2x 32 bit chunks displays 64 bits with leading zero's instead of just 42 bits.

                        TX                LLLLHHHH
Temp   RH% -Preamble- ??CH                Humidity 
 7,1*C 93% 0001010111 0101 0011 0100 0101 11010101 10011000

Humidity is stored as low/high order nibbles. In the example above take the first 4 bits and tack them on the end of the next 4 bits. 11010101 becomes 01011101 that is 93 decimal. Not done temperature yet but it look like it's also split into nibbles.

Wow, Riva, I'm amazed of the knownledge you get here. I wouldn't manage to get that never, probably.
As I've written on google docs - temperatures may be in fahrenheit.
Sensor, after changing batteries, views temp. as F degrees. I have to push button on the back to switch to celsius - the data sent by transmitter doesn't change by that.

I also see about that you also used 'preamble' - do you know why would it change when changing batteries?
Usually I see the battery-indicator in the transmission as a "high"/"low".
Maybe it was too late for me (and I was tired) but there are more changes in bits than one-two in preamble part.

I also see about that you also used 'preamble' - do you know why would it change when changing batteries?

The transmitter will probably generate a random number when first powered on (or batteries changed) and this will become all/part of the preamble.

                        TX LLLL MMMM HHHH LLLLHHHH
Temp   RH% -Preamble- ??CH Temperature- Humidity 
 7,1*C 93% 0001010111 0101 001101000101 11010101 10011000

Looks like temperature is transmitted as 12 bits in 3x nibbles ranging from low to high nibbles. A fixed offset of 900 is applied to the temperature value so 0 degrees F = 900 and each degree F change is 10 decimal. In the example 001101000101 becomes 010101000011 that is 1347 decimal.
1347-900 = 447
447/10 = 44.7
44.7F = 7.1C

Riva:
The transmitter will probably generate a random number when first powered on (or batteries changed) and this will become all/part of the preamble.

I'm not sure about this, because - how its possible to sensor to generate the same number again when putting back 'normal' batteries?
As you can see from here (and I don't know if I cut the lead 'zeroes' properly) - we have the same preamble after tries with 3 other sets of batteries.
Compare: "starting point" and "typical setup" - preamble is the same.

0001010111 01010011010001011101010110011000 - your preamble (7,1, RH93%)
0010100100 00011100010001100000001000000001 - starting point
0000101111 10010010001101100111001000001010 - battery + old ni-mh
0010101101 00011100001101100101001010001010 - used battery (1 GOOD, 1 'used') 
0011110101 00010111010001100100001010001011 - used battery (1 GOOD, 1 nimh used)
0010100100 00011100010001100011001010000110 - typical setup (2AA varta batt.) (same as "starting point")

Great job with the temperature - as I see the biggest problem will be the code. :slight_smile:

Temp*C RH% -Preamble- BC CH Temperature- Humidity --CRC?--
                      BB CC LLLLMMMMHHHH LLLLHHHH
 7,1*C 93% 0001010111 01 01 001101000101 11010101 10011000

I still wonder if first 8/10 bits are random number used as device ID
BC looks like 2 bit battery condition
CH is channel number from switch position?
Have not figured out the CRC yet but that's what I assume it is.