@jason2866/serialport-bindings-cpp 0.0.0-development

package/src/darwin_list.h

@@ -0,0 +1,68 @@
+#ifndef PACKAGES_SERIALPORT_SRC_DARWIN_LIST_H_
+#define PACKAGES_SERIALPORT_SRC_DARWIN_LIST_H_
+#include <sys/param.h>  // For MAXPATHLEN
+#include <napi.h>
+#include <uv.h>
+#include <list>
+#include <string>
+
+#define ERROR_STRING_SIZE 1088
+
+Napi::Value List(const Napi::CallbackInfo& info);
+void setIfNotEmpty(Napi::Object item, std::string key, const char *value);
+
+struct ListResultItem {
+  std::string path;
+  std::string manufacturer;
+  std::string serialNumber;
+  std::string pnpId;
+  std::string locationId;
+  std::string vendorId;
+  std::string productId;
+};
+
+struct ListBaton : public Napi::AsyncWorker {
+  ListBaton(Napi::Function& callback) : Napi::AsyncWorker(callback, "node-serialport:ListBaton"), 
+  errorString() {}
+  std::list<ListResultItem*> results;
+  char errorString[ERROR_STRING_SIZE];
+  void Execute() override;
+
+  void OnOK() override {
+    Napi::Env env = Env();
+    Napi::HandleScope scope(env);
+    Napi::Array result = Napi::Array::New(env);
+    int i = 0;
+    for (std::list<ListResultItem*>::iterator it = results.begin(); it != results.end(); ++it, i++) {
+      Napi::Object item = Napi::Object::New(env);
+
+      setIfNotEmpty(item, "path", (*it)->path.c_str());
+      setIfNotEmpty(item, "manufacturer", (*it)->manufacturer.c_str());
+      setIfNotEmpty(item, "serialNumber", (*it)->serialNumber.c_str());
+      setIfNotEmpty(item, "pnpId", (*it)->pnpId.c_str());
+      setIfNotEmpty(item, "locationId", (*it)->locationId.c_str());
+      setIfNotEmpty(item, "vendorId", (*it)->vendorId.c_str());
+      setIfNotEmpty(item, "productId", (*it)->productId.c_str());
+
+      (result).Set(i, item);
+    }
+    Callback().Call({env.Null(), result});
+  }
+};
+
+typedef struct SerialDevice {
+    char port[MAXPATHLEN];
+    char locationId[MAXPATHLEN];
+    char vendorId[MAXPATHLEN];
+    char productId[MAXPATHLEN];
+    char manufacturer[MAXPATHLEN];
+    char serialNumber[MAXPATHLEN];
+} stSerialDevice;
+
+typedef struct DeviceListItem {
+    struct SerialDevice value;
+    struct DeviceListItem *next;
+    int* length;
+} stDeviceListItem;
+
+#endif  // PACKAGES_SERIALPORT_SRC_DARWIN_LIST_H_

package/src/poller.cpp

