Add SEN0228 TAS

DHT11/DHT11.cpp

@@ -3,7 +3,7 @@
 #include <stdlib.h>
 #include <stdint.h>
 #define MAXTIMINGS    85
-#define DHTPIN        25  //wPi pin. physical num 7
+#define DHTPIN        1
 int dht11_dat[5] = { 0, 0, 0, 0, 0 };
  
 int read_dht11_dat()

Makefile

-install: compile
+install:
 	sudo npm -g install forever
 	cd thyme && npm install
 	cd ADXL345 && npm install
 	cd DHT11 && npm install
+	cd SEN0228 && npm install
 
 compile:
 	cd DHT11 && g++ DHT11.cpp -o DHT11 -lwiringPi
+	cd SEN0228 && g++ SEN0228.cpp VEML7700.cpp -o SEN0228 -lwiringPi
 
 start:
 	cd thyme && forever start thyme.js
 	cd ADXL345 && forever start app.js
 	cd DHT11 && forever start app.js
+	cd SEN0228 && forever start app.js
 
 stop:
 	forever stopall

SEN0228/SEN0228.cpp

+#include <stdio.h>
+#include "VEML7700.h"
+
+int main(void)
+{
+	VEML7700 als;
+	float lux;
+
+	als.begin();
+	als.sampleDelay();
+	if(!als.getALSLux(lux))
+		printf("%f", lux);
+}

SEN0228/VEML7700.cpp

