upgrade 0.0.0-alpha4

Author: L Diaz

LICENSE

@@ -0,0 +1,25 @@
+The MIT License (MIT)
+=====================
+
+Copyright © 2018 Luis Diaz
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the “Software”), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,24 +1,40 @@
+
 # nrf24 - RF24 Radios in the node way
 
-This module enable __nodejs__ to manage __nRF24L01(+)__ radios using javascript syntactic sugar manage seamlessly on linux-based one board computers (RaspberryPi,OrangePi,BeagleBone,Edison,CHIP...). Wide support for SBCs is provided by the *RF24 library* supporting Generic Linux devices with SPIDEV, MRAA, RPi native via BCM* chips, WiringPi or using LittleWire.
+[![GitHub issues](https://img.shields.io/github/issues/ludiazv/node-nrf24.svg)](https://github.com/ludiazv/node-nrf24/issues)
+
+This module enable __nodejs__ (using javascript syntactic sugar) to manage __nRF24L01(+)__ radios on linux-based one board computers (RaspberryPi,OrangePi,BeagleBone,Edison,CHIP...). Wide support for SBCs is provided by the *RF24 library* supporting Generic Linux devices with SPIDEV, MRAA, RPi native via BCM* chips, WiringPi or using LittleWire.
 
-This module is based on the outstanding C++ library optimized by @tmrh20. Please consult this project documentation for **nRF24** [here](http://tmrh20.github.io/RF24/).
+This module is based on the outstanding C++ library optimized by @tmrh20. Please consult this project documentation **nRF24** [here](http://tmrh20.github.io/RF24/) for additional details.
+
+This project has a sister project to enable **Node-RED** to use __nRF24L01(+)__ radios in a seamless way with visual flow programming. Check out the repository [here](https://github.com/ludiazv/node-red-contrib-nrf24).
 
-This project has a sister project enable Node-RED to use __nRF24L01(+)__ radios in a seamless way. Check out the repository [here](TODO)
 
 ## Overview
 
-This node add-on has the following features:
+This nodejs add-on has the following features:
 
 1. Basic __RF24__ radio support.
 2. Create a __RF24Mesh__ network as master or Join to a *RF24Mesh* as node.
-3. Provide a __RF24Gateway__ directly on nodeJs to provide TCP/IP connectivity for your radios.
+3. Provide a __RF24Gateway__ directly on nodeJs to provide TCP/IP connectivity for your radios. *[In development]*
 
 
 ## Installation
 
 ### Prerequisites:
 
+#### SPI enabled
+In order to communicate with the radio linux kernel need to have SPI enabled. In some distributions SPI interface is disabled by default so it's needed to be enabled.
+
+In Rpi Raspbian it can be done using ``raspi-config`` or modifing `` /boot/config.txt ``. Check [here](https://www.raspberrypi.org/documentation/hardware/raspberrypi/spi/README.md) for more details.
+For Rpi DietPi (recommended distribution for headless projects) the procedure is similar.
+
+In Rpi alternatives based on armbian such OrangePi, NaoPi,... please consult armbian documentation [here](https://docs.armbian.com/Hardware_Allwinner_overlays/).
+
+For other SBCs or distributions consult who to activate SPI.
+
+If using Spidev driver (see below) the user executing the nodejs application need to have access to the /dev/spidevX.X files. This can be done in typical distribution adding the user to the ``spi`` group.
+
 #### A working nRF24L01(+) radio
 
 A *nRF24L01(+)* radio must be wired to your system and tested for connection. RF24* libs have several testing examples that can be use for for that purpose.
@@ -49,6 +65,9 @@ An example of wiring for an OrangePi Zero(using SPI 1 bus) and Rpi (using SPI 0
 
 Understand your wiring is critical for hardware initialization as there are not hardware discovery mechanism implemented in the library.
 
+__note__: IRQ pins are not used in current version but planned.
+
+
 #### RF24* libraries installed
 
 RF24* libs must be installed in the system. Please check out  [this](http://tmrh20.github.io/RF24/Linux.html) for detailed installation procedure.
@@ -60,7 +79,7 @@ You can use the installation script in this repository:
 # ./build_rf24libs.sh
 ```
 
-it should work on a typical linux environments. nRF24 c++ support different drivers. SPIDEV driver is recommended as this this the standard portable SPI.
+it should work on a typical linux environments. nRF24 c++ support different drivers. SPIDEV driver is recommended as this this the standard portable SPI. But in principle all drived provides _should_ work in a similar way. This nodejs package has been tested using Rpi driver and Spidev.
 
 ### Install the nrf24 package
 
@@ -410,7 +429,7 @@ rf24.stop_read();
 
 
 ### useWritePipe(addrs)
-
+Define the output pipe to write to. __nRF24L01__ have only one
 
 
 
@@ -431,15 +450,28 @@ TODO
 
 # TODO
 
-- Test bindings
-- Migrate to NAN 2.8 to support queued async msg passing.
+- ~~Test bindings~~
+- ~~Migrate to NAN >2.8 to support queued async msg passing.~~
+- Document Mesh
+- Document Gateway.
 - Get rid off try_abort hack (pending nRF24 lib merge)
 - Implement IRQ management.
-
+- Benchmark IRQ performance.
 
 # Change log
-- v0.0.0 alpha versions
-- v0.0.1 First version
+
+- v0.0.0-alpha4
+  - Documentation improvements.
+  - Basic RF24 additional Testing
+  - Migrated to NAN 2.10.0: Async workers now are queued so no data loss in nodejs.
+  - Cleaned RF24Mesh for after testing.
+  - Test/Example modification to arduino RF24 common pins.
+  - Added License
+
+- v0.0.0-alpha3
+  - Include bindings package to resolve package name
   - Basic RF24 Working stable.
   - RF24Mesh in testing.
   - RF24Gateway in development.
+
+- v0.0.0-alpha1 & 2 versions: Initial implementation of Basic Radio.

binding.gyp

@@ -8,7 +8,7 @@
       "cflags": [
         "-std=c++11","-fexceptions"
       ],
-      'cflags_cc': [ '-fexceptions',"-std=c++11" ],
+      'cflags_cc': [ '-fexceptions',"-std=c++11","-Ofast" ],
       "include_dirs": [
         "<!(node -e \"require('nan')\")",
         "<!(node -e \"require('nan-check')\")",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nrf24",
-  "version": "0.0.0-alpha3",
+  "version": "0.0.0-alpha4",
   "description": "nRF24 (nrf24l01/nrfl24l01+) radios in the nodejs way",
   "main": "index.js",
   "scripts": {
@@ -37,7 +37,7 @@
   "gypfile": true,
   "dependencies": {
     "bindings": "^1.3.0",
-    "nan": "^2.7.0",
+    "nan": "^2.10.0",
     "nan-check": "0.0.6"
   }
 }

rf24.cc

@@ -4,17 +4,21 @@
 #include "rf24.hpp"
 #include "tryabort.hpp"
 
+#ifdef NRF24_DEBUG
+
 std::ostream& operator<<(std::ostream& out, RF24_conf_t &h) {
    return out << "PALevel:" << (int)h.PALevel << " DataRate:" << (int)h.DataRate
               << " Channel:" << (int)h.Channel << " CRCLength:" << (int)h.CRCLength
               << " Retries:("<< (int)h.retriesDelay << "," << (int)h.retriesCount << ")"
               << " PayloadSize:" << (int)h.PayloadSize << " AddressWidth:" << (int)h.AddressWidth;
 }
 
+#endif
+
 static RF24_conf_t DEFAULT_RF24_CONF={ RF24_PA_MIN , RF24_1MBPS , 76 , RF24_CRC_16 , 5, 15, 32, 5 };
 
 /* Reader */
-void nRF24::ReaderWorker::Execute(const Nan::AsyncProgressWorker::ExecutionProgress& progress_) {
+void nRF24::ReaderWorker::Execute(const RF24AsyncWorker::ExecutionProgress& progress_) {
   char frame[32+1];
   uint8_t pipe;
   useconds_t half=poll_timeus/4;
@@ -57,7 +61,7 @@ void nRF24::ReaderWorker::HandleProgressCallback(const char *data, size_t size)
     Nan::CopyBuffer( ((char*)data)+1,size-1).ToLocalChecked(),
     Nan::New(pipe)
   };
-  progress->Call(2, argv);
+  progress->Call(2, argv,this->async_resource);
 }
 
 void nRF24::ReaderWorker::HandleOKCallback() {
@@ -66,7 +70,7 @@ void nRF24::ReaderWorker::HandleOKCallback() {
       Nan::New(stopped_),
       Nan::New(want_stop),
       Nan::New(error_count) };
-      callback->Call(3,argv);
+      callback->Call(3,argv,this->async_resource);
 }
 
 void nRF24::ReaderWorker::stop() {
@@ -141,15 +145,15 @@ bool nRF24::_write(void *data,size_t r_length){
     if(!is_enabled_) return false;
     if(worker_!=NULL) worker_->want_write(true);
     std::lock_guard<std::mutex> guard2(radio_write_mutex); // write lock
-    //std::cout << "try to w" << std::endl;
+
     if(_powerUp() && _transmit()) {
       std::lock_guard<std::mutex> guard(radio_mutex); // radio lock
       try_and_catch_abort([&]() -> void {
               res=radio_->write(data,r_length);
       });
     }
     if(worker_!=NULL) worker_->want_write(false);
-    _listen(); // Back to listen
+    _listen(); // Back to listen TODO- remove this an test.
     return res;
 }
 bool nRF24::_useWritePipe(uint8_t *pipe_name){
@@ -166,7 +170,7 @@ int32_t nRF24::_addReadPipe(uint8_t *pipe_name,bool auto_ack) {
    int i=1;
    if(!is_enabled_) return -1;
    while(used_pipes_[i] && i<6) i++;
-   //std::cout << "Free pipe " << i << std::endl;
+
    if(i<6) {
       std::lock_guard<std::mutex> guard(radio_mutex); // radio lock
       try_and_catch_abort([&]() -> void {

rf24.hpp

@@ -20,26 +20,25 @@ typedef struct RF24_conf {
 
 std::ostream& operator<<(std::ostream& out, RF24_conf_t &h); // Prototype
 
-//typedef Nan::AsyncProgressQueueWorker<char> LFG;
 
 class nRF24 : public Nan::ObjectWrap {
  public:
    // Reader nested class
-   class ReaderWorker : public Nan::AsyncProgressWorker {
+   class ReaderWorker : public RF24AsyncWorker {
     public:
      ReaderWorker(
          Nan::Callback *progress
        , Nan::Callback *callback
        , nRF24& dev)
-       : Nan::AsyncProgressWorker(callback), progress(progress),device(dev)
+       : RF24AsyncWorker(callback), progress(progress),device(dev)
        , want_stop(false),stopped_(true), want_towrite(false), error_count(0)
        , poll_timeus(RF24_DEFAULT_POLLTIME) {
           dev.worker_=this;
         }
      ~ReaderWorker() { device.worker_=NULL; if(progress) delete progress; }
 
      // Main loop for pooling the reading
-     void Execute(const Nan::AsyncProgressWorker::ExecutionProgress& progress);
+     void Execute(const RF24AsyncWorker::ExecutionProgress& progress);
      void HandleProgressCallback(const char *data, size_t size);
      void HandleOKCallback();
 

rf24_config.hpp

@@ -4,10 +4,10 @@
 #include <nan.h>
 #include <nan-check.h>
 #include <RF24.h>
-#include <RF24Network.h>
+/*#include <RF24Network.h>
 #include <RF24Mesh.h>
 #include <RF24Gateway.h>
-
+*/
 
 // config
 #define RF24_DEFAULT_POLLTIME  50*1000   // 50ms default poll wait for reading
@@ -19,5 +19,10 @@
 #define NANCONST(x,v)  (Nan::Set(target,Nan::New(x).ToLocalChecked(),Nan::New(v).ToLocalChecked()))
 #define NANCONSTI(x,v) (Nan::Set(target,Nan::New(x).ToLocalChecked(),Nan::New(v)))
 
+// Old Nan version 2.7.0
+//typedef Nan::AsyncProgressWorker RF24AsyncWorker;
+// For Nan version > 2.8.0
+typedef Nan::AsyncProgressQueueWorker<char> RF24AsyncWorker;
+
 
 #endif

rf24_util.hpp

@@ -2,7 +2,9 @@
 #define _NRF24_NODE_UTIL_HPP_
 #include<nan.h>
 // For debug
+#ifdef NRF24_DEBUG
 #include<iostream>
+#endif
 
 bool ObjHas(v8::Local<v8::Object> & obj,const std::string & name);
 v8::Local<v8::Value> ObjGet(v8::Local<v8::Object> & obj,const std::string & name);

rf24mesh.cc

@@ -6,7 +6,7 @@
 
 // Main loop for pooling the reading
 
-void nRF24Mesh::MeshWorker::Execute(const Nan::AsyncProgressWorker::ExecutionProgress& progress_) {
+void nRF24Mesh::MeshWorker::Execute(const RF24AsyncWorker::ExecutionProgress& progress_) {
   stopped_=false;
   useconds_t half=poll_timeus/4;
   nRF24Mesh::MeshFrame frame;
@@ -48,7 +48,7 @@ void nRF24Mesh::MeshWorker::HandleProgressCallback(const char *data, size_t size
      Nan::CopyBuffer((char*)f->data,f->size).ToLocalChecked()
    };
 
-   progress->Call(2, argv);
+   progress->Call(2, argv,this->async_resource);
 }
 
 void nRF24Mesh::MeshWorker::HandleOKCallback() {
@@ -57,7 +57,7 @@ void nRF24Mesh::MeshWorker::HandleOKCallback() {
     Nan::New(stopped_),
     Nan::New(want_stop),
     Nan::New(error_count) };
-    callback->Call(3,argv);
+    callback->Call(3,argv,this->async_resource);
 }
 
 void nRF24Mesh::MeshWorker::stop() {
@@ -78,9 +78,8 @@ bool nRF24Mesh::_begin(uint8_t nodeID,uint8_t channel, uint8_t data_rate,uint8_t
   bool res=false;
   std::lock_guard<std::mutex> guard(mesh_mutex);
   if(reset_dhcp) std::remove("dhcplist.txt"); // Clean DHCP if required
-  on_abort(); // Do nothing on abort
+  //on_abort(); // Do nothing on abort
   try_and_catch_abort([&]() -> void {
-          set_debug_abort("begin");
           int ce,cs;
           // Disable referenced radio object
           nrf24._begin(false);
@@ -116,7 +115,6 @@ int16_t nRF24Mesh::_getNodeID(uint16_t address) {
   std::lock_guard<std::mutex> guard(rules_mutex);
   std::lock_guard<std::mutex> guard2(mesh_mutex);
   try_and_catch_abort([&]() -> void {
-          set_debug_abort("getID");
           res=mesh->getNodeID(address);
   });
   return res;
@@ -139,7 +137,6 @@ bool nRF24Mesh::_send(void* data, uint8_t msg_type, uint16_t size, uint8_t nodeI
   bool res=false;
   std::lock_guard<std::mutex> guard(mesh_mutex);
   try_and_catch_abort([&]() -> void {
-          set_debug_abort("write");
           res=mesh->write(data,msg_type,size,nodeID);
           if(!res && !_isMaster()) {
             if(!mesh->checkConnection()) mesh->renewAddress();
@@ -154,28 +151,21 @@ int nRF24Mesh::_loop(nRF24Mesh::MeshFrame &frame) {
   std::lock_guard<std::mutex> guard(mesh_mutex);
   std::lock_guard<std::mutex> guard2(rules_mutex);
   try_and_catch_abort([&]()-> void {
-                          //std::cout << "Thread" << std::this_thread::get_id() << std::endl;
-                          set_debug_abort("update");
                           mesh->update();
-                          set_debug_abort("dhcp");
                           if(_isMaster()) mesh->DHCP();
-                          set_debug_abort("available");
                           if(network->available()) {
                             RF24NetworkHeader header;  // Check the header and try to match rules
-                            set_debug_abort("peek");
                             network->peek(header);
                             NRF24DBG(std::cout << "[Loop] type:" << header.type << std::endl);
                             auto i=rules.begin();
                             for( ;i != rules.end(); ++i) {
-                                if(i->type == 0 || i->type == header.type) { //
-                                  set_debug_abort("read");
+                                if(i->type == 0 || i->type == header.type) { // type match
                                   auto lng=network->read(frame.header,frame.data,i->max_len);
                                   frame.size=lng;
                                   res=1;
                                   break;
                                 }
                             }
-                            set_debug_abort("read2");
                           if(i==rules.end()) {network->read(header,0,0); res=0; } // Ignore frame
                         } else res=0;
   });