@@ -0,0 +1,166 @@
+#include <napi.h>
+#include <uv.h>
+#include "./poller.h"
+
+Poller::Poller (const Napi::CallbackInfo &info) : Napi::ObjectWrap<Poller>(info)
+  {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  if (!info[0].IsNumber()) {
+    Napi::TypeError::New(env, "First argument must be an int").ThrowAsJavaScriptException();
+    return;
+  }
+  this->fd = info[0].As<Napi::Number>().Int32Value();
+
+  // callback
+  if (!info[1].IsFunction()) {
+    Napi::TypeError::New(env, "Second argument must be a function").ThrowAsJavaScriptException();
+    return;
+  }
+  this->callback = Napi::Persistent(info[1].As<Napi::Function>());
+
+  this->poll_handle = new uv_poll_t();
+  memset(this->poll_handle, 0, sizeof(uv_poll_t));
+  poll_handle->data = this;
+  int status = uv_poll_init(uv_default_loop(), poll_handle, fd);
+  if (0 != status) {
+    Napi::Error::New(env, uv_strerror(status)).ThrowAsJavaScriptException();
+    return;
+  }
+  uv_poll_init_success = true;
+}
+
+Poller::~Poller() {
+  // if we call uv_poll_stop after uv_poll_init failed we segfault
+  if (uv_poll_init_success) {
+    uv_poll_stop(poll_handle);
+    uv_unref(reinterpret_cast<uv_handle_t*> (poll_handle));
+    uv_close(reinterpret_cast<uv_handle_t*> (poll_handle), Poller::onClose);
+  } else {
+    delete poll_handle;
+  }
+  return;
+}
+
+void Poller::onClose(uv_handle_t* poll_handle) {
+  // fprintf(stdout, "~Poller is closed\n");
+  delete poll_handle;
+}
+
+// Events can be UV_READABLE | UV_WRITABLE | UV_DISCONNECT
+void Poller::poll(Napi::Env env, int events) {
+  Napi::HandleScope scope(env);
+  // fprintf(stdout, "Poller:poll for %d\n", events);
+  this->events = this->events | events;
+  int status = uv_poll_start(this->poll_handle, events, Poller::onData);
+  if (0 != status) {
+    Napi::Error::New(env, uv_strerror(status)).ThrowAsJavaScriptException();
+  }
+  return;
+}
+
+void Poller::stop(Napi::Env env) {
+  Napi::HandleScope scope(env);
+  int status = uv_poll_stop(this->poll_handle);
+  if (0 != status) {
+    Napi::Error::New(env, uv_strerror(status)).ThrowAsJavaScriptException();
+  }
+  return;
+}
+
+int Poller::_stop() {
+  return uv_poll_stop(poll_handle);
+}
+
+void Poller::onData(uv_poll_t* handle, int status, int events) {
+  Poller* obj = static_cast<Poller*>(handle->data);
+  Napi::Env env = obj->Env();
+  Napi::HandleScope scope(env);
+
+  // if Error
+  if (0 != status) {
+    // fprintf(stdout, "OnData Error status=%s events=%d\n", uv_strerror(status), events);
+    obj->_stop(); // doesn't matter if this errors
+    obj->callback.Call({Napi::Error::New(env, uv_strerror(status)).Value(), env.Undefined()});
+  } else {
+    // fprintf(stdout, "OnData status=%d events=%d subscribed=%d\n", status, events, obj->events);
+    // remove triggered events from the poll
+    int newEvents = obj->events & ~events;
+    obj->poll(env, newEvents);
+    obj->callback.Call({env.Null(), Napi::Number::New(env, events)});
+  }
+
+}
+
+Napi::Object Poller::Init(Napi::Env env, Napi::Object exports) {
+  Napi::Function func = DefineClass(env, "Poller", {
+    StaticMethod<&Poller::New>("New"),
+    InstanceMethod<&Poller::poll>("poll"),
+    InstanceMethod<&Poller::stop>("stop"),
+    InstanceMethod<&Poller::destroy>("destroy"),
+  });
+
+  Napi::FunctionReference* constructor = new Napi::FunctionReference();
+
+  *constructor = Napi::Persistent(func);
+  exports.Set("Poller", func);
+
+  env.SetInstanceData<Napi::FunctionReference>(constructor);
+
+  return exports;
+}
+
+Napi::Value Poller::New(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  if (!info[0].IsNumber()) {
+    Napi::TypeError::New(env, "fd must be an int").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  Napi::Value  fd = info[0];
+  if (!info[1].IsFunction()) {
+    Napi::TypeError::New(env, "cb must be a function").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  Napi::Function callback = info[1].As<Napi::Function>();
+  Napi::FunctionReference* constructor = info.Env().GetInstanceData<Napi::FunctionReference>();
+  return constructor->New({fd, callback});
+}
+
+Napi::Value Poller::poll(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  Poller* obj = this;
+  if (!info[0].IsNumber()) {
+    Napi::TypeError::New(env, "events must be an int").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  int events = info[0].As<Napi::Number>().Int32Value();
+  obj->poll(env, events);
+  return env.Undefined();
+}
+
+Napi::Value Poller::stop(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  this->stop(env);
+  return env.Undefined();
+}
+
+Napi::Value Poller::destroy(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  Poller* obj = this;
+  // TODO Fix destruction Segfault
+  obj->Reset();
+  // delete obj;
+  return env.Undefined();
+}
+
+inline Napi::FunctionReference & Poller::constructor() {
+  static Napi::FunctionReference my_constructor;
+  // TODO Check if required
+  // my_constructor.SuppressDestruct();
+  return my_constructor;
+}

package/src/poller.h

@@ -0,0 +1,35 @@
+#ifndef PACKAGES_SERIALPORT_SRC_POLLER_H_
+#define PACKAGES_SERIALPORT_SRC_POLLER_H_
+
+#include <napi.h>
+#include <uv.h>
+
+class Poller : public Napi::ObjectWrap<Poller> {
+ public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  explicit Poller(const Napi::CallbackInfo &info);
+  static Napi::Value New(const Napi::CallbackInfo& info);
+  static void onData(uv_poll_t* handle, int status, int events);
+  static void onClose(uv_handle_t* poll_handle);
+  ~Poller();
+
+ private:
+  int fd;
+  uv_poll_t* poll_handle = nullptr;
+	Napi::FunctionReference callback;
+  bool uv_poll_init_success = false;
+
+  // can this be read off of poll_handle?
+  int events = 0;
+
+  void poll(Napi::Env env, int events);
+  void stop(Napi::Env env);
+  int _stop();
+
+  Napi::Value poll(const Napi::CallbackInfo& info);
+  Napi::Value stop(const Napi::CallbackInfo& info);
+  Napi::Value destroy(const Napi::CallbackInfo& info);
+  static inline Napi::FunctionReference & constructor();
+};
+
+#endif  // PACKAGES_SERIALPORT_SRC_POLLER_H_

package/src/serialport.cpp

@@ -0,0 +1,342 @@
+#include "./serialport.h"
+
+#ifdef __APPLE__
+  #include "./darwin_list.h"
+#endif
+
+#ifdef WIN32
+  #define strncasecmp strnicmp
+  #include "./serialport_win.h"
+#else
+  #include "./poller.h"
+#endif
+
+Napi::Value getValueFromObject(Napi::Object options, std::string key) {
+  Napi::String str = Napi::String::New(options.Env(), key);
+  return (options).Get(str);
+}
+
+int getIntFromObject(Napi::Object options, std::string key) {
+  return getValueFromObject(options, key).ToNumber().Int64Value();
+}
+
+bool getBoolFromObject(Napi::Object options, std::string key) {
+  return getValueFromObject(options, key).ToBoolean().Value();
+}
+
+Napi::String getStringFromObj(Napi::Object options, std::string key) {
+  return getValueFromObject(options, key).ToString();
+}
+
+double getDoubleFromObject(Napi::Object options, std::string key) {
+  return getValueFromObject(options, key).ToNumber().DoubleValue();
+}
+
+Napi::Value Open(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  // path
+  if (!info[0].IsString()) {
+    Napi::TypeError::New(env, "First argument must be a string").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  std::string path = info[0].ToString().Utf8Value();
+
+  // options
+  if (!info[1].IsObject()) {
+    Napi::TypeError::New(env, "Second argument must be an object").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  Napi::Object options = info[1].ToObject();
+
+  // callback
+  if (!info[2].IsFunction()) {
+    Napi::TypeError::New(env, "Third argument must be a function").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  Napi::Function callback = info[2].As<Napi::Function>();
+  OpenBaton* baton = new OpenBaton(callback);
+  snprintf(baton->path, sizeof(baton->path), "%s", path.c_str());
+  baton->baudRate = getIntFromObject(options, "baudRate");
+  baton->dataBits = getIntFromObject(options, "dataBits");
+  baton->parity = ToParityEnum(getStringFromObj(options, "parity"));
+  baton->stopBits = ToStopBitEnum(getDoubleFromObject(options, "stopBits"));
+  baton->rtscts = getBoolFromObject(options, "rtscts");
+  baton->rtsMode = ToRtsModeEnum(getStringFromObj(options, "rtsMode"));
+  baton->xon = getBoolFromObject(options, "xon");
+  baton->xoff = getBoolFromObject(options, "xoff");
+  baton->xany = getBoolFromObject(options, "xany");
+  baton->hupcl = getBoolFromObject(options, "hupcl");
+  baton->lock = getBoolFromObject(options, "lock");
+
+  #ifndef WIN32
+    baton->vmin = getIntFromObject(options, "vmin");
+    baton->vtime = getIntFromObject(options, "vtime");
+  #endif
+
+  baton->Queue();
+  return env.Undefined();
+}
+
+Napi::Value Update(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  // file descriptor
+  if (!info[0].IsNumber()) {
+    Napi::TypeError::New(env, "First argument must be an int").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  int fd = info[0].As<Napi::Number>().Int32Value();
+
+  // options
+  if (!info[1].IsObject()) {
+    Napi::TypeError::New(env, "Second argument must be an object").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  Napi::Object options = info[1].ToObject();
+
+  if (!(options).Has("baudRate")) {
+    Napi::TypeError::New(env, "\"baudRate\" must be set on options object").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  // callback
+  if (!info[2].IsFunction()) {
+    Napi::TypeError::New(env, "Third argument must be a function").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Function callback = info[2].As<Napi::Function>();
+  ConnectionOptionsBaton* baton = new ConnectionOptionsBaton(callback);
+
+  baton->fd = fd;
+  baton->baudRate = getIntFromObject(options, "baudRate");
+
+  baton->Queue();
+  return env.Undefined();
+}
+
+Napi::Value Close(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  // file descriptor
+  if (!info[0].IsNumber()) {
+    Napi::TypeError::New(env, "First argument must be an int").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  // callback
+  if (!info[1].IsFunction()) {
+    Napi::TypeError::New(env, "Second argument must be a function").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Function callback = info[1].As<Napi::Function>();
+  CloseBaton* baton = new CloseBaton(callback);
+  baton->fd = info[0].ToNumber().Int64Value();;
+
+  baton->Queue();
+  return env.Undefined();
+}
+
+Napi::Value Flush(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  // file descriptor
+  if (!info[0].IsNumber()) {
+    Napi::TypeError::New(env, "First argument must be an int").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  int fd = info[0].As<Napi::Number>().Int32Value();
+
+  // callback
+  if (!info[1].IsFunction()) {
+    Napi::TypeError::New(env, "Second argument must be a function").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  Napi::Function callback = info[1].As<Napi::Function>();
+
+  FlushBaton* baton = new FlushBaton(callback);
+  baton->fd = fd;
+
+  baton->Queue();
+  return env.Undefined();
+}
+
+Napi::Value Set(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  // file descriptor
+  if (!info[0].IsNumber()) {
+    Napi::TypeError::New(env, "First argument must be an int").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  int fd = info[0].As<Napi::Number>().Int32Value();
+
+  // options
+  if (!info[1].IsObject()) {
+    Napi::TypeError::New(env, "Second argument must be an object").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  Napi::Object options = info[1].ToObject();
+
+  // callback
+  if (!info[2].IsFunction()) {
+    Napi::TypeError::New(env, "Third argument must be a function").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  Napi::Function callback = info[2].As<Napi::Function>();
+
+  SetBaton* baton = new SetBaton(callback);
+  baton->fd = fd;
+  baton->brk = getBoolFromObject(options, "brk");
+  baton->rts = getBoolFromObject(options, "rts");
+  baton->cts = getBoolFromObject(options, "cts");
+  baton->dtr = getBoolFromObject(options, "dtr");
+  baton->dsr = getBoolFromObject(options, "dsr");
+  baton->lowLatency = getBoolFromObject(options, "lowLatency");
+
+  baton->Queue();
+  return env.Undefined();
+}
+
+Napi::Value Get(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  // file descriptor
+  if (!info[0].IsNumber()) {
+    Napi::TypeError::New(env, "First argument must be an int").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  int fd = info[0].As<Napi::Number>().Int32Value();
+
+  // callback
+  if (!info[1].IsFunction()) {
+    Napi::TypeError::New(env, "Second argument must be a function").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  Napi::Function callback = info[1].As<Napi::Function>();
+
+  GetBaton* baton = new GetBaton(callback);
+  baton->fd = fd;
+  baton->cts = false;
+  baton->dsr = false;
+  baton->dcd = false;
+  baton->lowLatency = false;
+
+  baton->Queue();
+  return env.Undefined();
+}
+
+Napi::Value GetBaudRate(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  // file descriptor
+  if (!info[0].IsNumber()) {
+    Napi::TypeError::New(env, "First argument must be an int").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  int fd = info[0].As<Napi::Number>().Int32Value();
+
+  // callback
+  if (!info[1].IsFunction()) {
+    Napi::TypeError::New(env, "Second argument must be a function").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Function callback = info[1].As<Napi::Function>();
+  GetBaudRateBaton* baton = new GetBaudRateBaton(callback);
+  baton->fd = fd;
+  baton->baudRate = 0;
+
+  baton->Queue();
+  return env.Undefined();
+}
+
+Napi::Value Drain(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  // file descriptor
+  if (!info[0].IsNumber()) {
+    Napi::TypeError::New(env, "First argument must be an int").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  int fd = info[0].As<Napi::Number>().Int32Value();
+
+  // callback
+  if (!info[1].IsFunction()) {
+    Napi::TypeError::New(env, "Second argument must be a function").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Function callback = info[1].As<Napi::Function>();
+  DrainBaton* baton = new DrainBaton(callback);
+  baton->fd = fd;
+
+  baton->Queue();
+  return env.Undefined();
+}
+
+inline SerialPortParity ToParityEnum(const Napi::String& napistr) {
+  auto tmp = napistr.Utf8Value();
+  const char* str = tmp.c_str();
+
+  size_t count = strlen(str);
+  SerialPortParity parity = SERIALPORT_PARITY_NONE;
+  if (!strncasecmp(str, "none", count)) {
+    parity = SERIALPORT_PARITY_NONE;
+  } else if (!strncasecmp(str, "even", count)) {
+    parity = SERIALPORT_PARITY_EVEN;
+  } else if (!strncasecmp(str, "mark", count)) {
+    parity = SERIALPORT_PARITY_MARK;
+  } else if (!strncasecmp(str, "odd", count)) {
+    parity = SERIALPORT_PARITY_ODD;
+  } else if (!strncasecmp(str, "space", count)) {
+    parity = SERIALPORT_PARITY_SPACE;
+  }
+  return parity;
+}
+
+ inline SerialPortStopBits ToStopBitEnum(double stopBits) {
+  if (stopBits > 1.4 && stopBits < 1.6) {
+    return SERIALPORT_STOPBITS_ONE_FIVE;
+  }
+  if (stopBits == 2) {
+    return SERIALPORT_STOPBITS_TWO;
+  }
+  return SERIALPORT_STOPBITS_ONE;
+}
+
+inline SerialPortRtsMode ToRtsModeEnum(const Napi::String& napistr) {
+  auto tmp = napistr.Utf8Value();
+  const char* str = tmp.c_str();
+
+  size_t count = strlen(str);
+  SerialPortRtsMode mode = SERIALPORT_RTSMODE_HANDSHAKE;
+  if (!strncasecmp(str, "enable", count)) {
+    mode = SERIALPORT_RTSMODE_ENABLE;
+  } else if (!strncasecmp(str, "handshake", count)) {
+    mode = SERIALPORT_RTSMODE_HANDSHAKE;
+  } else if (!strncasecmp(str, "toggle", count)) {
+    mode = SERIALPORT_RTSMODE_TOGGLE;
+  }
+  return mode;
+}
+
+Napi::Object init(Napi::Env env, Napi::Object exports) {
+  exports.Set("set", Napi::Function::New(env, Set));
+  exports.Set("get", Napi::Function::New(env, Get));
+  exports.Set("getBaudRate", Napi::Function::New(env, GetBaudRate));
+  exports.Set("open", Napi::Function::New(env, Open));
+  exports.Set("update", Napi::Function::New(env, Update));
+  exports.Set("close", Napi::Function::New(env, Close));
+  exports.Set("flush", Napi::Function::New(env, Flush));
+  exports.Set("drain", Napi::Function::New(env, Drain));
+
+  #ifdef __APPLE__
+  exports.Set("list", Napi::Function::New(env, List));
+  #endif
+
+  #ifdef WIN32
+  exports.Set("write", Napi::Function::New(env, Write));
+  exports.Set("read", Napi::Function::New(env, Read));
+  exports.Set("list", Napi::Function::New(env, List));
+  #else
+  Poller::Init(env, exports);
+  #endif
+  return exports;
+}
+
+NODE_API_MODULE(serialport, init);