oschii_ruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bb0e8b35b66541a40236ea7a4595518d8a9d6727105c2543e74ca5d6fbb8443f
+  data.tar.gz: 1d9c121b90502130c86056f9818dca4b6a81fe9485734e257e9f261891bbe6f8
+SHA512:
+  metadata.gz: 8b35574e7713cdc5bf13d0e9710894818bc48c72a7a86ade3c6b8688a4449548a2106b01adeb52ac99585f7356f195b4c90999029a0b2aca3c1c6f3d170fb0c0
+  data.tar.gz: 57a436a356063c353d9e8f5a5a18014fce3aa2016b689f50b7daef79cf3efcba1a643d6081fb5669a81e0ddcbb8230735575439e3d1db2dba915d8c13dadb106

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+ruby '2.7.7'
+
+source 'http://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'make_menu'
+  gem 'byebug'
+end

data/Gemfile.lock

@@ -0,0 +1,80 @@
+PATH
+  remote: .
+  specs:
+    oschii_ruby (0.0.1)
+      activesupport (~> 7.1.2)
+      faye-websocket (~> 0.11.3)
+      osc-ruby (~> 1.1.4)
+      rest-client (~> 2.1.0)
+      rubyserial (~> 0.6.0)
+      webrick (~> 1.8.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (7.1.2)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      mutex_m
+      tzinfo (~> 2.0)
+    base64 (0.2.0)
+    bigdecimal (3.1.5)
+    byebug (11.1.3)
+    concurrent-ruby (1.2.2)
+    connection_pool (2.4.1)
+    domain_name (0.6.20231109)
+    drb (2.2.0)
+      ruby2_keywords
+    eventmachine (1.2.7)
+    faye-websocket (0.11.3)
+      eventmachine (>= 0.12.0)
+      websocket-driver (>= 0.5.1)
+    ffi (1.16.3)
+    http-accept (1.7.0)
+    http-cookie (1.0.5)
+      domain_name (~> 0.5)
+    i18n (1.14.1)
+      concurrent-ruby (~> 1.0)
+    make_menu (0.0.3)
+      tty-screen (~> 0.8.2)
+    mime-types (3.5.1)
+      mime-types-data (~> 3.2015)
+    mime-types-data (3.2023.1205)
+    minitest (5.20.0)
+    mutex_m (0.2.0)
+    netrc (0.11.0)
+    osc-ruby (1.1.4)
+    rest-client (2.1.0)
+      http-accept (>= 1.7.0, < 2.0)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 4.0)
+      netrc (~> 0.8)
+    ruby2_keywords (0.0.5)
+    rubyserial (0.6.0)
+      ffi (~> 1.9, >= 1.9.3)
+    tty-screen (0.8.2)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    webrick (1.8.1)
+    websocket-driver (0.7.6)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
+
+PLATFORMS
+  arm64-darwin-21
+
+DEPENDENCIES
+  byebug
+  make_menu
+  oschii_ruby!
+
+RUBY VERSION
+   ruby 2.7.7p221
+
+BUNDLED WITH
+   2.3.26

data/lib/oschii/cloud.rb

