matrix_creator 0.0.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d21b212be4bd23cc70b6acf2c1e1a4494c991a48
-  data.tar.gz: e9aa9dd8aa1913ad4edc004bb9b2fcbc7291d30d
+  metadata.gz: d3dd6fc5e8a17ab1866611eadf427252ddfe0d46
+  data.tar.gz: 0ba05783b39c14f454a93a591905c23cdbf704f7
 SHA512:
-  metadata.gz: 85cbc478d93e0662318120b07116c24aa616ecfbc3e1aa5a30b5380b80a13fc4ace651b47479fe7d3eda8de286853dce4815abbe77b15d0daa81c4bf9199cf93
-  data.tar.gz: 80e623c607debe434c081eaed03383cd9b0ad275b61a41a4510a1d70581f59adbdcabe991de823e9584ca2ac0dcab4ed2150f50e6915e1532a037efa2c7f08bc
+  metadata.gz: 1f801925095f6649e709e0eb3a5cceecc203e53d8e2c17ca2748aef46628632e1f63e840b63c481969727056f603c11ced15d12704a791dbcd8d43684586c095
+  data.tar.gz: fc289525820b176c474713611771a53bfa5f67331524263f845cbf472d1ab323deb5eb576bc116f30e3a23fd544ed32c634c23fa6b6f5d9269d8853ad52f0ff6

data/README.md

