ledblinker

#!/usr/bin/env node
'use strict';

/*****************************************************************************/
/*                    Led Blinker for the raspberry pi                       */
/*                              by: ok 2013                                  */
/*                                                                           */
/*             Set your pin configs at config.json before running.           */
/*                 If you break something, it's your own fault.              */
/*                                                                           */
/*                          This software is free.                           */
/*                                                                           */
/*****************************************************************************/

// some module deps and main vars
var Gpio = require('onoff').Gpio;
var config = require('./config');
var http = require('http');
var fs = require('fs');
var zlib = require('zlib')
var isValidJson = require('validjson');
var filePath = './public/index.html';
var htmlFile = fs.readFileSync(filePath).toString('utf8');
var fileStats = fs.statSync(filePath);
var route = {
    file: htmlFile
};
var headers = {
    'Content-Type': 'text/html',
    'Cache-Control': 'public, max-age=31536000',
    'X-Powered-By':'raspberry Pi',
    'Last-Modified': fileStats.mtime,
    'Expires': 'Wed, 01 Jan 2020 16:20:00 GMT',
    'ETag': fileStats.size + '-' + Date.parse(fileStats.mtime)
};
var server = http.createServer(app);
var ledsO = {};
var ledsA = [];
var buttonO = {};
var buttonA = [];
var gi = 0;

// set up the objects for leds and buttons based on the config
(function setLeds() {
    if (config.leds) {
        var i = 0;
        Object.keys(config.leds).forEach(function (ledc) {
            ledsA[i] = new Gpio(config.leds[ledc].pin, 'out');
            ledsA[i].writeSync(0);
            ledsO[ledc] = { index: i, status: 'off', value: 0 };
            i += 1;
        });
    }
    if (config.buttons) {
        var j = 0;
        Object.keys(config.buttons).forEach(function (button) {
            var but = config.buttons[button];
            var pin = but.pin;
            var edge = but.edge || 'both';
            var debounce = but.debounce || 200;
            buttonA[j] = new Gpio(pin, 'in', edge, { persistentWatch: true, debounceTimeout: debounce });;
            buttonO[button] = { index : j, clicks: 0 };
            buttonA[j].watch(function (err, value) {
                if (err) {
                    throw err;
                } else {
                    buttonO[button].clicks += 1;
                    wss.emit('sendAll', JSON.stringify({ type: 'buttons', data: buttonO }));
                }
            });
            j += 1;
        });
    }
}());

// setup the in-memory http-server with both gzipped and deflated files
// after this is done, we can start listening on the server
['gzip', 'deflate'].forEach(function (gz) {
    zlib[gz](htmlFile, function (err, gzipped) {
        if (!err) {
            route[gz] = gzipped;
        }
        if (gi === 1) {
            server.listen(config.port);
        } else {
            gi += 1;
        }
    });
});

// this is the connectionhandler for the http-server
function app(req, res) {
    var reqHeaders = req.headers;
    if (reqHeaders['if-none-match'] === headers['ETag']) {
        res.statusCode = 304;
        return res.end();
    }
    var resHeaders = headers;
    var acceptEncoding = reqHeaders['accept-encoding'];
    if (acceptEncoding) {
        var gzipd = acceptEncoding.match(/\bgzip|deflate\b/);
        if (gzipd) {
            resHeaders['content-encoding'] = gzipd[0];
            res.writeHead(200, resHeaders);
            return res.end(route[gzipd[0]]);
        }
    }
    res.writeHead(200, resHeaders);
    return res.end(route.file);
}

// set up the websocket server
var WebSocketServer = require('websocket').server;
var connIds = [];
var wss = new WebSocketServer({ httpServer: server });
wss.clientConnections = {};

// websocket server eventlisteners and callbacks
wss.on('request', function (request) {
    var connection = request.accept(null, request.remoteAddress);
    var cid = request.key;
    var self = this;
    connection.id = cid;
    this.clientConnections[cid] = setConnectionListeners(connection);
    connIds.push(cid);
    connection.send(JSON.stringify({ type: 'leds', data: ledsO }));
    connection.send(JSON.stringify({ type: 'buttons', data: buttonO }));
})
.on('sendAll', function (message) {
    var self = this;
    connIds.forEach(function (id) {
        var conn = self.clientConnections[id];
        if (conn.connected) {
            conn.send(message);
        }
    });
});

// just a helper for sending status to all clients
function sendLedStatus() {
    wss.emit('sendAll', JSON.stringify({type:'leds', data: ledsO }));
}

// a function to set websocket connection eventlisteners and callbacks
function setConnectionListeners(connection) {
    connection.on('message', function (msg) {
        if (msg.type === 'utf8') {
            var message = msg.utf8Data;
            var obj = isValidJson(message);
            if (obj && obj.led && ledsO.hasOwnProperty(obj.led)) {
                var ledname = obj.led;
                var ledObj = ledsO[ledname];
                if (obj.on && obj.off && obj.count && obj.count > 0 && obj.count < 1000000 && obj.on > 0 && obj.on < 1000000 && obj.off > 0 && obj.off < 1000000) {
                    obj.count = obj.count * 2;
                    leds.blink(obj);
                } else if (obj.stop) {
                    leds.stopBlinking(ledname);
                } else if (obj.hasOwnProperty('value') && obj.value === 1 || obj.value === 0) {
                    leds.switchLed(ledsA[ledObj.index], function (value) {
                        var stat = (obj.value === 1) ? 'on' : 'off';
                        ledObj.value = obj.value;
                        ledObj.status = stat;
                        sendLedStatus();
                    });
                }
            } else {
                connection.close();
            }
        } else {
            connection.close();
        }
    })
    .on('error', function (error) {
        connection.close();
    })
    .on('close', function () {
        delete wss.clientConnections[connection.id];
        connIds = Object.keys(wss.clientConnections);
    });
    return connection;
}


// the object that holds the methods for blinking and switching the leds
var leds = {
    timeO: [],
    switchLed: function (led, cb) {
        led.read(function (err, value) {
            if (err) {
                throw err;
            } else {
                var val = value === 0 ? 1 : 0;
                led.write(val, function (err) {
                    if (err) {
                        throw err;
                    } else {
                        cb(val);
                    }
               });
            }
        });
    },
    blink: function(options) {
        var indx = ledsO[options.led].index;
        var led = ledsA[indx];
        var self = this;
        led.blinking = true;
        ledsO[options.led].status = 'blinking';
        sendLedStatus();
        (function timeouts(indx, options, led) {
            if (led.blinking) {
                var onT = options.on;
                var offT = options.off;
                if (options.count <= 0) {
                    return self.stopBlinking(options.led);
                }
                options.count -= 1;
                self.switchLed(led, function (value) {
                    var to = (value === 1) ? onT : offT;
                    self.timeO[indx] = setTimeout(function() {
                        timeouts(indx, options, led);
                    }, to);
                });
            }
        }(indx, options, led));
    },
    stopBlinking: function (name) {
        var ind = ledsO[name].index;
        var val = ledsO[name].value;
        ledsO[name].status = 'stop';
        clearTimeout(this.timeO[ind]);
        var led = ledsA[ind];
        if (led.blinking) {
            led.writeSync(val);
            led.blinking = false;
        }
        sendLedStatus();
    }
};

// this releases the pins after exit
process.on('exit', function() {
    console.log(' Exiting...');
    ledsA.forEach(function (led) {
        led.unexport();
    });
    buttonA.forEach(function (button) {
        button.unexport();
    });
});

// print something to the console
console.log(' -= LED-Blinker || ok 2013 =-');