@@ -0,0 +1,294 @@
+require 'restclient'
+require 'osc-ruby'
+require 'osc-ruby/em_server'
+require 'socket'
+require 'webrick'
+require_relative 'servlets'
+
+module Oschii
+  class Cloud
+    PING_PORT = 3333
+    PING_ADDR = '/hello_oschii'
+    RESPONSE_PORT = 3333
+    RESPONSE_ADDR = '/i_am_oschii'
+    HTTP_PORT = 8000
+
+    def initialize(silent: false)
+      @osc_server = OSC::EMServer.new(RESPONSE_PORT)
+      @http_server = WEBrick::HTTPServer.new(Port: HTTP_PORT)
+
+      @devices = {}
+      @silent = silent
+
+      start_listening
+    end
+
+    attr_reader :osc_server, :http_server, :devices, :silent
+
+    def find_serial(port = nil)
+      return ::Oschii::SerialDevice.new(port) if port
+
+      puts "\n~~> Scanning Serial Ports...."
+
+      9.times do |i|
+        port = "/dev/ttyUSB#{i}"
+        print "\n~~> #{port}: "
+        begin
+          node = ::Oschii::SerialDevice.new(port)
+          name = "serial_#{node.name.downcase}".to_sym
+          if (existing_node = devices[name.downcase.to_sym])
+            existing_node.refresh
+          else
+            devices[name] = node
+            node.refresh
+          end
+          puts "'#{node.name}'"
+        rescue ::Oschii::DeviceUnavailable => e
+          puts e.message
+        end
+      end
+
+      print_devices
+
+      self
+    end
+
+    def start_listening
+      osc_server.add_method RESPONSE_ADDR do |message|
+        payload = message.to_a.first
+        begin
+          json = JSON.parse(payload)
+          name = json['name']
+          ip = json['ip']
+        rescue JSON::ParserError
+          name = payload.split(':').last.strip
+          ip = message.ip_address
+        end
+
+        if (device = devices[name.downcase.to_sym])
+          puts "\n==> '#{name}' is back\n" unless silent
+          device.refresh
+        else
+          begin
+            device = ::Oschii::HttpDevice.new(ip)
+            # add_http_handlers device
+            puts "\n==> '#{name}' connected @ #{device.ip_address}\n" unless silent
+            devices[name.downcase.to_sym] = device
+          rescue Errno::ECONNREFUSED => e
+            puts "\n!!! Failed connecting to #{name} on #{ip}"
+          end
+        end
+        save_device device.ip
+      end
+
+      Thread.new do
+        puts "~~> Starting OSC Server on port #{RESPONSE_PORT}" unless silent
+        osc_server.run
+      end
+
+      trap 'INT' do http_server.shutdown end
+
+      Thread.new do
+        puts "~~> Starting HTTP Server on port #{HTTP_PORT}" unless silent
+        http_server.start
+      end
+
+      http_server.mount '/api/devices', GetDevices, self
+      http_server.mount '/api/refresh', RefreshCloud, self
+    end
+
+    def wait_for(oschii_name, timeout: 300)
+      print "==> Waiting for '#{oschii_name}'.... "
+      find_devices
+      oschii = nil
+      started = Time.now
+      while oschii.nil? && Time.now - started <= timeout
+        oschii = get oschii_name
+      end
+      if oschii
+        puts 'FOUND :D'
+      else
+        puts 'NOT FOUND :('
+      end
+      oschii
+    end
+
+    def restart
+      devices.each do |_name, oschii|
+        Thread.new { oschii.restart }
+      end
+    end
+
+    attr_reader :monitor
+
+    def monitor_osc(*address_list, max: 100)
+      @monitor ||= OscMonitor.new self
+
+      address_list = [address_list] unless address_list.is_a?(Array)
+
+      address_list.each do |address|
+        monitor.add address, max: max
+      end
+
+      monitor.run
+    end
+
+    def capture_osc(address, simple: true, &block)
+      address = "/#{address}" if address[0] != '/'
+
+      osc_server.add_method address do |message|
+        value = simple ? message.to_a.first&.to_i : message.to_a
+        if block_given?
+          yield value
+        else
+          puts "--> OSC #{address} [ #{value} ]"
+        end
+      end
+    end
+
+    BASE_IP_FILE = '.base_ip'.freeze
+
+    def base_ip=(value)
+      File.write BASE_IP_FILE, value unless value.nil?
+      @base_ip = value
+    end
+
+    def base_ip
+      return @base_ip if @base_ip
+
+      ip = Socket.ip_address_list.detect{|intf| intf.ipv4_private?}
+
+      addr = ip.ip_address.to_s
+
+      puts "Local IP: #{addr}"
+
+      @base_ip = addr.split('.')[0..-2].join('.')
+
+      # if File.exists? BASE_IP_FILE
+      #   @base_ip = File.read(BASE_IP_FILE).strip
+      # else
+      #   @base_ip = '192.168.1'
+      #   File.write BASE_IP_FILE, @base_ip
+      # end
+      # @base_ip = @base_ip[0..-2] if @base_ip[-1] == '.'
+      # @base_ip
+    end
+
+    def find_devices(echo: false)
+      @devices = {}
+      saved = saved_devices
+      saved.each do |ip|
+        begin
+          print "\r#{ip}" if echo
+
+          client = OSC::Client.new(ip, PING_PORT)
+          client.send(OSC::Message.new(PING_ADDR, 1))
+        rescue => e
+          # puts e.message
+        end
+      end
+
+      Thread.new do
+        (1..254).each do |i|
+          begin
+            ip = "#{base_ip}.#{i}"
+
+            next if saved.include? ip
+
+            print "\r#{ip}" if echo
+
+            client = OSC::Client.new(ip, PING_PORT)
+            client.send(OSC::Message.new(PING_ADDR, 1))
+
+            sleep 0.08
+          rescue => e
+            # puts e.message
+          end
+        end
+      end
+
+      puts if echo
+    end
+
+    def populate(echo: false)
+      find_devices(echo: echo)
+
+      start_waiting = Time.now
+      while Time.now - start_waiting < 3
+        sleep 0.2
+      end
+
+      print_devices unless silent
+      self
+    end
+
+    def print_devices
+      puts
+      puts self.to_s
+      puts
+      puts
+    end
+
+    def to_s
+      return '' if devices.empty?
+
+      result = ''
+
+      conn_width = 0
+      name_width = 0
+      devices.each do |name, device|
+        if device.is_a? ::Oschii::SerialDevice
+          conn_width = device.serial_port.size if device.serial_port.size > conn_width
+        elsif device.is_a? ::Oschii::HttpDevice
+          conn_width = device.ip.size if device.ip.size > conn_width
+        end
+        name_width = name.size if name.size > name_width
+      end
+
+      sorted = devices.to_a.sort_by { |name, _node| name }.to_h
+
+      result += "\e[1m#{'Name'.ljust(name_width + 3)}#{'Connection'.ljust(conn_width + 3)}#{'Version'}\e[22m"
+      sorted.each do |_name, device|
+        connection = if device.is_a? ::Oschii::SerialDevice
+                       device.serial.ljust(conn_width)
+                     elsif device.is_a? ::Oschii::HttpDevice
+                       device.ip.ljust(conn_width)
+                     else
+                       ""
+                     end
+        result += "\n#{device.name.ljust(name_width)}   #{connection}   #{device.version}"
+      end
+      result += "\n"
+      result
+    end
+
+    def get(name)
+      devices[name.to_s.downcase.to_sym]
+    end
+
+    def inspect
+      "<#{self.class.name} #{local_ip_address} devices: #{devices.size}>"
+    end
+
+    def local_ip_address
+      ip = Socket.ip_address_list.detect { |intf| intf.ipv4_private? }
+      ip.ip_address
+    end
+
+    def saved_devices
+      @saved_devices ||= if File.exists? '.saved_devices'
+        File.read('.saved_devices').split("\n")
+      else
+        []
+      end
+    end
+
+    def save_device(ip)
+      return if saved_devices.include? ip
+
+      @saved_devices << ip
+
+      File.write('.saved_devices', @saved_devices.join("\n"))
+    end
+  end
+end