@@ -1,8 +1,10 @@
 # MatrixCreator
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/matrix_creator`. To experiment with that code, run `bin/console` for an interactive prompt.
+Abstraction level RubyGem for the [MATRIX Creator](https://creator.matrix.one/) device to interact with its sensors and interfaces.
 
-TODO: Delete this and the text above, and describe your gem
+## Dependencies
+
+TODO: Include dependencies needed for a brand news RaspberryPi installation
 
 ## Installation
 
@@ -22,20 +24,16 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+For usage instructions you can refer to our [Wiki](https://github.com/vikonava/matrix_creator/wiki).
 
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/matrix_creator. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
-
+Bug reports and pull requests are welcome on GitHub at https://github.com/vikonava/matrix_creator. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-
+The gem is available as open source under the terms of the [GNU AGPLv3](http://www.gnu.org/licenses/agpl-3.0.txt).

data/config/matrix_creator.yml

@@ -0,0 +1,26 @@
+matrix:
+  ip: '127.0.0.1'
+  port_offset:
+    base: 0
+    error: 1
+    keep_alive: 2
+    data: 3
+  devices:
+    imu:
+      port: 20013
+    humidity:
+      port: 20017
+    everloop:
+      port: 20021
+    pressure:
+      port: 20025
+    uv:
+      port: 20029
+    zigbee_bulb:
+      port: 20033
+    microphone:
+      port: 20037  
+    lirc:
+      port: 20041
+    vision:
+      port: 22013

data/lib/matrix_creator.rb

@@ -1,5 +1,28 @@
-require "matrix_creator/version"
+require 'google/protobuf'
+require 'yaml'
+require 'json'
+require 'timeout'
+require 'rbczmq'
 
+require 'matrix_creator/version'
+
+##
+# Main module for Matrix Creator
 module MatrixCreator
-  # Your code goes here...
+  # Returns a hash of settings to be used by Matrix Creator
+  #
+  # @return [Hash] the symbolized names object from config/matrix_creator.yml
+  def self.settings
+    @@_matrix_creator_config ||= JSON.parse(
+      JSON.dump(YAML.load_file('config/matrix_creator.yml')),
+      symbolize_names: true
+    )[:matrix]
+  end
 end
+
+require 'matrix_creator/everloop'
+require 'matrix_creator/vision'
+require 'matrix_creator/imu'
+require 'matrix_creator/humidity'
+require 'matrix_creator/pressure'
+require 'matrix_creator/uv'

data/lib/matrix_creator/comm.rb

@@ -0,0 +1,265 @@
+require 'fileutils'
+require 'json'
+
+module MatrixCreator
+  ##
+  # Class: Comm
+  #
+  # This class is used to communicate to the chipset by using ZeroMQ sockets
+  class Comm # rubocop:disable Metrics/ClassLength
+    # Contains the IP address to be used to connect to the Matrix Creator chipset
+    MATRIX_CREATOR_IP = MatrixCreator.settings[:ip]
+
+    # Maximum number of old log files to keep
+    MAX_OLD_FILES = 10
+
+    # Maximum size for each log file
+    MAX_LOG_SIZE = 102_400_000
+
+    # Current logger level to store
+    LOG_LEVEL = Logger::WARN
+
+    # Pinging speed
+    PING_SPEED = 3
+
+    # Speed to check for timeout
+    TIMEOUT_VERIFICATION_SPEED = 1
+
+    # Contains the ZMQ::Context instance used
+    attr_reader :context
+
+    # Contains device base port
+    attr_reader :device_port
+
+    ##
+    # Creates an instance of Comm to be used as communication with chipset's device
+    #
+    # @param device_port [Integer] port of the device to communicate with
+    def initialize(device_port)
+      initialize_logger
+
+      # Creating instance variables
+      print_log(:debug, 'Initializing instance')
+      @context = ::ZMQ::Context.new
+      @device_port = device_port
+    end
+
+    ##
+    # Sends configuration data to the driver
+    #
+    # @param driver_config [MatrixMalos::DriverConfig] data message
+    def send_configuration(driver_config)
+      # Connecting to the configuration port
+      socket_address = "tcp://#{MATRIX_CREATOR_IP}:#{@device_port}"
+      config_socket = @context.socket(:PUSH)
+      config_socket.connect(socket_address)
+      print_log(:debug, "config_socket connected to #{socket_address}")
+
+      # Sending Encoded Data
+      config_data = MatrixMalos::DriverConfig.encode(driver_config)
+      config_socket.send(config_data)
+      print_log(:info, 'Configuration sent to driver')
+      print_log(:debug, "Data: #{driver_config.to_json}")
+    end
+
+    ##
+    # Pings the driver keep-alive port every 3 seconds until listener finishes running
+    #
+    # @param main_thread [Thread] the main listener
+    # @return [Thread] instance
+    def start_pinging(main_thread)
+      Thread.new do
+        # Connecting to the keep-alive port
+        socket_address = "tcp://#{MATRIX_CREATOR_IP}:#{@device_port + 1}"
+        ping_socket = @context.socket(:PUSH)
+        ping_socket.connect(socket_address)
+        print_log(:debug, "ping_socket connected to #{socket_address}")
+
+        # Infinite loop that breaks when main thread has finished
+        loop do
+          # Send Ping
+          ping_socket.send('')
+          print_log(:info, 'Ping sent')
+
+          sleep(PING_SPEED)
+
+          break if main_thread[:finished]
+        end
+
+        print_log(:debug, 'Stopped pinging')
+      end
+    end
+
+    ##
+    # Connects to the error port to listen for any errors reported
+    #
+    # @return [Thread] instance
+    def start_error_listener
+      Thread.new do
+        # Connecting to the error port
+        socket_address = "tcp://#{MATRIX_CREATOR_IP}:#{@device_port + 2}"
+        error_socket = @context.socket(:SUB)
+        error_socket.connect(socket_address)
+        error_socket.subscribe('')
+
+        # Infinite loop to listen for errors, this thread will be killed
+        # by the main thread when it needs to be stopped
+        loop do
+          # Read and log error messages
+          error_msg = error_socket.recv_message
+          print_log(:error, error_msg.data)
+        end
+      end
+    end
+
+    ##
+    # Main thread that listens for data reported by the driver data port.
+    # It will listen for any errors until the maximum number of messages expected
+    # to be received is reached or until it is killed by the timeout verification.
+    #
+    # @param decoder [MatrixMalos] module to be used to decode data received
+    # @param max_resp [Integer] maximum number of messages to receive
+    # @param error_thread [Thread] instance that logs errors
+    # @param block callback method to be executed when a message has been received
+    # @return [Thread] instance
+    def start_data_listener(decoder, max_resp, error_thread, block = nil)
+      Thread.new do
+        # Initialize current number of messages received
+        count = 0
+
+        begin
+          # Thread variable that indicates if this thread has finished
+          Thread.current[:finished] = false
+
+          # Thread variable that contains an array of messages received
+          # for further processing
+          Thread.current[:result] = []
+
+          # Connecting to the data port
+          socket_address = "tcp://#{MATRIX_CREATOR_IP}:#{@device_port + 3}"
+          data_socket = @context.socket(:SUB)
+          data_socket.connect(socket_address)
+          print_log(:debug, "data_socket connected to #{socket_address}")
+          data_socket.subscribe('')
+          print_log(:info, "Listening for data (max_resp: #{max_resp || 'Unlimited'})")
+
+          loop do
+            # Receiving data
+            data = data_socket.recv
+            print_log(:info, 'Data received')
+            decoded_data = JSON.parse(decoder.decode(data).to_json, symbolize_names: true)
+            print_log(:debug, "Data: #{decoded_data}")
+
+            # Push decoded data into the results array
+            Thread.current[:result] << decoded_data
+
+            # Send data to callback method
+            block.call(decoded_data) if block
+
+            # Increment count and break loop if max number of
+            # messages has been reached
+            count += 1
+            break if max_resp && count >= max_resp
+          end
+        rescue => e
+          print_log(:fatal, e.message)
+        end
+
+        # Mark thread as finished
+        Thread.current[:finished] = true
+        print_log(:info, 'Finished listening')
+
+        # Kill error thread, no longer need to log errors
+        Thread.kill(error_thread)
+        print_log(:info, 'Killed error listener thread')
+      end
+    end
+
+    ##
+    # Verifies if there is a timeout according to the max number of seconds specified,
+    # if there is then all threads are killed
+    #
+    # @param max_secs [Integer] maximum number of seconds to gather data
+    # @param main_thread [Thread] instance of the main data listener
+    # @param error_thread [Thread] instance of the error listener
+    # @param ping_thread [Thread] instance of the ping thread
+    def verify_timeout(max_secs, main_thread, error_thread, ping_thread)
+      current_time = Time.now
+
+      print_log(:info, "Starting timeout verification (max_secs: #{max_secs})")
+
+      loop do
+        # Break if main thread is finished, we no longer need to check for timeout
+        break if main_thread[:finished]
+
+        # If there is a timeout, kill all threads and break
+        if Time.now >= current_time + max_secs
+          print_log(:info, 'Listener timed out, killing all threads')
+          Thread.kill(main_thread)
+          Thread.kill(error_thread)
+          Thread.kill(ping_thread)
+          break
+        end
+
+        sleep(TIMEOUT_VERIFICATION_SPEED)
+      end
+
+      print_log(:info, 'Finishing timeout verification')
+    end
+
+    ##
+    # Start the listening proccess on a driver.
+    #
+    # @param decoder [MatrixMalos] module to be used to decode data received
+    # @param options [Hash] contains the options that can be specified for a max_resp and/or max_secs
+    # @yield callback used to process data received from the driver
+    # @return an array with a list of all the messages received
+    def perform(decoder, options = {}, block = nil)
+      # Start running threads
+      error_thread = start_error_listener
+      data_thread = start_data_listener(decoder, options[:max_resp], error_thread, block)
+      ping_thread = start_pinging(data_thread)
+
+      # Verify timeout if that option is specified
+      if options[:max_secs]
+        verify_timeout(options[:max_secs], data_thread, error_thread, ping_thread)
+      end
+
+      # Wait for threads to finish
+      data_thread.join
+      error_thread.join
+      ping_thread.join
+
+      # Return data captured from the driver
+      print_log(:debug, "Data Result: #{data_thread[:result].to_json}")
+      data_thread[:result]
+    end
+
+    ##
+    # Destroy the ZMQ::Context instance, since there can only be one running per proccess
+    def destroy
+      print_log(:info, 'Destroying ZMQ context')
+      @context.destroy
+    end
+
+    private
+
+    ##
+    # Initialize logger instance
+    def initialize_logger
+      # Logger initialization
+      FileUtils.mkdir_p('log/') unless File.directory?('log/')
+      @logger = Logger.new('log/matrix_creator.log', MAX_OLD_FILES, MAX_LOG_SIZE)
+      @logger.level = LOG_LEVEL
+    end
+
+    ##
+    # Send a message to the logger instance
+    #
+    # @param level [Symbol] logging level for the message
+    # @param msg [String] message to be logged
+    def print_log(level, msg)
+      @logger.send(level, "[Instance: #{object_id}] #{msg}")
+    end
+  end
+end

data/lib/matrix_creator/driver_base.rb

@@ -0,0 +1,47 @@
+# Load Protos
+require 'protos/malos/driver_pb'
+
+# Load Dependencies
+require 'matrix_creator/comm'
+
+module MatrixCreator
+  # Module: DriverBase
+  #
+  # Base communication for generic drivers
+  module DriverBase
+    ##
+    # Detects and returns information from a generic driver
+    #
+    # @param base_port [Integer] indicates the base port to communicate to the driver
+    # @param decoder ProtoBuf to use for decoding returned data
+    # @param options [Hash] of keys and values that can contain speed, max_resp and/or max_secs
+    # @return [Array] elements detected in JSON format
+    #
+    # @example Detect value from a driver and return data
+    #   MatrixCreator::DriverBase.detect(8888, MatrixMalos::Imu, max_resp: 3)
+    #
+    # @example Detect value from a driver and process data immediatly when received
+    #   MatrixCreator::DriverBase.detect(8888, MatrixMalos::Imu, max_resp: 3) { |data|
+    #     // Do something with data
+    #   }
+    #
+    def self.detect(base_port, decoder, options = {}, block = nil)
+      @driver_comm = MatrixCreator::Comm.new(base_port)
+
+      # Setup Driver
+      config = MatrixMalos::DriverConfig.new(
+        delay_between_updates: options[:speed] || 1.0,
+        timeout_after_last_ping: 4.0
+      )
+      @driver_comm.send_configuration(config)
+
+      # Query Driver
+      result = @driver_comm.perform(decoder, options, block)
+
+      # Destroy context
+      @driver_comm.destroy
+
+      result
+    end
+  end
+end

data/lib/matrix_creator/everloop.rb

@@ -0,0 +1,48 @@
+# Load Protos
+require 'protos/malos/driver_pb'
+
+# Load Dependencies
+require 'matrix_creator/comm'
+require 'matrix_creator/everloop/color'
+require 'matrix_creator/everloop/spinner'
+require 'matrix_creator/everloop/pulse'
+
+module MatrixCreator
+  # Module: Everloop
+  #
+  # Communicate with the Everloop driver
+  module Everloop
+    # Configuration values for the Everloop driver
+    EVERLOOP_CONFIG = MatrixCreator.settings[:devices][:everloop]
+
+    # Base port to send data to Everloop driver
+    BASE_PORT = EVERLOOP_CONFIG[:port]
+
+    ##
+    # Change the color of all of the Leds on the Everloop driver
+    #
+    # @param color [Hash] with the rgb+w values for the color
+    #
+    # @example Change leds using predetermined color
+    #   MatrixCreator::Everloop.modify_color(MatrixCreator::Everloop::Color::GREEN)
+    #
+    # @example Change leds using custom
+    #   MatrixCreator::Everloop.modify_color({ r: 5, g: 3, b: 9, w: 0 })
+    #
+    def self.modify_color(color)
+      everloop_comm = MatrixCreator::Comm.new(BASE_PORT)
+
+      # Generate 35 instances of LedValue with the same color
+      image = (1..35).map do
+        MatrixMalos::LedValue.new(red: color[:r], green: color[:g],
+                                  blue: color[:b], white: color[:w])
+      end
+
+      everloop_image = MatrixMalos::EverloopImage.new(led: image)
+      msg = MatrixMalos::DriverConfig.new(image: everloop_image)
+      everloop_comm.send_configuration(msg)
+
+      everloop_comm.destroy
+    end
+  end
+end