RF Communication using nrf24L01 and Nodejs addon

Recently I started experimenting with radio communication with low cost nrf24L01 modules. These modules are very cheap compare to XBee modules which I used earlier. With these nrf24 modules we could enable wireless communication between Arduinos and Raspberry pi very effectively and economically. For my experiment I used two nrf24 modules, one connected to an Arduino Uno and another to a Raspberry pi 1. Here is the pin connection details

Seq	NRF24L01	RPi	Arduino Uno
1	GND	25 (GND)	GND
2	VCC	17 (3.3v)	3.3v
3	CE	15	7
4	CSN	24	8
5	SCK	23	13
6	MOSI	19	11
7	MISO	21	12
8	IRQ	–	–

For testing the communication, I used the RF24Network library, which is very good and has good documentation. Also it comes with e.g for both Arduino and RPi. So I didn’t write any single code just used the e.g and able to see the communication working, initially I had some troubles and at the end every thing worked well, I can see the data coming from Arduino in RPi.

My intention is to use these modules in RPi and write code in nodejs. Unfortunately there is no nodejs support for this library. So last night I decided to write a nodejs addon for this C/C++ library. I didn’t had any experience in writing a nodejs addon, I spend an hour understanding the Nan and creating very simple addons. Then I started writing the addon for RF24Network, this task was very hard than trying with simple hello world addons.

Node-gyp was keep on failing when it tries to compile the RFNetwork modules. In my searches I realized that node-gyp uses make utility and I need to add the C/C++ files of this library. At the end I could compile the node addon. See the binding.gyp file

{
  "targets": [
    {
      "target_name": "nrf24Node",
      "sources": [ 
        "nrf24Node.cc",
        "RF24/RF24.cpp", 
        "RF24/utility/RPi/spi.cpp",
        "RF24/utility/RPi/bcm2835.c",
        "RF24/utility/RPi/interrupt.cpp",
        "RF24Network/RF24Network.cpp",
        "RF24Network/Sync.cpp"
        ],
      "include_dirs": [
        "<!(node -e \"require('nan')\")",
        "RF24Network",
        "RF24"
      ],
      "link_settings": {
        "libraries": [
          "-RF24",
          "-RFNetwork"
        ]
      }   
    }
  ]
}

I should say, I am just a beginner in node-gyp and this binding.gyp might need some improvements. Anyway with this gyp file, the compilation succeeded.

Next is to create the addon file. Here I had to learn more about the data types of Nan and Callbacks. I started simple functions to begin with and compile again, then moved on to next. I took more time in understanding callbacks which allows the addon to call javascript callback functions. Also spend a lot of time in understanding threading and creating a module to continuous listening of incoming messages and trigger the callback function, so that nodejs can process those incoming messages. I use libuv for threading, it seems more easy to understand than Async worker modules in Nan.

That whole night I spend learning and writing and refactoring the addon, I finished the module by early morning. By that time I could write a nodejs app and could listen to incoming messages.

Here is the sample code in node js to listen and acknowledge the message back to the sender.

var rf24 = require('./build/Release/nrf24Node.node');
rf24.begin(90,00);
rf24.printDetails();
rf24.write(1,"Ack");

rf24.readAsync(function(from, data){
    console.log(from);
    console.log(data);
    rf24.write(from,"Ack");
});


process.on('SIGINT', exitHandler);

function exitHandler() {
    process.exit();
    rf24.close();
}

Here is the complete addon. The code is uploaded to github, with the steps to compile and use it your own nodejs applications.

#include <nan.h>
#include <v8.h>
#include <RF24.h>
#include <RF24Network.h>
#include <iostream>
#include <ctime>
#include <stdio.h>
#include <time.h>
#include <string>
using namespace Nan;
using namespace v8;

RF24 radio(RPI_V2_GPIO_P1_15, BCM2835_SPI_CS0, BCM2835_SPI_SPEED_8MHZ);
RF24Network network(radio);

Nan::Callback *cbPeriodic;
uv_async_t* async;

struct payload_t {                  // Structure of our payload
  char msg[24];
};

struct payload_pi {                  
  uint16_t fromNode;
  char msg[24];
};

//--------------------------------------------------------------------------
//Below functions are just replica of RF24Network functions.
//No need to use these functions in you app.
NAN_METHOD(BeginRadio) {
  radio.begin();
}

NAN_METHOD(BeginNetwork){
  uint16_t channel = info[0]->Uint32Value();
  uint16_t thisNode = info[0]->Uint32Value();
  network.begin(channel,thisNode);
}

NAN_METHOD(Update) {
  network.update();
}

NAN_METHOD(Available) {
  v8::Local<v8::Boolean> status = Nan::New(network.available());
  info.GetReturnValue().Set(status);
}