data/lib/oschii/device.rb

@@ -0,0 +1,286 @@
+require 'restclient'
+require 'rubyserial'
+require 'json'
+require 'io/console'
+require 'faye/websocket'
+require 'eventmachine'
+require 'byebug'
+
+module Oschii
+  DeviceUnavailable = Class.new(StandardError)
+  NoConnection = Class.new(StandardError)
+
+  class Device
+    def initialize
+      @log_lines = []
+      refresh
+    end
+
+    attr_reader :log_lines
+
+    def restart
+      raise NoConnection
+    end
+
+    # Connection
+
+    def refresh
+      @device_details = nil
+      @status = nil
+      @settings = nil
+      @config = nil
+      poke!
+    end
+
+    def ip
+      raise NoConnection
+    end
+
+    def poke
+      raise NoConnection
+    end
+
+    def poke!
+      remaining_attempts = 3
+      while remaining_attempts > 0
+        begin
+          if poke
+            # device_details
+            return true
+          end
+          return false
+
+        rescue RubySerial::Error => e
+          raise DeviceUnavailable, case e.message
+                                   when 'ENOENT'
+                                     '(no device)'
+                                   when 'EBUSY'
+                                     '(port in use)'
+                                   else
+                                     e.message
+                                   end
+        rescue RestClient::Exception => e
+          raise DeviceUnavailable, e.message
+        end
+        remaining_attempts -= 1
+      end
+      raise DeviceUnavailable, '(no response)'
+    end
+
+    # Device details
+
+    def raw_device_details
+      raise NoConnection
+    end
+
+    def device_details
+      @device_details ||= JSON.parse(raw_device_details)
+    end
+
+    def version
+      device_details['version']
+    end
+
+    def name
+      device_details['name']
+    end
+
+    def name=(new_name)
+      self.settings = ({ name: new_name })
+      refresh
+    end
+
+    def description
+      device_details['description']
+    end
+
+    def config_name
+      device_details['configName']
+    end
+
+    def config_description
+      device_details['configDescription']
+    end
+
+    # Status
+
+    def raw_status
+      raise NoConnection
+    end
+
+    def status
+      @status ||= JSON.parse(raw_status)
+    end
+
+    def uptime
+      status['uptime']
+    end
+
+    # Settings
+
+    def raw_settings
+      raise NoConnection
+    end
+
+    def settings=(new_settings)
+      raise NoConnection
+    end
+
+    def settings
+      @settings ||= JSON.parse(raw_settings)
+    end
+
+    # Configuration
+
+    def raw_config
+      raise NoConnection
+    end
+
+    def raw_config=(json)
+      raise NoConnection
+    end
+
+    def config=(hash)
+      self.raw_config = hash.to_json
+    end
+
+    def config
+      @config ||= Oschii::Config.parse(raw_config)
+    end
+
+    def clear!
+      self.config = {}
+    end
+
+    def update!
+      self.config = config.compacted
+    end
+
+    def upload_config(filename = nil, silent: false)
+      if filename.nil?
+        filenames = Dir.glob("configs/#{name}_*.json")
+        if filenames.empty?
+          puts 'No previous config' unless silent
+          return
+        end
+        filename = filenames.sort.last
+
+        unless silent
+          display_name = filename.split('/')[-1]
+                           .split('_')[-1]
+                           .split('+')[0]
+                           .gsub('T', ' ')
+                           .gsub('.json', '')
+          puts "Latest: #{display_name}"
+          begin
+            prompt '>> [ENTER] to upload, [ESC] to cancel <<'
+          rescue CancelSerialQuery
+            return
+          end
+        end
+      end
+
+      self.config = JSON.parse File.read(filename)
+
+      self
+    end
+
+    def save_config(filename = nil, silent: false)
+      filename ||= "configs/#{name}_#{Time.now.iso8601}.json"
+      File.write filename, JSON.pretty_generate(config)
+      puts "Saved #{filename.split('/')[-1]}" unless silent
+    end
+
+    # Logging
+
+    def log
+      raise NoConnection
+    end
+
+    def clear_log
+      raise NoConnection
+    end
+
+    def tail(filter: nil)
+      while true
+        while (line = log_lines.shift)
+          if filter.nil? || line.match?(filter)
+            puts line
+          end
+        end
+        sleep 0.05
+      end
+    end
+
+    def logger(params = {})
+      current_logger = settings['logger']
+
+      all = params[:all]
+
+      sensors = all.nil? ? params[:sensors] : all
+      drivers = all.nil? ? params[:drivers] : all
+      monitors = all.nil? ? params[:monitors] : all
+      listeners = all.nil? ? params[:listeners] : all
+      states = all.nil? ? params[:states] : all
+      timers = all.nil? ? params[:timers] : all
+      subs = all.nil? ? params[:subs] : all
+      pixels = all.nil? ? params[:pixels] : all
+      network_in = all.nil? ? params[:network_in] : all
+      network_out = all.nil? ? params[:network_out] : all
+      timestamp = params[:timestamp]
+      to_file = params[:to_file]
+
+      current_logger['sensors'] = sensors unless sensors.nil?
+      current_logger['drivers'] = drivers unless drivers.nil?
+      current_logger['monitors'] = monitors unless monitors.nil?
+      current_logger['listeners'] = listeners unless listeners.nil?
+      current_logger['states'] = states unless states.nil?
+      current_logger['timers'] = timers unless timers.nil?
+      current_logger['subs'] = subs unless subs.nil?
+      current_logger['pixels'] = pixels unless pixels.nil?
+      current_logger['networkIn'] = network_in unless network_in.nil?
+      current_logger['networkOut'] = network_out unless network_out.nil?
+      current_logger['timestamp'] = timestamp unless timestamp.nil?
+      current_logger['logToFile'] = to_file unless to_file.nil?
+      update_settings({ 'logger' => current_logger })
+      current_logger = settings['logger']
+      puts JSON.pretty_generate current_logger
+    end
+
+    def inspect
+      "<#{self.class.name}[#{name}] (v#{version})>"
+    end
+
+    private
+
+    def prompt(text, obscure: false)
+      print "#{text}: "
+      input = ''
+      char = ''
+      until !char.empty? && char.ord == 13
+        char = STDIN.getch
+        if char.ord == 127
+          # BACKSPACE
+          input = input[0..-2]
+          print "\r#{text}: #{' ' * input.size} "
+          print "\r#{text}: #{obscure ? '*' * input.size : input}"
+        elsif char.ord == 27
+          # ESC
+          raise CancelSerialQuery
+        elsif char.ord == 13
+          # ENTER
+        else
+          input += char
+          if obscure
+            print '*'
+          else
+            print char
+          end
+        end
+      end
+      puts
+      input
+    end
+
+  end
+end

