ban 0.0.1

data/examples/client.rb

@@ -0,0 +1,26 @@
+require 'faye/websocket'
+require 'eventmachine'
+require 'json'
+
+def rc_turn(state, address)
+  { "rc-turn-#{state}" => { 'address' => address } }.to_json
+end
+
+EM.run do
+  ws = Faye::WebSocket::Client.new('ws://localhost:8080/')
+  light = '11110D'
+  
+  ws.on :open do |event|
+    puts "Connected"
+    ws.send(rc_turn(:on, light))
+    EM.add_timer(5) { ws.send(rc_turn(:off, light)) }
+  end
+
+  ws.on :message do |event|
+    p JSON.parse(event.data)
+  end
+
+  ws.on :close do |event|
+    puts "Connection closed"
+  end
+end

data/ino.ini

@@ -0,0 +1,5 @@
+[build]
+board-model = uno
+
+[upload]
+board-model = uno

data/lib/ban.rb

@@ -0,0 +1,50 @@
+require 'ban/version'
+require 'logger'
+require 'json'
+
+# used gems
+require 'eventmachine'
+require 'em-websocket'
+require 'arduino_firmata'
+require 'thor'
+
+module Ban
+  Logger = Logger.new(STDOUT)
+
+  # @param [Array<Fixnum>] data 7 bit encoded data from firmata (midi)
+  # @return [String] ascii
+  def self.decode7bit(data)
+    msg = ""
+    i = 0
+    while i < data.size
+      lsb, msb = data[i], data[i + 1]
+
+      if msb == 0
+        msg << lsb.chr
+      else
+        msg << (lsb + 0b10000000).chr
+      end
+      i += 2
+    end
+    msg
+  end
+  
+  # @param [String] data the data to convert to midi 7 bit encoded string
+  # @return [Array<Fixnum>] array of midi bytes
+  def self.encode7bit(data)
+    msg = []
+    data.each_byte do |byte|
+      msg << (byte & 0b01111111) # LSB
+      msg << (byte >> 7 & 0b01111111) # MSB
+    end
+    msg
+  end
+end
+
+require 'ban/server'
+require 'ban/event'
+require 'ban/events/door_event'
+require 'ban/events/ir_event'
+require 'ban/events/rc_event'
+require 'ban/board'
+require 'ban/cli'

data/lib/ban/board.rb

@@ -0,0 +1,49 @@
+module Ban
+  class Board
+    include EventEmitter
+    SEND_RC_ON = 0x20
+    SEND_RC_OFF = 0x21
+    STRING_DATA = 0x71
+    EVENTS = {
+      DoorEvent::CMD => DoorEvent,
+      IrEvent::CMD   => IrEvent,
+      RcEvent::CMD   => RcEvent
+    }
+
+    def start(path)
+      @path = path
+      @firmata = ArduinoFirmata.connect @path, nonblock_io: true,
+                                        eventmachine: true
+      Logger.debug "Firmata Version: #{@firmata.version}"
+
+      arduino = self
+      @firmata.on :sysex do |cmd, data|
+        arduino.received_sysex(cmd, data)
+      end
+    end
+    
+    def close
+      @firmata.close
+    end
+
+    def received_sysex(event_code, data)
+      if klass = EVENTS[event_code]
+        emit :event, klass.parse(data)
+      else
+        emit :error, msg: 'Unknown event!', event_code: event_code, data: data
+      end
+    end
+
+    def turn_on(address)
+      send_command(SEND_RC_ON, address)
+    end
+
+    def turn_off(address)
+      send_command(SEND_RC_OFF, address)
+    end
+
+    def send_command(command, data)
+      @firmata.sysex(STRING_DATA, Ban.encode7bit(command.chr + data))
+    end
+  end
+end

data/lib/ban/cli.rb

