Send and receive

Your ads will be inserted here by

Easy Plugin for AdSense.

Please go to the plugin admin page to
Paste your ad code OR
Suppress this ad slot.

The last days I’ve been playing around with my JeeLink and a JeeNode including three sensors. I made a JeePlug with the TMP36, an LDR and a TSOP infrared receiver, which I can plug into my JeeNode. So I don’t have to plug everything in a breadboard and connect the wires, just place the JeePlug on top of my JeeNode in ports 1 and 4. I use port 1 for the temperature (TMP36) on the analog pin and I use the analog pin of port 4 for the LDR. The TSOP is connected to the digital pin of port 4 which leave the digital pin of port 1 empty to be used in the future.

The goal is to create a WSN based on several JeeNode and a Jeelink as central node. The JeeLink/JeeNode have a RF12Demo sketch with which it is possible to easily create a mesh network. The JeeLink is connected to a computer through USB. JeeNodes can communicate wirelessm using the on board RF12 chipset. All you have to do is configure the two units s that they can ‘find’ each other. See POF03 @ JeeLabs for an instruction on how to do that.

After I made the setup of my nodes and got the sketch started I saw data being displayed in my serial monitor. The JeeNode (sensor node) displayed information about the light and temperature on screen and sent the data to the JeeLink. I saw valid messages in the serial monitor of the JeeLink. The data shown by the JeeLink was something like:

OK 33 103 113 175 65

This line contains the measured temperature sent by the JeeNode. I knew that the value measured and sent was related to 21.93 degrees Centigrade. So somewhere in the sequence could be found. When you take a look at the Arduino Reference page about float (floating-point variables) you find that a float is represented by 4 bytes. So 4 of the 5 numbers in the message will together form the floating point number.

I wanted to know what 4 bytes were sent by the JeeNode so I did put in some extra Serial.print statements to display not only the measured temperature of (in this case) 21.93 degrees but I also the seperate bytes. To do this I had to ‘convert’ the float into an array of bytes. The lines below show you how:

float temperature;
byte  *ArrayOfFourBytes;

temperature = 21.93;

ArrayOfFourBytes = (byte*)&temperature;

Serial.println(temperature); // print the temperature

Serial.println(ArrayOfFourBytes[0],BIN); // print the 'first' byte in binary notation
Serial.println(ArrayOfFourBytes[1],BIN); // print the 'first' byte in binary notation
Serial.println(ArrayOfFourBytes[2],BIN); // print the 'first' byte in binary notation
Serial.println(ArrayOfFourBytes[3],BIN); // print the 'first' byte in binary notation

The printed binary numbers were:


In decimal notation equal to 103, 113, 165 and 65 which are the last 4 numbers of the received message. This still doesn’t look like 21.93 but we’re getting there.

Your ads will be inserted here by

Easy Plugin for AdSense.

Please go to the plugin admin page to
Paste your ad code OR
Suppress this ad slot.

A float is represented by 4 bytes which are equal to 32 bits. The printed binaries above are not all 8-bits but three of them are 7-bits. This is because the preceding zero’s are left out and you have to place them yourself in front of the 7-bits.
Al together these 32-bits give you three pieces of the puzzle; a sign, a exponent and a mantisse.

The formula for a IEEE 754 float is:  sign * 2exponent * mantissa  , where sign is +1 or -1

There are many of pages that explain more about floating-point numbers and their representation in bits, together with formulas. You can also find websites with converters that let you enter a number in the different representations and show that number in a binary, hexadecimal, float or decimal representation. I used this website.

I entered 21.93 in the converter and got 01000001 10101111 01110000 10100100 (in bytes this is equal to 65 175 112 164). This isn’t equal to 103, 113, 165 and 65; except for the 65 which might be a coincidence or not.
When I entered the original bit sequence with preceding zeros 01100111 01110001 10101111 01000001 I got the float number 1.1413232E24 and not 21.93.

I know that there are more possibilities of ordering and combining bytes to get e.g. a float. You have big-endian and little-endian (see Wikipedia about Endianness). This has a relation with the hardware platform you are using.

So I tried the sequence: 01000001 10101111 01110001 01100111 (which takes the ‘last’ byte first, then the third, second and first byte). The converter now gave me the floating-point number  21.930372 which is not exactly 21.93 but close enough to continue.

The explanation for the difference between 21.93 and 21.930372 can be found on the Arduino Reference page about Serial.print. Where the second example shows: Serial.print(1.23456) gives “1.23”, in other words the float is rounded or capped to two decimals.

This difference also explains the difference in bit sequence returned by the converter.

Knowing this I can continue sending, receiving and translating data to build my own WSN solution with central reporting functionality.


LDR and the JeeNode

Your ads will be inserted here by

Easy Plugin for AdSense.

Please go to the plugin admin page to
Paste your ad code OR
Suppress this ad slot.