data/lib/oschii/http_device.rb

@@ -0,0 +1,154 @@
+module Oschii
+  class HttpDevice < Device
+    def initialize(ip)
+      @ip_address = ip
+      @osc_clients = {}
+      super()
+    end
+
+    attr_reader :ip_address, :osc_clients, :log_socket
+
+    def restart
+      RestClient.post("http://#{ip}/restart", {})&.body
+    end
+
+    # Connection
+
+    def refresh
+      stop_web_socket
+      super
+    end
+
+    def ip
+      ip_address
+    end
+
+    def poke
+      device_details
+      begin
+        start_web_socket
+      rescue
+        # ignored
+      end
+      true
+    end
+
+    # Raw getters
+
+    def raw_device_details
+      RestClient.get("http://#{ip}/device")&.body || ''
+    end
+
+    def raw_status
+      RestClient.get("http://#{ip}/status")&.body || ''
+    end
+
+    def raw_settings
+      RestClient.get("http://#{ip}/settings.json")&.body || ''
+    end
+
+    def raw_config
+      RestClient.get("http://#{ip}/config.json")&.body || ''
+    end
+
+    # Updaters
+
+    def raw_config=(json)
+      RestClient.post(
+        "http://#{ip}/config",
+        json,
+        content_type: 'application/json'
+      )
+      # refresh
+    end
+
+    def settings=(new_settings)
+      RestClient.post(
+        "http://#{ip}/settings",
+        new_settings.to_json,
+        content_type: 'application/json'
+      )
+      refresh
+    end
+
+    # Logging
+
+    def start_web_socket
+      EM.run {
+        @log_socket = Faye::WebSocket::Client.new("ws://#{ip}/logger_ws")
+
+        log_socket.on :open do |event|
+          log_socket.send('WebSocket connected')
+        end
+
+        log_socket.on :message do |event|
+          event.data.split("\n").each do |line|
+            log_lines << line
+          end
+        end
+
+        log_socket.on :close do |event|
+          log_socket.send("WebSocket DISCONNECTED: #{event.code} #{event.reason}")
+          @log_socket = nil
+        end
+      }
+    end
+
+    def stop_web_socket
+      log_socket&.close
+    end
+
+    # Network Commands
+
+    def fire(address, *values)
+      send_osc address, *values
+    end
+
+    def send_osc(address, *values, port: 3333)
+      address = "/#{address}" unless address[0] == '/'
+      osc_client(port).send(OSC::Message.new(address, *values))
+    end
+
+    def osc_client(port)
+      osc_clients[port] ||= OSC::Client.new(ip, port)
+    end
+
+    def get(path, value = 1)
+      send_http path, value, method: :get
+    end
+
+    def post(path, value = 1)
+      send_http path, value, method: :post
+    end
+
+    def send_http(path, value = 1, method: :post)
+      path = "/#{path}" unless %w(/ :).include?(path[0])
+      method = method.to_s.downcase.to_sym
+      url = "http://#{ip}#{path}"
+      if method == :get
+        args = [url]
+      else
+        args = [url, value.to_s]
+      end
+      puts RestClient.send(method, *args)
+    rescue RestClient::BadRequest => e
+      puts "Oschii didn't like that: #{e.http_body}"
+    end
+
+    def log
+      RestClient.get("http://#{ip}/log")&.body
+    end
+
+    def clear_log
+      RestClient.delete("http://#{ip}/log")&.body
+    end
+
+    def to_s
+      inspect
+    end
+
+    def inspect
+      "<#{self.class.name}[#{name}] #{ip_address} (v#{version})>"
+    end
+  end
+end