@@ -0,0 +1,45 @@
+module Ban
+  class CLI < Thor
+    option :device, default: nil
+    option :port, type: :numeric, default: 8080
+    option :interface, type: :string, default: '0.0.0.0'
+    desc "server", "starts the ban server"
+    def server
+      device = options[:device]
+      interface = options[:interface]
+      port = options[:port]
+
+      EM.epoll
+      EM.run do
+        board = Board.new
+        server = Server.new
+
+        board.on :event do |event|
+          if event.valid?
+            Ban::Logger.debug "#{event.class}: #{event}"
+            server.broadcast event
+          end
+        end
+
+        server.on :command do |command|
+          Ban::Logger.debug "Received cmd #{command}"
+          if options = command['rc-turn-off']
+            Ban::Logger.debug "Turn off #{options['address']}"
+            board.turn_off(options['address'])
+          elsif options = command['rc-turn-on']
+            Ban::Logger.debug "Turn on #{options['address']}"
+            board.turn_on(options['address'])
+          end
+        end
+        
+        trap(:INT) { board.close; EM.stop }
+        trap(:TERM) { board.close; EM.stop }
+
+        Ban::Logger.info "Connecting to #{device || 'auto'}"
+        board.start(device)
+        Ban::Logger.info "Starting WebSocket Server on #{interface}:#{port}"
+        server.start(interface, port)
+      end
+    end
+  end
+end

data/lib/ban/event.rb

@@ -0,0 +1,7 @@
+module Ban
+  class Event
+    def valid?
+      true
+    end
+  end
+end

data/lib/ban/events/door_event.rb

@@ -0,0 +1,31 @@
+module Ban
+  class DoorEvent < Event
+    CMD = 0x37
+
+    attr_reader :state
+
+    def self.parse(data)
+      new(Ban.decode7bit(data).downcase)
+    end
+    
+    def initialize(state)
+      @state = state
+    end
+    
+    def name
+      open? ? 'door-opened' : 'door-closed'
+    end
+    
+    def to_hash
+      { 'state' => @state }
+    end
+    
+    def open?
+      @state == 'open'
+    end
+    
+    def to_s
+      "door: #{open? ? 'opened' : 'closed'}"
+    end
+  end
+end

data/lib/ban/events/ir_event.rb

@@ -0,0 +1,31 @@
+module Ban
+  class IrEvent < Event
+    CMD = 0x36
+
+    attr_reader :code
+
+    def self.parse(data)
+      new(Ban.decode7bit(data).to_i)
+    end
+
+    def initialize(code)
+      @code = code
+    end
+
+    def name
+      'ir-received'
+    end
+
+    def hex
+      code.to_s(16)
+    end
+
+    def to_hash
+      { 'code' => @code, 'hex' => hex }
+    end
+
+    def to_s
+      "#{code} (0x#{hex})"
+    end
+  end
+end

data/lib/ban/events/rc_event.rb

@@ -0,0 +1,59 @@
+module Ban
+  class RcEvent < Event
+    CMD = 0x35
+
+    attr_reader :decimal, :bits, :delay, :protocol
+
+    def self.parse(data)
+      new(*Ban.decode7bit(data).split('|').map(&:to_i))
+    end
+
+    def initialize(decimal, bits, delay, protocol)
+      @decimal, @bits, @delay, @protocol = decimal, bits, delay, protocol
+    end
+
+    def name
+      (tristate[-1] == 'F') ? 'rc-turned-on' : 'rc-turned-off'
+    end
+
+    def valid?
+      tristate
+      true
+    rescue ArgumentError
+      false
+    end
+
+    def to_hash
+      {
+        'decimal' => decimal,
+        'bits' => bits,
+        'binary' => binary,
+        'tristate' => tristate,
+        'delay' => delay,
+        'protocol' => protocol
+      }
+    end
+
+    def to_s
+      "decimal: #{decimal} (#{bits} bits) binary #{binary} " +
+      "tri-state: #{tristate} pulse length: #{delay} (ms) " +
+      "protocol: #{protocol}"
+    end
+
+    def binary
+      ("%#{bits}s" % decimal.to_s(2)).gsub(' ', '0')
+    end
+
+    def tristate
+      binary.gsub(/[0-9]{2}/) do |match|
+        if match == '00'
+          '0'
+        elsif match == '01'
+          'F'
+        else
+          raise ArgumentError, "#{match} not applicable"
+        end
+      end
+    end
+  end
+end