+// VEML7700.cpp: VEML7700 Ambient light sensor arduino driver
+//
+// Copyright 2016 Theodore C. Yapo
+//
+// released under MIT License (see file)
+
+#include "VEML7700.h"
+
+VEML7700::
+VEML7700()
+{
+}
+
+void 
+VEML7700::
+begin()
+{
+  fd = wiringPiI2CSetup(I2C_ADDRESS);
+
+  // write initial state to VEML7700
+  register_cache[0] = ( (uint16_t(ALS_GAIN_x2) << ALS_SM_SHIFT) |
+                        (uint16_t(ALS_INTEGRATION_100ms) << ALS_IT_SHIFT) |
+                        (uint16_t(ALS_PERSISTENCE_1) << ALS_PERS_SHIFT) |
+                        (uint16_t(0) << ALS_INT_EN_SHIFT) |
+                        (uint16_t(0) << ALS_SD_SHIFT) );
+  register_cache[1] = 0x0000;
+  register_cache[2] = 0xffff;
+  register_cache[3] = ( (uint16_t(ALS_POWER_MODE_3) << PSM_SHIFT) |
+                        (uint16_t(0) << PSM_EN_SHIFT) );
+  for (uint8_t i=0; i<4; i++){
+    sendData(i, register_cache[i]);
+  }
+
+  // wait at least 2.5ms as per datasheet
+  delay(3);
+}
+
+uint8_t
+VEML7700::
+sendData(uint8_t command, uint16_t data)
+{
+  if (wiringPiI2CWriteReg16(fd, command, data) == -1){
+    return STATUS_ERROR;
+  }
+  return STATUS_OK;
+}
+
+uint8_t
+VEML7700::
+receiveData(uint8_t command, uint16_t& data)
+{
+  if ((data = wiringPiI2CReadReg16(fd, command)) == -1){
+    return STATUS_ERROR;
+  }
+  return STATUS_OK;
+}
+
+uint8_t
+VEML7700::
+setGain(als_gain_t gain)
+{
+  uint16_t reg = ( (register_cache[COMMAND_ALS_SM] & ~ALS_SM_MASK) | 
+                   ((uint16_t(gain) << ALS_SM_SHIFT) & ALS_SM_MASK) );
+  register_cache[COMMAND_ALS_SM] = reg;
+  return sendData(COMMAND_ALS_SM, reg);
+}
+
+uint8_t
+VEML7700::
+getGain(als_gain_t& gain)
+{
+  gain = als_gain_t(
+    (register_cache[COMMAND_ALS_SM] & ALS_SM_MASK) >> ALS_SM_SHIFT );
+  return STATUS_OK;
+}
+
+uint8_t
+VEML7700::
+setIntegrationTime(als_itime_t itime)
+{
+  uint16_t reg = ( (register_cache[COMMAND_ALS_IT] & ~ALS_IT_MASK) | 
+                   ((uint16_t(itime) << ALS_IT_SHIFT) & ALS_IT_MASK) );
+  register_cache[COMMAND_ALS_IT] = reg;
+  return sendData(COMMAND_ALS_IT, reg);
+}
+
+uint8_t
+VEML7700::
+getIntegrationTime(als_itime_t& itime)
+{
+  itime = als_itime_t(
+    (register_cache[COMMAND_ALS_IT] & ALS_IT_MASK) >> ALS_IT_SHIFT );
+  return STATUS_OK;
+}
+
+uint8_t
+VEML7700::
+setPersistence(als_persist_t persist)
+{
+  uint16_t reg = ( (register_cache[COMMAND_ALS_PERS] & ~ALS_PERS_MASK) | 
+                   ((uint16_t(persist) << ALS_PERS_SHIFT) & ALS_PERS_MASK) );
+  register_cache[COMMAND_ALS_PERS] = reg;
+  return sendData(COMMAND_ALS_PERS, reg);
+}
+
+uint8_t
+VEML7700::
+setPowerSavingMode(als_powmode_t powmode)
+{
+  uint16_t reg = ( (register_cache[COMMAND_PSM] & ~PSM_MASK) | 
+                   ((uint16_t(powmode) << PSM_SHIFT) & PSM_MASK) );
+  register_cache[COMMAND_PSM] = reg;
+  return sendData(COMMAND_PSM, reg);
+}
+
+uint8_t
+VEML7700::
+setPowerSaving(uint8_t enabled)
+{
+  uint16_t reg = ( (register_cache[COMMAND_PSM_EN] & ~PSM_EN_MASK) | 
+                   ((uint16_t(enabled) << PSM_EN_SHIFT) & PSM_EN_MASK) );
+  register_cache[COMMAND_PSM_EN] = reg;
+  return sendData(COMMAND_PSM_EN, reg);
+}
+
+uint8_t
+VEML7700::
+setInterrupts(uint8_t enabled)
+{
+  uint16_t reg = ( (register_cache[COMMAND_ALS_INT_EN] & ~ALS_INT_EN_MASK) | 
+                   ((uint16_t(enabled) << ALS_INT_EN_SHIFT) & 
+                    ALS_INT_EN_MASK) );
+  register_cache[COMMAND_ALS_INT_EN] = reg;
+  return sendData(COMMAND_ALS_INT_EN, reg);
+}
+
+uint8_t
+VEML7700::
+setPower(uint8_t on)
+{
+  uint16_t reg = ( (register_cache[COMMAND_ALS_SD] & ~ALS_SD_MASK) | 
+                   ((uint16_t(~on) << ALS_SD_SHIFT) & ALS_SD_MASK) );
+  register_cache[COMMAND_ALS_SD] = reg;
+  uint8_t status = sendData(COMMAND_ALS_SD, reg);
+  if (on) {
+    delay(3); // minimu 2.5us delay per datasheet
+  }
+  return status;
+}
+
+uint8_t
+VEML7700::
+setALSHighThreshold(uint16_t thresh)
+{
+  return sendData(COMMAND_ALS_WH, thresh);
+}
+
+uint8_t
+VEML7700::
+setALSLowThreshold(uint16_t thresh)
+{
+  return sendData(COMMAND_ALS_WL, thresh);
+}
+
+uint8_t
+VEML7700::
+getALS(uint16_t& als)
+{
+  return receiveData(COMMAND_ALS, als);
+}
+
+uint8_t
+VEML7700::
+getWhite(uint16_t& white)
+{
+  return receiveData(COMMAND_WHITE, white);
+}
+
+uint8_t
+VEML7700::
+getHighThresholdEvent(uint8_t& event)
+{
+  uint16_t reg;
+  uint8_t status = receiveData(COMMAND_ALS_IF_H, reg);
+  event = (reg & ALS_IF_H_MASK) >> ALS_IF_H_SHIFT;
+  return status;
+}
+
+uint8_t
+VEML7700::
+getLowThresholdEvent(uint8_t& event)
+{
+  uint16_t reg;
+  uint8_t status = receiveData(COMMAND_ALS_IF_L, reg);
+  event = (reg & ALS_IF_L_MASK) >> ALS_IF_L_SHIFT;
+  return status;
+}
+
+void
+VEML7700::
+scaleLux(uint16_t raw_counts, float& lux)
+{
+  als_gain_t gain;
+  als_itime_t itime;
+  getGain(gain);
+  getIntegrationTime(itime);
+
+  float factor1, factor2;
+
+  switch(gain & 0x3){
+  case ALS_GAIN_x1:
+    factor1 = 1.f;
+    break;
+  case ALS_GAIN_x2:
+    factor1 = 0.5f;
+    break;
+  case ALS_GAIN_d8:
+    factor1 = 8.f;
+    break;
+  case ALS_GAIN_d4:
+    factor1 = 4.f;
+    break;
+  default:
+    factor1 = 1.f;
+    break;
+  }
+
+  switch(itime){
+  case ALS_INTEGRATION_25ms:
+    factor2 = 0.2304f;
+    break;
+  case ALS_INTEGRATION_50ms:
+    factor2 = 0.1152f;
+    break;
+  case ALS_INTEGRATION_100ms:
+    factor2 = 0.0576f;
+    break;
+  case ALS_INTEGRATION_200ms:
+    factor2 = 0.0288f;
+    break;
+  case ALS_INTEGRATION_400ms:
+    factor2 = 0.0144f;
+    break;
+  case ALS_INTEGRATION_800ms:
+    factor2 = 0.0072f;
+    break;
+  default:
+    factor2 = 0.2304f;
+    break;
+  }
+
+  lux = raw_counts * factor1 * factor2;
+
+  // apply correction from App. Note for all readings
+  //   using Horner's method
+  lux = lux * (1.0023f + lux * (8.1488e-5f + lux * (-9.3924e-9f + 
+                                                    lux * 6.0135e-13f)));
+}
+
+uint8_t
+VEML7700::
+getALSLux(float& lux)
+{
+  uint16_t raw_counts;
+  uint8_t status = getALS(raw_counts);
+  scaleLux(raw_counts, lux);
+  return status;
+}
+
+uint8_t
+VEML7700::
+getWhiteLux(float& lux)
+{
+  uint16_t raw_counts;
+  uint8_t status = getWhite(raw_counts);
+  scaleLux(raw_counts, lux);
+  return status;
+}
+
+uint8_t
+VEML7700::
+getAutoXLux(float& lux,
+            VEML7700::getCountsFunction counts_func,
+            VEML7700::als_gain_t& auto_gain,
+            VEML7700::als_itime_t& auto_itime,
+            uint16_t& raw_counts)
+{
+  als_gain_t gains[4] = { ALS_GAIN_d8,
+                          ALS_GAIN_d4,
+                          ALS_GAIN_x1,
+                          ALS_GAIN_x2 };
+  als_itime_t itimes[6] = {ALS_INTEGRATION_25ms,
+                           ALS_INTEGRATION_50ms,
+                           ALS_INTEGRATION_100ms,
+                           ALS_INTEGRATION_200ms,
+                           ALS_INTEGRATION_400ms,
+                           ALS_INTEGRATION_800ms };
+
+  uint16_t counts_threshold = 200;
+
+  int8_t itime_idx;
+  uint8_t gain_idx;
+  if (setPower(0)){
+    return STATUS_ERROR;
+  }
+  for (itime_idx = 2; itime_idx < 6; itime_idx++){
+    if (setIntegrationTime(itimes[itime_idx])){
+      return STATUS_ERROR;
+    }
+    for (gain_idx = 0; gain_idx < 4; gain_idx++){
+      if (setGain(gains[gain_idx])){
+        return STATUS_ERROR;
+      }
+      if (setPower(1)){
+        return STATUS_ERROR;
+      }
+      sampleDelay();
+      if ((this->*counts_func)(raw_counts)){
+        return STATUS_ERROR;
+      }
+
+      if (raw_counts > counts_threshold){
+        do {
+          if (raw_counts < 10000){
+            scaleLux(raw_counts, lux);
+            auto_gain = gains[gain_idx];
+            auto_itime = itimes[itime_idx];
+            return STATUS_OK;  
+          }
+          if(setPower(0)){
+            return STATUS_ERROR;
+          }
+          itime_idx--;
+          if (setIntegrationTime(itimes[itime_idx])){
+            return STATUS_ERROR;
+          }          
+          if (setPower(1)){
+            return STATUS_ERROR;
+          }
+          sampleDelay();
+          if ((this->*counts_func)(raw_counts)){
+            return STATUS_ERROR;
+          }
+        } while (itime_idx > 0);
+        scaleLux(raw_counts, lux);
+        auto_gain = gains[gain_idx];
+        auto_itime = itimes[itime_idx];
+        return STATUS_OK;  
+      }
+      if(setPower(0)){
+        return STATUS_ERROR;
+      }
+    }
+  }
+  scaleLux(raw_counts, lux);
+  auto_gain = gains[gain_idx];
+  auto_itime = itimes[itime_idx];
+  return STATUS_OK;
+}
+
+uint8_t
+VEML7700::
+getAutoALSLux(float& lux)
+{
+  VEML7700::als_gain_t auto_gain;
+  VEML7700::als_itime_t auto_itime;
+  uint16_t raw_counts;
+  return getAutoXLux(lux,
+                     &VEML7700::getALS,
+                     auto_gain,
+                     auto_itime,
+                     raw_counts);
+}
+
+uint8_t
+VEML7700::
+getAutoWhiteLux(float& lux)
+{
+  VEML7700::als_gain_t auto_gain;
+  VEML7700::als_itime_t auto_itime;
+  uint16_t raw_counts;
+  return getAutoXLux(lux,
+                     &VEML7700::getWhite,
+                     auto_gain,
+                     auto_itime,
+                     raw_counts);
+}
+
+
+uint8_t
+VEML7700::
+getAutoALSLux(float& lux,
+              VEML7700::als_gain_t& auto_gain,
+              VEML7700::als_itime_t& auto_itime,
+              uint16_t& raw_counts)
+{
+  return getAutoXLux(lux,
+                     &VEML7700::getALS,
+                     auto_gain,
+                     auto_itime,
+                     raw_counts);
+}
+
+uint8_t
+VEML7700::
+getAutoWhiteLux(float& lux,
+                VEML7700::als_gain_t& auto_gain,
+                VEML7700::als_itime_t& auto_itime,
+                uint16_t& raw_counts)
+{
+  return getAutoXLux(lux,
+                     &VEML7700::getWhite,
+                     auto_gain,
+                     auto_itime,
+                     raw_counts);
+}
+
+uint8_t
+VEML7700::
+sampleDelay()
+{
+  als_itime_t itime;
+  getIntegrationTime(itime);
+
+  // extend nominal delay to ensure new sample is generated
+  #define extended_delay(ms) delay(2*(ms))
+
+  switch(itime){
+  case ALS_INTEGRATION_25ms:
+    extended_delay(25);
+    break;
+  case ALS_INTEGRATION_50ms:
+    extended_delay(50);
+    break;
+  case ALS_INTEGRATION_100ms:
+    extended_delay(100);
+    break;
+  case ALS_INTEGRATION_200ms:
+    extended_delay(200);
+    break;
+  case ALS_INTEGRATION_400ms:
+    extended_delay(400);
+    break;
+  case ALS_INTEGRATION_800ms:
+    extended_delay(800);
+    break;
+  default:
+    extended_delay(100);
+    break;
+  }
+}

