dial_a_device_node 0.0.153

data/README.md

@@ -0,0 +1,94 @@
+dial-a-device-node
+==================
+
+This package contains a gem AND a npm package AND a standalone node.js application.
+
+## Installation in node.js (Ubuntu Linux)
+
+Install the latest node.js and node package manager
+
+	sudo apt-get install software-properties-common python-software-properties
+	sudo add-apt-repository ppa:chris-lea/node.js
+	sudo apt-get update
+	sudo apt-get install nodejs git-core curl build-essential openssl libssl-dev coffeescript
+
+Install the packages manually for development use: Download the dial-a-device-node source code and the required packages
+
+	sudo git clone https://github.com/Cominch/dial-a-device-node.git
+	
+	sudo npm install -g coffee-script
+	sudo npm install -g serialport
+	sudo npm install -g websocket
+	sudo npm install -g bonescript
+	sudo npm install -g getmac
+
+Go! on Linux
+
+	Make sure your user is in the dialout group or give full access to your serial port
+
+		sudo chmod 777 /dev/ttyUSB0
+
+	Edit start.js
+
+		Define your serial port and websocket URL, if you don't want to use the default values
+
+	Run the dial-a-device-node client
+
+		node start.js
+
+## Installation on BeagleBone (Angstrom Linux) for development and debugging
+
+Install required OS packages
+
+	opkg update
+	opkg install python-compiler
+	opkg install python-misc
+	opkg install python-multiprocessing
+
+Install the npm package
+	
+	npm update
+	npm install -g coffee-script
+	npm install -g serialport
+	npm install -g websocket
+	npm install -g getmac
+
+	cd /var/lib/cloud9
+
+	env GIT_SSL_NO_VERIFY=true git clone https://github.com/Cominch/dial-a-device-node
+
+	cd /var/lib/cloud9/dial-a-device-node
+
+	npm install
+
+	node start.js
+
+You can access and modify the source code via the cloud9 editor on your BeagleBone:
+
+	http://192.168.7.2:3000
+
+
+## Installation as part of a Ruby on Rails project (gem)
+
+Add this line to your application's Gemfile:
+
+    gem 'dial_a_device_node'
+
+Change these settings in /config/environments/production.rb
+
+    config.serve_static_assets = true
+    config.assets.compress = false
+    config.assets.compile = true
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dial_a_device_node
+
+
+## License
+
+GPLv3

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/app/assets/javascripts/dial_a_device_node/consolelogger.js