data/lib/oschii/osc_monitor.rb

@@ -0,0 +1,57 @@
+module Oschii
+  class OscMonitor
+    COL_WIDTH = 40
+
+    def initialize(cloud)
+      @cloud = cloud
+      @values = {}
+    end
+
+    attr_reader :cloud, :values
+
+    def add(name, max: 100)
+      unless values[name.to_sym]
+        values[name.to_sym] = {value: nil, max: max}
+        cloud.capture_osc name do |value|
+          values[name.to_sym][:value] = value
+        end
+      end
+
+      values[name.to_sym][:max] = max
+    end
+
+    def run
+      puts
+      values.each do |k, v|
+        print " #{k}".ljust (COL_WIDTH+4)
+      end
+      puts
+      while true
+        render
+        sleep 0.01
+      end
+    end
+
+    def render
+      print "\r"
+      values.each do |k, v|
+        print sensor_bar(v)
+      end
+    end
+
+    def sensor_bar(value)
+      result = '['
+      norm = [value[:value].to_f / value[:max], 1.0].min * COL_WIDTH
+      COL_WIDTH.times do |i|
+        if i < norm
+          result += '■'
+        else
+          result += ':'
+        end
+      end
+      result += ']  '
+    end
+
+
+  end
+end

data/lib/oschii/serial_device.rb