In a previous post I gave an example of an LDR with the Arduino. In case you want to use it with a JeeNode you can connect the LDR between the AIO and GND. JeeLabs has a great page about LDR in combination with the on-board RF12 chipset to transmit the data between two nodes. A first step to your own Wireless Sensor Network (WSN).

I’ll give a small code sample just to read the measure light values when the LDR is connect between AIO (A) and GND (G) of port 3 of your JeeNode. For the extended code version please visit the original page at JeeLabs.

#include <Ports.h>
#include <RF12.h>

Port ldr (3);

void setup () {

void loop()
    // Measure value; convert the 0..1023 value to a 0.255 value
     byte value = 255 - ldr.anaRead() / 4;

    // Print the 'light  value'
    Serial.println((int) value);

   // wait for a second





JeeNode and OOK433 plug

Besides an Arduino Mega 2560 I can also use a JeeNode to do some experiments. The JeeNode is made based upon the Arduino but it has several differences. Like, it has fewer ports, it runs on 3.3V instead of 5V, it is smaller and has I2C support. Another great feature is the RFM12B wireless RF chipset that can be used to let JeeNodes communicate with eachother. Take a look at the JeeLabs blog for a ton of information, it is really great.

Because one of the wishes for my domotica solution is controlling KAKU devices a 433Mhz OOK RF receiver and transmitter is needed.  JeeLabs has a nice solution; the OOK 433 plug.

This plug has two 433 Mhz chipsets; one to send and one to receive signals. KAKU uses On-Off-keying (OOK) modulation for sending and receiving signals.

KAKU remote YCT-102

I assembled the plug and tested the ookDecoder.pde sketch (look at the bottom of the page), together with my KAKU YCT-102 remote. I was lucky as it worked right away; I read that some people weren’t able to get it working in combination with another KAKU remote (probably an older version).

It also works with the KAKU doorbell transmitter (ACDB-6500BC).

One thing to mention is that the sketch decodes the signals as ‘HEZ’ signals instead of ‘KAKU’ signals. Some other website also mentioned that the signals of the UCR-4285 universal KAKU remote were also recognized as ‘HEZ’ signals.

However, if you remove  ‘HezDecoder hez;’ in the ookDecoder.pde sketch the signals will show up as KAKU commands!

As for now I haven’t tried to send KAKU commands so I don’t know if that works in combination with my KAKU socket units.

Because I cannot find the webpage to download the ookDecoder.pde sketch I include it below. All credits go to Jean-Claude (owner of JeeLabs and creator of the JeeNode hardware) see the comments in the code.


// New code to decode OOK signals from weather sensors, etc.
// 2010-04-11 <>
// $Id: ookDecoder.pde 7527 2011-04-11 01:57:48Z jcw $

#include "decoders.h"

#define USE_433 1
#define USE_868 0

#if USE_433
OregonDecoder orsc;
CrestaDecoder cres;
KakuDecoder kaku;
XrfDecoder xrf;
HezDecoder hez;

#if USE_868
VisonicDecoder viso;
EMxDecoder emx;
KSxDecoder ksx;
FSxDecoder fsx;

#define PORT 1

volatile word pulse;

    static word last;
    // determine the pulse length in microseconds, for either polarity
    pulse = micros() - last;
    last += pulse;

void reportSerial (const char* s, DecodeOOK& decoder) {
    byte pos;
    const byte* data = decoder.getData(pos);
    Serial.print(' ');
    for (byte i = 0; i < pos; ++i) {
        byte d = data[i];
        Serial.print(d & 0x0F, HEX);
        Serial.print(d >> 4, HEX);
    // Serial.print(' ');
    // Serial.print(millis() / 1000);

void setup () {
    pinMode(13 + PORT, INPUT);  // use the AIO pin
    digitalWrite(13 + PORT, 1); // enable pull-up

    // use analog comparator to switch at 1.1V bandgap transition
    ACSR = _BV(ACBG) | _BV(ACI) | _BV(ACIE);

    // set ADC mux to the proper port
    ADCSRA &= ~ bit(ADEN);
    ADCSRB |= bit(ACME);
    ADMUX = PORT - 1;

void loop () {
    word p = pulse;
    pulse = 0;

#if USE_433
    if (p != 0) {
        if (orsc.nextPulse(p))
            reportSerial("ORSC", orsc);        
        if (cres.nextPulse(p))
            reportSerial("CRES", cres);        
        if (kaku.nextPulse(p))
            reportSerial("KAKU", kaku);        
        if (xrf.nextPulse(p))
            reportSerial("XRF", xrf);        
        if (hez.nextPulse(p))
            reportSerial("HEZ", hez);        

#if USE_868
    if (p != 0) {
        if (viso.nextPulse(p))
            reportSerial("VISO", viso);        
        if (emx.nextPulse(p))
            reportSerial("EMX", emx);        
        if (ksx.nextPulse(p))
            reportSerial("KSX", ksx);        
        if (fsx.nextPulse(p))
            reportSerial("FSX", fsx);        

Nodo can do KAKU too …