@@ -0,0 +1,176 @@
+(function (exports) {
+
+    exports.init = function (eventbus) {
+        localeventbus = eventbus;
+
+
+        localeventbus.on("folderwatcher.event", function (event, path) {
+
+            console.log("folderwatcher "+ event + " - "+ path);
+        });
+
+
+        localeventbus.on("serial.initialized", function () {
+
+            console.log("serial port library initialized");
+        });
+
+
+        localeventbus.on("serial.portopened", function () {
+
+            console.log("serial port opened");
+        });
+
+        localeventbus.on("serial.portclosed", function () {
+
+            console.log("serial port closed");
+        });
+
+        localeventbus.on("serial.command", function (data) {
+
+            console.log("serial send command: " + data);
+        });
+
+        localeventbus.on("serial.immediatecommand", function (data) {
+
+            console.log("serial send immediatecommand: " + data);
+        });
+
+        localeventbus.on("serial.incoming", function (data) {
+
+            console.log("serial incoming: " + JSON.stringify(data));
+        });
+
+        localeventbus.on("serial.retrieve", function (data) {
+
+            console.log("serial retrieve string: " + JSON.stringify(data));
+        });
+        
+        localeventbus.on("serial.rawretrieve", function (data) {
+
+            console.log("serial retrieve raw: " + JSON.stringify(data));
+        });
+
+        localeventbus.on("serial.set.baud", function (data) {
+            console.log("serial set baud: " + data);
+        });
+
+        localeventbus.on("serial.set.port", function (data) {
+            console.log("serial set port: " + data);
+        });
+
+
+
+        localeventbus.on("serial.openfailed", function (data) {
+
+            console.log("serial openfailed: " + data);
+        });
+
+
+
+        localeventbus.on("status.deviceendpoint", function (url) {
+
+            console.log("device endpoint?  " + url);
+        });
+
+
+        localeventbus.on("connecting", function (url) {
+
+            console.log("connecting to " + url);
+        });
+
+        localeventbus.on("webconnection.connected", function (url) {
+
+            console.log("connected to  " + url);
+        });
+
+        localeventbus.on("channel.subscribing", function (channelname) {
+
+            console.log("subscribing to " + channelname);
+        });
+
+        localeventbus.on("connectionclosed", function () {
+
+            console.log("connection closed");
+        });
+
+        localeventbus.on("channel.subscription", function (channelname, channel) {
+
+            console.log("subscribed to " + channelname);
+        });
+
+
+
+        localeventbus.on("channel.ui_connected", function (data) {
+
+            console.log("new ui conection: " + JSON.stringify(data));
+        });
+
+        localeventbus.on("channel.ui_disconnected", function (data) {
+
+            console.log("ui disconection: " + JSON.stringify(data));
+        });
+
+        localeventbus.on("channel.dev_connected", function (data) {
+
+            console.log("new dev conection: " + JSON.stringify(data));
+        });
+
+        localeventbus.on("channel.dev_disconnected", function (data) {
+
+            console.log("dev disconection: " + JSON.stringify(data));
+        });
+
+
+
+        localeventbus.on("device.log", function (lm, data) {
+
+            console.log(JSON.stringify(data));
+        });
+
+        localeventbus.on("device.initialized", function () {
+
+            console.log("device initialized");
+
+        });
+
+        localeventbus.on("device.snapshot", function (device_model) {
+
+            console.log("device snapshot: " + JSON.stringify(device_model));
+
+        });
+
+        localeventbus.on("device.command", function (message) {
+
+            console.log("device command: " + JSON.stringify(message));
+
+        });
+
+        localeventbus.on("device.reply", function (message, data) {
+
+            console.log("device reply: " + JSON.stringify(message)+ " --> "+ JSON.stringify(data));
+
+        });
+
+        localeventbus.on("ui.update", function (message) {
+
+            console.log("ui update: " + JSON.stringify(message));
+
+        });
+
+        localeventbus.on("ui.command", function (message) {
+
+            console.log("ui command: " + JSON.stringify(message));
+
+        });
+
+        localeventbus.on("status.incoming", function (message) {
+
+            console.log("status incoming  " + JSON.stringify(message));
+        });
+
+
+        localeventbus.emit("consolelogger.initialized");
+    };
+
+})(typeof exports == 'undefined' ? this['consolelogger'] = {} : exports);

data/app/assets/javascripts/dial_a_device_node/deviceconnection.js