NAN_METHOD(Read) {
  payload_t payload;
  RF24NetworkHeader header;
  network.read(header,&payload,sizeof(payload));
  info.GetReturnValue().Set(Nan::New(payload.msg).ToLocalChecked());
}
//--------------------------------------------------------------------------------

NAN_METHOD(Begin){
  if (info.Length() < 2)
      return Nan::ThrowTypeError("Should pass Channel and Node id");

  uint16_t channel = info[0]->Uint32Value();
  uint16_t thisNode = info[1]->Uint32Value();

    radio.begin();
    delay(5);
    network.begin(channel, thisNode);
}

NAN_METHOD(Write){
  if (info.Length() < 2)
      return Nan::ThrowTypeError("Should pass Receiver Node Id and Message");  

  uint16_t otherNode = info[0]->Uint32Value();
  v8::String::Utf8Value message(info[1]->ToString());
  std::string msg = std::string(*message);
  payload_t payload;
  strncpy(payload.msg, msg.c_str(),24);
  
  RF24NetworkHeader header(otherNode);
  bool ok = network.write(header,&payload, sizeof(payload));
  info.GetReturnValue().Set(ok);
}


void keepListen(void *arg) {
    while(1)
    {
        network.update();
        while (network.available()) { 
              RF24NetworkHeader header; 
               payload_t payload;
              network.read(header,&payload,sizeof(payload));

        payload_pi localPayload;
        localPayload.fromNode = header.from_node;
        strncpy(localPayload.msg, payload.msg, 24);
        async->data = (void *) &localPayload;
        uv_async_send(async);
        }
        delay(2000);
    }
}

void doCallback(uv_async_t *handle){
  payload_pi* p = (struct payload_pi*)handle->data;
  v8::Handle<v8::Value> argv[2] = {
      Nan::New(p->fromNode),
      Nan::New(p->msg).ToLocalChecked()
    };
  cbPeriodic->Call(2, argv);
}  

NAN_METHOD(ReadAsync){
  if (info.Length() <= 0)
    return Nan::ThrowTypeError("Should pass a callback function");
  if (info.Length() > 0 && !info[0]->IsFunction())
      return Nan::ThrowTypeError("Provided callback must be a function");

  cbPeriodic = new Nan::Callback(info[0].As<Function>());
  async = (uv_async_t*)malloc(sizeof(uv_async_t));
  uv_async_init(uv_default_loop(), async, doCallback);
  uv_thread_t id;
  uv_thread_create(&id, keepListen, NULL);
  uv_run(uv_default_loop(), UV_RUN_DEFAULT);
}

NAN_METHOD(PrintDetails) {
  radio.printDetails();
}

NAN_METHOD(Close){
  uv_close((uv_handle_t*) &async, NULL);
}


NAN_MODULE_INIT(Init){
    Nan::Set(target, New<String>("beginRadio").ToLocalChecked(),
        GetFunction(New<FunctionTemplate>(BeginRadio)).ToLocalChecked());

    Nan::Set(target, New<String>("beginNetwork").ToLocalChecked(),
        GetFunction(New<FunctionTemplate>(BeginNetwork)).ToLocalChecked());

    Nan::Set(target, New<String>("update").ToLocalChecked(),
        GetFunction(New<FunctionTemplate>(Update)).ToLocalChecked());

    Nan::Set(target, New<String>("printDetails").ToLocalChecked(),
        GetFunction(New<FunctionTemplate>(PrintDetails)).ToLocalChecked());

    Nan::Set(target, New<String>("available").ToLocalChecked(),
        GetFunction(New<FunctionTemplate>(Available)).ToLocalChecked());

    Nan::Set(target, New<String>("read").ToLocalChecked(),
        GetFunction(New<FunctionTemplate>(Read)).ToLocalChecked());         

    Nan::Set(target, New<String>("readAsync").ToLocalChecked(),
        GetFunction(New<FunctionTemplate>(ReadAsync)).ToLocalChecked());

    Nan::Set(target, New<String>("write").ToLocalChecked(),
        GetFunction(New<FunctionTemplate>(Write)).ToLocalChecked());        

    Nan::Set(target, New<String>("close").ToLocalChecked(),
        GetFunction(New<FunctionTemplate>(Close)).ToLocalChecked()); 

    Nan::Set(target, New<String>("begin").ToLocalChecked(),
        GetFunction(New<FunctionTemplate>(Begin)).ToLocalChecked());                           
}

NODE_MODULE(nrf24Node, Init)

All the credit goes to the developers of RF24 and RF24Network library, I just created an addon for the great library. Along the way I learned a lot and could finish the nodejs addon.

Happy coding…

Written by Sony Arouje

February 5, 2017 at 4:57 pm

Posted in Arduino, JavaScript, Raspberry Pi

Tagged with nodejs addon, nrf24L01, RF24, RF24Network

Sony Arouje