SEN0228/VEML7700.h

+// VEML7700.h: VEML7700 Ambient light sensor arduino driver
+//
+// Copyright 2016 Theodore C. Yapo
+//
+// released under MIT License (see file)
+
+#include <stdint.h>
+#include <wiringPi.h>
+#include <wiringPiI2C.h>
+
+class VEML7700
+{
+public:
+  enum als_gain_t
+  { ALS_GAIN_x1 = 0x0,    // x 1
+    ALS_GAIN_x2 = 0x1,    // x 2
+    ALS_GAIN_d8 = 0x2,    // x 1/8
+    ALS_GAIN_d4 = 0x3 };  // x 1/4
+  enum als_itime_t
+  { ALS_INTEGRATION_25ms = 0xc,
+    ALS_INTEGRATION_50ms = 0x8,
+    ALS_INTEGRATION_100ms = 0x0,
+    ALS_INTEGRATION_200ms = 0x1,
+    ALS_INTEGRATION_400ms = 0x2,
+    ALS_INTEGRATION_800ms = 0x3 };
+  enum als_persist_t
+  { ALS_PERSISTENCE_1 = 0x0,
+    ALS_PERSISTENCE_2 = 0x1,
+    ALS_PERSISTENCE_4 = 0x2,
+    ALS_PERSISTENCE_8 = 0x3 };
+  enum als_powmode_t
+  { ALS_POWER_MODE_1 = 0x0,
+    ALS_POWER_MODE_2 = 0x1,
+    ALS_POWER_MODE_3 = 0x2,
+    ALS_POWER_MODE_4 = 0x3 };
+  enum { STATUS_OK = 0, STATUS_ERROR = 0xff };
+
+  VEML7700();
+
+  // raw device commands
+  uint8_t setGain(als_gain_t gain);
+  uint8_t getGain(als_gain_t& gain);
+  uint8_t setIntegrationTime(als_itime_t itime);
+  uint8_t getIntegrationTime(als_itime_t& itime);
+  uint8_t setPersistence(als_persist_t persist);
+  uint8_t setPowerSavingMode(als_powmode_t powmode);
+  uint8_t setPowerSaving(uint8_t enabled);
+  uint8_t setInterrupts(uint8_t enabled);
+  uint8_t setPower(uint8_t on);
+  uint8_t setALSHighThreshold(uint16_t thresh);
+  uint8_t setALSLowThreshold(uint16_t thresh);
+  uint8_t getALS(uint16_t& als);
+  uint8_t getWhite(uint16_t& white);
+  uint8_t getHighThresholdEvent(uint8_t& event);
+  uint8_t getLowThresholdEvent(uint8_t& event);
+
+  // higher-level API
+  void begin();
+  uint8_t getALSLux(float& lux);
+  uint8_t getWhiteLux(float& lux);
+  uint8_t getAutoALSLux(float& lux);
+  uint8_t getAutoWhiteLux(float& lux);
+  uint8_t getAutoALSLux(float& lux,
+                        VEML7700::als_gain_t& auto_gain,
+                        VEML7700::als_itime_t& auto_itime,
+                        uint16_t& raw_counts);
+  uint8_t getAutoWhiteLux(float& lux,
+                          VEML7700::als_gain_t& auto_gain,
+                          VEML7700::als_itime_t& auto_itime,
+                          uint16_t& raw_counts);
+  uint8_t sampleDelay();
+  
+private:
+  typedef uint8_t (VEML7700::*getCountsFunction)(uint16_t& counts);
+  enum { I2C_ADDRESS = 0x10 };
+  enum { COMMAND_ALS_SM = 0x00, ALS_SM_MASK = 0x1800, ALS_SM_SHIFT = 11 };
+  enum { COMMAND_ALS_IT = 0x00, ALS_IT_MASK = 0x03c0, ALS_IT_SHIFT = 6 };
+  enum { COMMAND_ALS_PERS = 0x00, ALS_PERS_MASK = 0x0030, ALS_PERS_SHIFT = 4 };
+  enum { COMMAND_ALS_INT_EN = 0x00, ALS_INT_EN_MASK = 0x0002,
+         ALS_INT_EN_SHIFT = 1 };
+  enum { COMMAND_ALS_SD = 0x00,  ALS_SD_MASK = 0x0001, ALS_SD_SHIFT = 0 };
+  enum { COMMAND_ALS_WH = 0x01 };
+  enum { COMMAND_ALS_WL = 0x02 };
+  enum { COMMAND_PSM = 0x03, PSM_MASK = 0x0006, PSM_SHIFT = 1 };
+  enum { COMMAND_PSM_EN = 0x03, PSM_EN_MASK = 0x0001, PSM_EN_SHIFT = 0 };
+  enum { COMMAND_ALS = 0x04 };
+  enum { COMMAND_WHITE = 0x05 };
+  enum { COMMAND_ALS_IF_L = 0x06, ALS_IF_L_MASK = 0x8000, ALS_IF_L_SHIFT = 15 };
+  enum { COMMAND_ALS_IF_H = 0x06, ALS_IF_H_MASK = 0x4000, ALS_IF_H_SHIFT = 14 };
+
+  uint16_t register_cache[4];
+
+  uint8_t sendData(uint8_t command, uint16_t data = 0);
+  uint8_t receiveData(uint8_t command, uint16_t& data);
+  void scaleLux(uint16_t raw_counts, float& lux);
+  uint8_t getAutoXLux(float& lux,
+                      VEML7700::getCountsFunction counts_func,
+                      VEML7700::als_gain_t& auto_gain,
+                      VEML7700::als_itime_t& auto_itime,
+                      uint16_t& raw_counts);
+  int fd;
+
+};