@@ -0,0 +1,197 @@
+module Oschii
+  class SerialDevice < Device
+    BAUD_RATE = 115200
+
+    CancelSerialQuery = Class.new(StandardError)
+
+    def initialize(serial)
+      @serial = serial
+      @capturing_serial = false
+      super()
+    end
+
+    attr_reader :serial
+    attr_accessor :capturing_serial, :serial_line_buffer
+
+    def poke
+      start_serial_capture
+      serial_query('poke', timeout: 2) == 'Tickles!'
+    end
+
+    def version
+      return @version if @version
+
+      attempts = 3
+      while attempts > 0
+        @version = serial_query 'version'
+        if @version.empty?
+          attempts -= 1
+        else
+          attempts = 0
+        end
+      end
+    end
+
+    def ip
+      serial_query 'ip'
+    end
+
+    def restart
+      serial_query 'restart'
+    end
+
+    def name
+      return @name if @name
+
+      attempts = 3
+      while attempts > 0
+        @name = serial_query 'name'
+        if @name.empty?
+          attempts -= 1
+        else
+          attempts = 0
+        end
+      end
+    end
+
+    def name=(new_name)
+      puts 'Querying serial port....'
+      if serial_query('name=') == '>> Enter new name <<'
+        puts serial_query new_name
+      end
+      refresh
+    end
+
+    def config=(new_config)
+      puts 'Querying serial port....'
+      if serial_query('config=') == '>> Enter new configuration <<'
+        puts 'Uploading configuration....'
+        puts serial_query new_config.to_json
+      end
+      refresh
+    end
+
+    def raw_config
+      serial_query 'config', timeout: 3
+    end
+
+    def status
+      JSON.parse(serial_query('status'))
+    end
+
+    def update_settings(new_settings = nil, file: nil)
+      unless file.nil?
+        puts 'Reading file....'
+        new_settings = JSON.parse(File.read(file))
+      end
+      puts 'Querying serial port....'
+      if serial_query('settings=') == '>> Enter new settings <<'
+        puts 'Uploading settings....'
+        puts serial_query new_settings.to_json
+        refresh
+      end
+    end
+
+    def raw_settings
+      serial_query 'settings'
+    end
+
+    def serial_query(query, timeout: 3)
+      # puts "#> #{query}"
+      purge_serial
+      serial_port.write (query.empty? ? "\n" : query)
+      sleep timeout
+      result = log_lines.join
+      log_lines.clear
+      # puts "   #{result}"
+      result
+    end
+
+    def purge_serial
+      log_lines.clear
+      self.serial_line_buffer = ''
+    end
+
+    def start_serial_capture
+      return if capturing_serial
+
+      Thread.new do
+        self.capturing_serial = true
+        self.serial_line_buffer = ''
+        log_lines.clear
+        while capturing_serial
+          input = serial_port.read 100
+          input.each_char do |c|
+            if c == "\n"
+              log_lines << serial_line_buffer.gsub("\r", '')
+              self.serial_line_buffer = ''
+            else
+              serial_line_buffer << c
+            end
+          end
+          sleep 0.01
+        end
+      end
+    end
+
+    def stop_serial_capture
+      self.capturing_serial = false
+    end
+
+    def start_wifi(ssid = nil, password = nil)
+      begin
+        if ssid.nil?
+          ssid = prompt 'Enter SSID'
+        end
+
+        if password.nil?
+          password = prompt 'Enter password', obscure: true
+        end
+
+        puts 'Querying serial port...'
+        if serial_query('start wifi') == '>> Enter new Wifi SSID <<'
+          puts 'Sending SSID...'
+          if serial_query(ssid) == '>> Enter new Wifi Password <<'
+            puts 'Sending password...'
+            puts serial_query(password)
+          end
+        end
+
+      rescue CancelSerialQuery
+        puts 'Cancelled'
+      end
+    end
+
+    def stop_wifi
+      serial_query 'stop wifi'
+    end
+
+    def start_ethernet
+      serial_query 'start ethernet'
+    end
+
+    def stop_ethernet
+      serial_query 'stop ethernet'
+    end
+
+    def serial_port
+      @serial_port ||= Serial.new serial, BAUD_RATE
+    end
+
+    def log
+      serial_query 'print log'
+    end
+
+    def clear_log
+      serial_query 'clear log'
+    end
+
+    def to_s
+      inspect
+    end
+
+    def inspect
+      "<#{self.class.name}[#{name}] #{serial} (v#{version})>"
+    end
+  end
+end