@@ -0,0 +1,225 @@
+var util = require('util');
+var ser = require('serialport');
+
+var serialport;
+
+var localeventbus;
+
+var lastmessage = new Array;
+var currentmessage;
+var waiting = false;
+
+var port;
+var baud;
+var databit = 8;
+var parity = "none";
+var stopbit = 1;
+
+var linebreak = hex2a('0D');
+var suffix = hex2a('0D');
+var prefix = "";
+
+function hex2a(hexx) {
+        var hex = hexx.toString();//force conversion
+        var str = '';
+        for (var i = 0; i < hex.length; i += 2)
+            str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
+        return str;
+}
+
+function knfsimdosparser() {
+
+    var data = new Buffer(0);
+
+    return function(emitter, buffer){
+
+      data = Buffer.concat([data, buffer]);
+      
+      while (data.toJSON().indexOf(2) > -1 && data.toJSON().indexOf(3) > data.toJSON().indexOf(2) && data.toJSON().length > data.toJSON().indexOf(3)+1) {
+
+        var out = data.slice(data.toJSON().indexOf(2)+1, data.toJSON().indexOf(3));
+
+        data = data.slice(data.toJSON().indexOf(3)+2);
+
+        emitter.emit('data', out.toString());
+
+      }
+
+    };
+
+
+}
+
+exports.init = function (eventbus) {
+    localeventbus = eventbus;
+    localeventbus.emit("serial.initialized");
+
+    localeventbus.on("serial.set.baud", function (data) {
+        baud = data;
+    });
+
+    localeventbus.on("serial.set.port", function (data) {
+        port = data;
+    });
+    
+    localeventbus.on("serial.set.linebreak", function (data) {
+        linebreak = data;
+    });
+    
+    localeventbus.on("serial.set.prefix", function (data) {
+        prefix = data;
+    });
+    
+    localeventbus.on("serial.set.suffix", function (data) {
+        suffix = data;
+    });
+    
+    localeventbus.on("serial.set.databit", function (data) {
+        databit = data;
+    });
+    
+    localeventbus.on("serial.set.parity", function (data) {
+        parity = data;
+    });
+    
+    localeventbus.on("serial.set.stopbit", function (data) {
+        stopbit = data;
+    });
+
+
+    localeventbus.on("serial.connect", function () {
+        
+        if (linebreak == "") {
+            serialport = new ser.SerialPort(port, {
+                baudrate: baud,
+                databit: databit,
+                parity: parity,
+                stopbit: stopbit,
+                parser: (ser.parsers.raw)
+            });
+        } else if (linebreak == "knfsimdos") {
+
+            serialport = new ser.SerialPort(port, {
+                baudrate: baud,
+                databit: databit,
+                parity: parity,
+                stopbit: stopbit,
+                parser: (knfsimdosparser())
+            });
+
+        } else if (linebreak == "denver") {
+            
+            serialport = new ser.SerialPort(port, {
+                baudrate: baud,
+                databit: databit,
+                parity: parity,
+                stopbit: stopbit,
+                parser: (ser.parsers.readline(hex2a("0D"), "ascii"))
+            });
+        
+        }else {
+            
+            serialport = new ser.SerialPort(port, {
+                baudrate: baud,
+                databit: databit,
+                parity: parity,
+                stopbit: stopbit,
+                parser: (ser.parsers.readline(hex2a(linebreak)))
+            });
+        }
+
+        serialport.on("error", function (err) {
+            localeventbus.emit("serial.openfailed", err);
+        });
+
+        serialport.on("close", function () {
+            localeventbus.emit("serial.portclosed", port);
+
+        });
+
+
+        serialport.on("open", function () {
+            localeventbus.emit("serial.portopened", port, baud);
+
+            serialport.on("data", function (data) {
+                localeventbus.emit("serial.incoming", data);
+            });
+
+            localeventbus.on("serial.immediatecommand", function (msg) {
+                waiting = false;
+                lastmessage = new Array;
+                serialport.write(hex2a(prefix) + msg + hex2a(suffix), function (err, results) {});
+            });
+            
+            localeventbus.on("serial.sendraw", function (msg) {
+                
+                waiting = false;
+                lastmessage = new Array;
+                serialport.write(hex2a(prefix) + hex2a(msg) + hex2a(suffix), function (err, results) {});
+            });
+
+            localeventbus.on("serial.command", function (data) {
+                lastmessage.push(data);
+                localeventbus.emit("serial.writenext");
+            });
+
+
+            localeventbus.on("serial.close", function (msg) {
+
+                serialport.close();
+            });
+
+            localeventbus.on("serial.writenext", function () {
+                setTimeout(function () {
+
+                    if (waiting) {
+                        localeventbus.emit('serial.writenext');
+                    } else if (lastmessage.length > 0) {
+
+                        waiting = true;
+                        currentmessage = lastmessage.pop();
+                        serialport.write(hex2a(prefix) + currentmessage + hex2a(suffix), function (err, results) {});
+
+                    }
+
+                }, 50);
+
+            });
+
+        });
+    });
+
+
+    localeventbus.on("serial.incoming", function (data) {
+        
+        if ((typeof data === "object")) {
+            
+            localeventbus.emit("serial.rawretrieve", data);
+            
+        } else {
+            
+            if (data.substring(0, 1) == "\n") {
+                data = data.substring(1);
+            }
+
+            // data = data.replace(/[^A-Za-z 0-9 \.,\?""!@#\$%\^&\*\(\)-_=\+;:<>\/\\\|\}\{\[\]`~]*/g, '');
+            
+            localeventbus.emit("serial.retrieve", data);
+            
+        }
+
+
+        if (waiting) {
+
+            localeventbus.emit("device.reply", currentmessage, data);
+            waiting = false;
+        } else {
+            lastmessage = new Array;
+            localeventbus.emit("device.reply", "heartbeat", data);
+            
+            
+        }
+    });
+
+
+};