SEN0228/app.js

+/**
+ * Created by ryeubi on 2015-08-31.
+ * Updated 2017.03.06
+ * Made compatible with Thyme v1.7.2
+ */
+
+var net = require('net');
+var util = require('util');
+var fs = require('fs');
+var xml2js = require('xml2js');
+var exec = require("child_process").exec;
+
+var wdt = require('./wdt');
+
+var useparentport = '';
+var useparenthostname = '';
+
+var upload_arr = [];
+var download_arr = [];
+
+var conf = {};
+
+// This is an async file read
+fs.readFile('conf.xml', 'utf-8', function (err, data) {
+    if (err) {
+        console.log("FATAL An error occurred trying to read in the file: " + err);
+        console.log("error : set to default for configuration")
+    }
+    else {
+        var parser = new xml2js.Parser({explicitArray: false});
+        parser.parseString(data, function (err, result) {
+            if (err) {
+                console.log("Parsing An error occurred trying to read in the file: " + err);
+                console.log("error : set to default for configuration")
+            }
+            else {
+                var jsonString = JSON.stringify(result);
+                conf = JSON.parse(jsonString)['m2m:conf'];
+
+                useparenthostname = conf.tas.parenthostname;
+                useparentport = conf.tas.parentport;
+
+                if(conf.upload != null) {
+                    if (conf.upload['ctname'] != null) {
+                        upload_arr[0] = conf.upload;
+                    }
+                    else {
+                        upload_arr = conf.upload;
+                    }
+                }
+
+                if(conf.download != null) {
+                    if (conf.download['ctname'] != null) {
+                        download_arr[0] = conf.download;
+                    }
+                    else {
+                        download_arr = conf.download;
+                    }
+                }
+            }
+        });
+    }
+});
+
+
+var tas_state = 'init';
+
+var upload_client = null;
+
+var t_count = 0;
+
+var tas_download_count = 0;
+
+function on_receive(data) {
+    if (tas_state == 'connect' || tas_state == 'reconnect' || tas_state == 'upload') {
+        var data_arr = data.toString().split('<EOF>');
+        if(data_arr.length >= 2) {
+            for (var i = 0; i < data_arr.length - 1; i++) {
+                var line = data_arr[i];
+                var sink_str = util.format('%s', line.toString());
+                var sink_obj = JSON.parse(sink_str);
+
+                if (sink_obj.ctname == null || sink_obj.con == null) {
+                    console.log('Received: data format mismatch');
+                }
+                else {
+                    if (sink_obj.con == 'hello') {
+                        console.log('Received: ' + line);
+
+                        if (++tas_download_count >= download_arr.length) {
+                            tas_state = 'upload';
+                        }
+                    }
+                    else {
+                        for (var j = 0; j < upload_arr.length; j++) {
+                            if (upload_arr[j].ctname == sink_obj.ctname) {
+                                console.log('ACK : ' + line + ' <----');
+                                break;
+                            }
+                        }
+
+                        for (j = 0; j < download_arr.length; j++) {
+                            if (download_arr[j].ctname == sink_obj.ctname) {
+                                g_down_buf = JSON.stringify({id: download_arr[i].id, con: sink_obj.con});
+                                console.log(g_down_buf + ' <----');
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+function tas_watchdog() {
+    if(tas_state == 'init') {
+        upload_client = new net.Socket();
+
+        upload_client.on('data', on_receive);
+
+        upload_client.on('error', function(err) {
+            console.log(err);
+            tas_state = 'reconnect';
+        });
+
+        upload_client.on('close', function() {
+            console.log('Connection closed');
+            upload_client.destroy();
+            tas_state = 'reconnect';
+        });
+
+        if(upload_client) {
+            console.log('tas init ok');
+            tas_state = 'init_thing';
+        }
+    }
+    else if(tas_state == 'init_thing') {
+        tas_state = 'connect';
+    }
+    else if(tas_state == 'connect' || tas_state == 'reconnect') {
+        upload_client.connect(useparentport, useparenthostname, function() {
+            console.log('upload Connected');
+            tas_download_count = 0;
+            for (var i = 0; i < download_arr.length; i++) {
+                console.log('download Connected - ' + download_arr[i].ctname + ' hello');
+                var cin = {ctname: download_arr[i].ctname, con: 'hello'};
+                upload_client.write(JSON.stringify(cin) + '<EOF>');
+            }
+
+            if (tas_download_count >= download_arr.length) {
+                tas_state = 'upload';
+            }
+        });
+    }
+}
+
+wdt.set_wdt(require('shortid').generate(), 3, tas_watchdog);
+wdt.set_wdt(require('shortid').generate(), 3, uploadData);
+
+function uploadData() {
+    var cmd = 'sudo ./SEN0228';
+    exec(cmd, function callback(error, stdout, stderr) {
+            if(tas_state == 'upload') {
+                for(var i = 0; i < upload_arr.length; i++) {
+                    if(upload_arr[i].ctname == 'cnt-lux') {
+                        var cin = {ctname: upload_arr[i].ctname, con: stdout};
+                        console.log('SEND : ' + JSON.stringify(cin) + ' ---->');
+                        upload_client.write(JSON.stringify(cin) + '<EOF>');
+                    }
+                }
+            }
+    });
+}
+
+var cur_c = '';
+var pre_c = '';
+var g_sink_buf = '';
+var g_sink_ready = [];
+var g_sink_buf_start = 0;
+var g_sink_buf_index = 0;
+var g_down_buf = '';

SEN0228/conf.xml

+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<m2m:conf xmlns:m2m="http://www.onem2m.org/xml/protocols" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <tas>
+        <parenthostname>localhost</parenthostname>
+        <parentport>3105</parentport>
+    </tas>
+    <upload>
+        <ctname>cnt-lux</ctname>
+        <id>lux#1</id>
+    </upload>
+</m2m:conf>

SEN0228/package.json

+{
+  "name": "tas",
+  "version": "0.0.2",
+  "dependencies": {
+    "fs": "0.0.2",
+    "js2xmlparser": "^1.0.0",
+    "net": "^1.0.2",
+    "shortid": "^2.2.8",
+    "xml2js": "^0.4.12"
+  },
+  "description": "tas of &Cube",
+  "main": "app.js",
+  "devDependencies": {},
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Il Yeup Ahn, KETI",
+  "license": "ISC"
+}

SEN0228/wdt.js

+/**
+ * Copyright (c) 2017, OCEAN
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ * 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @file timer code of Mobius Yellow. manage state of mobius-yt
+ * @copyright KETI Korea 2017, OCEAN
+ * @author Il Yeup Ahn [iyahn@keti.re.kr]
+ */
+
+var events = require('events');
+var wdt = new events.EventEmitter();
+
+var wdt_callback_q = {};
+var wdt_value_q = {};
+var wdt_tick_q = {};
+var wdt_param1_q = {};
+var wdt_param2_q = {};
+var wdt_param3_q = {};
+
+setInterval(function () {
+    wdt.emit('tas_watchdog');
+}, 1000);
+
+wdt.on('tas_watchdog', function() {
+    for (var id in wdt_value_q) {
+        if(wdt_value_q.hasOwnProperty(id)) {
+            //console.log(++wdt_tick_q[id]);
+            ++wdt_tick_q[id];
+            if((wdt_tick_q[id] % wdt_value_q[id]) == 0) {
+                wdt_tick_q[id] = 0;
+                if(wdt_callback_q[id]) {
+                    wdt_callback_q[id](id, wdt_param1_q[id], wdt_param2_q[id], wdt_param3_q[id]);
+                }
+            }
+        }
+    }
+});
+
+exports.set_wdt = function (id, sec, callback_func, param1, param2, param3) {
+    wdt_value_q[id] = sec;
+    wdt_tick_q[id] = 0;
+    wdt_callback_q[id] = callback_func;
+    wdt_param1_q[id] = param1;
+    wdt_param2_q[id] = param2;
+    wdt_param3_q[id] = param3;
+};
+
+exports.get_wdt_callback = function (id) {
+    return wdt_callback_q[id];
+};
+
+exports.get_wdt_value = function (id) {
+    return wdt_value_q[id];
+};
+
+exports.del_wdt = function (id) {
+    delete wdt_value_q[id];
+    delete wdt_callback_q[id];
+};
\ No newline at end of file

thyme/conf.js

@@ -48,6 +48,9 @@ cnt_arr[count++].name = 'cnt-temp';
 cnt_arr[count] = {};
 cnt_arr[count].parent = '/' + cse.name + '/' + ae.name;
 cnt_arr[count++].name = 'cnt-accel';
+cnt_arr[count] = {};
+cnt_arr[count].parent = '/' + cse.name + '/' + ae.name;
+cnt_arr[count++].name = 'cnt-lux';
 
 // build sub
 count = 0;

thyme/conf.json

@@ -29,6 +29,10 @@
         {
             "parent": "/mobius-yt/ae-edu0",
             "name": "cnt-accel"
+        },
+        {
+            "parent": "/mobius-yt/ae-edu0",
+            "name": "cnt-lux"
         }
     ],
     "sub": [