data/lib/oschii/servlets.rb

@@ -0,0 +1,44 @@
+module Oschii
+  class Servlet < WEBrick::HTTPServlet::AbstractServlet
+    def initialize(server, cloud)
+      super
+      @cloud = cloud
+    end
+
+    attr_reader :cloud
+
+    def add_headers(res)
+      res.header['Access-Control-Allow-Origin'] = '*'
+      res.header['Access-Control-Allow-Methods'] = 'GET'
+      res.header['Vary'] = 'Access-Control-Request-Headers'
+      res.header['Access-Control-Allow-Headers'] = 'Content-Type, Accept'
+      res.header['Access-Control-Request-Method'] = '*'
+    end 
+  end
+
+  class GetDevices < Servlet
+    def do_GET(req, res)
+      res.status = 200
+      res.content_type = 'application/json'
+      res.body = cloud.devices.sort_by { |k, _v| k }.map do |name, device|
+        {
+          name: device.name,
+          ip: device.ip,
+          details: device.device_details
+        }
+      end.to_json
+      add_headers res
+    end
+  end
+
+  class RefreshCloud < Servlet
+    def do_POST(req, res)
+      Thread.new do
+        cloud.populate
+      end
+      res.status = 200
+      res.content_type = 'text/plain'
+      res.body = 'Refreshing Cloud'
+    end
+  end
+end