data/lib/ban/server.rb

@@ -0,0 +1,37 @@
+module Ban
+  class Server
+    include EventEmitter
+    def initialize
+      @clients = []
+    end
+
+    def broadcast(event)
+      @clients.each do |client|
+        client.send({ event.name => event.to_hash }.to_json)
+      end
+    end
+
+    def start(interface, port)
+      @server = EM::WebSocket.run(host: interface, port: port) do |ws|
+        ws.onopen do |handshake|
+          Ban::Logger.debug "WebSocket connection open"
+          @clients << ws
+        end
+
+        ws.onclose do
+          Ban::Logger.debug "WebSocket connection closed"
+          @clients.delete(ws)
+        end
+
+        ws.onmessage do |command_json|
+          begin
+            command = JSON.parse(command_json)
+            emit :command, command
+          rescue JSON::ParserError
+            Ban::Logger.warn "Received invalid json: #{command_json}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ban/version.rb

@@ -0,0 +1,3 @@
+module Ban
+  VERSION = "0.0.1"
+end

data/spec/ban/events/door_event_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Ban::DoorEvent do
+  context 'open' do
+    let(:data) { [79, 0, 80, 0, 69, 0, 78, 0] }
+
+    subject {  described_class.parse(data) }
+
+    its(:name) { should == 'door-opened' }
+    its(:valid?) { should == true }
+    its(:to_hash) { should == { "state" => "open" } }
+    its(:to_s) { should == "door: opened" }
+  end
+
+  context 'close' do
+    let(:data) { [67, 0, 76, 0, 79, 0, 83, 0, 69, 0] }
+
+    subject {  described_class.parse(data) }
+
+    its(:name) { should == 'door-closed' }
+    its(:valid?) { should == true }
+    its(:to_hash) { should == { "state" => "close" } }
+    its(:to_s) { should == "door: closed" }
+  end
+end

data/spec/ban/events/ir_event_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Ban::IrEvent do
+  let(:data) { [51, 0, 48, 0, 54, 0, 56, 0, 57, 0] }
+
+  subject {  described_class.parse(data) }
+
+  its(:name) { should == 'ir-received' }
+  its(:valid?) { should == true }
+  its(:to_hash) do
+    should == { "code" => 30689, "hex" => "77e1" }
+  end
+  its(:to_s) do
+    should == "30689 (0x77e1)"
+  end
+end

data/spec/ban/events/rc_event_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Ban::RcEvent do
+  subject { described_class.parse(data) }
+  
+  context 'valid' do
+    let(:data) do
+      [
+        50, 0, 49,  0, 53, 0, 56, 0, 56, 0, 124, 0, 50, 0,
+        52, 0, 124, 0, 51, 0, 50, 0, 50, 0, 124, 0, 49, 0
+      ]
+    end
+    
+    its(:name) { should == 'rc-turned-off' }
+    its(:valid?) { should == true }
+    its(:to_hash) do
+      should == {
+        "decimal" => 21588,
+        "bits" => 24,
+        "binary" => "000000000101010001010100",
+        "tristate" => "0000FFF0FFF0",
+        "delay" => 322,
+        "protocol" => 1
+      }
+    end
+    its(:to_s) do
+      should == "decimal: 21588 (24 bits) binary 000000000101010001010100 " + 
+                "tri-state: 0000FFF0FFF0 pulse length: 322 (ms) protocol: 1"
+    end
+  end
+  
+  context 'invalid' do
+    let(:data) do
+      [
+        50, 0, 49,  0, 53, 0, 56, 0, 30, 0, 124, 0, 50, 0,
+        52, 0, 124, 0, 51, 0, 50, 0, 50, 0, 124, 0, 49, 0
+      ]
+    end
+  
+    its(:valid?) { should == false }
+  end
+end