data/lib/oschii/session.rb

@@ -0,0 +1,7 @@
+require 'oschii'
+
+include Oschii
+
+if ENV['OSCHII_AUTO_POPULATE']
+  populate
+end

data/lib/oschii/version.rb

@@ -0,0 +1,3 @@
+module Oschii
+  VERSION = '0.0.1'
+end

data/lib/oschii.rb

@@ -0,0 +1,56 @@
+require 'oschii/version'
+
+require_relative 'oschii/device'
+require_relative 'oschii/http_device'
+require_relative 'oschii/serial_device'
+require_relative 'oschii/cloud'
+require_relative 'oschii/osc_monitor'
+
+module Oschii
+  LOGO = "
+  ╔═╗┌─┐┌─┐┬ ┬┬┬
+  ║ ║└─┐│  ├─┤││
+  ╚═╝└─┘└─┘┴ ┴┴┴
+  -- R U B Y ---
+  #{VERSION.center(14)}
+
+".freeze
+
+  def self.included(base)
+    base.class_eval do
+      puts LOGO
+    end
+  end
+
+  def cloud(silent: false)
+    @cloud ||= Cloud.new(silent: silent)
+  end
+
+  def populate
+    cloud.populate
+  end
+
+  def serve_forever
+    populate
+    puts 'Press ENTER to quit....'
+    gets
+  end
+
+  def serial
+    @serial ||= cloud.find_serial
+  end
+
+  def method_missing(m, *args, &block)
+    return if @cloud.nil?
+
+    node = cloud.get(m)
+
+    return node unless node.nil?
+
+    raise NameError
+  end
+
+  def send_osc(ip, address, *values, port: 3333)
+    OSC::Client.new(ip, port).send(OSC::Message.new(address, *values.to_a))
+  end
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: oschii_ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Barri Mason
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-12-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faye-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: rubyserial
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: osc-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.4
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.1.2
+description: Interfaces with a network of Oschiis
+email: loki@amarantha.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- lib/oschii.rb
+- lib/oschii/cloud.rb
+- lib/oschii/device.rb
+- lib/oschii/http_device.rb
+- lib/oschii/osc_monitor.rb
+- lib/oschii/serial_device.rb
+- lib/oschii/servlets.rb
+- lib/oschii/session.rb
+- lib/oschii/version.rb
+homepage: https://rubygems.org/gems/oschii_ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: 2.7.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Gem for managing Oschiis
+test_files: []