matrix_creator 0.0.0 → 1.0.0

data/lib/matrix_creator/everloop/animation.rb

@@ -0,0 +1,67 @@
+module MatrixCreator
+  module Everloop
+    ##
+    # Class to be inherited by Animations
+    class Animation
+      # Interval between animation updates in milliseconds
+      ANIMATION_SPEED = 0.1 # 100ms
+
+      ##
+      # Run a block of code while displaying an animation on the Everloop driver
+      #
+      # @param color [Hash] with the rgb+w values for the color
+      # @yield Block of code to be executed while displaying the spinner
+      # @return response from the block of code execution
+      #
+      # @example Run a block of code and display a spinner until it finishes
+      #
+      #   MatrixCreator::Everloop::Spinner.run {
+      #     // Do Something
+      #   }
+      #
+      # @example Run a block of code and display a green spinner until it finishes
+      #
+      #   color = MatrixCreator::Everloop::Color::GREEN
+      #
+      #   MatrixCreator::Everloop::Spinner.run(color) {
+      #     // Do Something
+      #   }
+      #
+      # @example Run a block of code and display a pulse until it finishes
+      #
+      #   MatrixCreator::Everloop::Pulse.run {
+      #     // Do Something
+      #   }
+      #
+      def self.run(color = Color::WHITE, &block)
+        result = nil
+
+        code_thread = Thread.new do
+          Thread.current[:finished] = false
+          result = yield if block
+          Thread.current[:finished] = true
+        end
+
+        animation_thread = Thread.new do
+          animation = new(color, code_thread)
+          animation.loop_animation
+          animation.destroy_context
+        end
+
+        # Turn off the leds on the Everloop driver
+        code_thread.join
+        animation_thread.join
+        Everloop.modify_color(Color::OFF)
+
+        # Return result of the code block
+        result
+      end
+
+      ##
+      # Sends a request to destroy the context of the everloop comm instance
+      def destroy_context
+        @everloop_comm.destroy
+      end
+    end
+  end
+end

data/lib/matrix_creator/everloop/color.rb

@@ -0,0 +1,63 @@
+module MatrixCreator
+  module Everloop
+    ##
+    # Contains the constants to be used for RGB+W Color values
+    module Color
+      # Contains the hash values for the color white
+      # @return [Hash] rgb+w values for this color
+      WHITE = { r: 0, g: 0, b: 0, w: 10 }.freeze
+
+      # Contains the hash values for the color red
+      # @return [Hash] rgb+w values for this color
+      RED = { r: 10, g: 0, b: 0, w: 0 }.freeze
+
+      # Contains the hash values for the color orange
+      # @return [Hash] rgb+w values for this color
+      ORANGE = { r: 10, g: 2, b: 0, w: 0 }.freeze
+
+      # Contains the hash values for the color yellow
+      # @return [Hash] rgb+w values for this color
+      YELLOW = { r: 10, g: 5, b: 0, w: 0 }.freeze
+
+      # Contains the hash values for the color spring green
+      # @return [Hash] rgb+w values for this color
+      SPRING_GREEN = { r: 8, g: 10, b: 0, w: 0 }.freeze
+
+      # Contains the hash values for the color green
+      # @return [Hash] rgb+w values for this color
+      GREEN = { r: 0, g: 10, b: 0, w: 0 }.freeze
+
+      # Contains the hash values for the color turquoise
+      # @return [Hash] rgb+w values for this color
+      TURQUOISE = { r: 0, g: 10, b: 2, w: 0 }.freeze
+
+      # Contains the hash values for the color cyan
+      # @return [Hash] rgb+w values for this color
+      CYAN = { r: 0, g: 10, b: 10, w: 0 }.freeze
+
+      # Contains the hash values for the color ocean
+      # @return [Hash] rgb+w values for this color
+      OCEAN = { r: 0, g: 6, b: 10, w: 0 }.freeze
+
+      # Contains the hash values for the color blue
+      # @return [Hash] rgb+w values for this color
+      BLUE = { r: 0, g: 0, b: 10, w: 0 }.freeze
+
+      # Contains the hash values for the color violet
+      # @return [Hash] rgb+w values for this color
+      VIOLET = { r: 4, g: 0, b: 10, w: 0 }.freeze
+
+      # Contains the hash values for the color magenta
+      # @return [Hash] rgb+w values for this color
+      MAGENTA = { r: 10, g: 0, b: 10, w: 0 }.freeze
+
+      # Contains the hash values for the color raspberry
+      # @return [Hash] rgb+w values for this color
+      RASPBERRY = { r: 10, g: 0, b: 3, w: 0 }.freeze
+
+      # Contains the hash values to turn off the Led
+      # @return [Hash] rgb+w values for this color
+      OFF = { r: 0, g: 0, b: 0, w: 0 }.freeze
+    end
+  end
+end

data/lib/matrix_creator/everloop/pulse.rb

@@ -0,0 +1,62 @@
+# Load Dependencies
+require 'matrix_creator/everloop/animation'
+
+module MatrixCreator
+  module Everloop
+    ##
+    # Pulse animation class
+    class Pulse < Animation
+      ##
+      # Initializes the variables on the instance to prepare for the
+      # loop animation
+      #
+      # @param color [Hash] with the rgb+w values for the color
+      # @param code_thread [Thread] instance with main thread
+      def initialize(color, code_thread)
+        @everloop_comm = MatrixCreator::Comm.new(BASE_PORT)
+        @code_thread = code_thread
+        @intensity = 0
+        @intensity_next_value = 1
+
+        # Generate everloop messages
+        @everloop_msgs = (0..10).map do |msg_intensity|
+          image = (1..35).map do
+            MatrixMalos::LedValue.new(
+              red: ((color[:r] / 10) * msg_intensity).round,
+              green: ((color[:g] / 10) * msg_intensity).round,
+              blue: ((color[:b] / 10) * msg_intensity).round,
+              white: ((color[:w] / 10) * msg_intensity).round
+            )
+          end
+
+          MatrixMalos::DriverConfig.new(
+            image: MatrixMalos::EverloopImage.new(led: image)
+          )
+        end
+      end
+
+      ##
+      # Loop animation until main code thread finishes
+      def loop_animation
+        loop do
+          @everloop_comm.send_configuration(@everloop_msgs[@intensity])
+
+          @intensity += @intensity_next_value
+
+          # Pulse intensity behavior
+          if @intensity == 11
+            @intensity = 10
+            @intensity_next_value = -1
+          elsif @intensity == -1
+            @intensity = 0
+            @intensity_next_value = 1
+          end
+
+          sleep(ANIMATION_SPEED)
+
+          break if @code_thread[:finished]
+        end
+      end
+    end
+  end
+end

data/lib/matrix_creator/everloop/spinner.rb

@@ -0,0 +1,52 @@
+# Load Dependencies
+require 'matrix_creator/everloop/animation'
+
+module MatrixCreator
+  module Everloop
+    ##
+    # Spinner animation class
+    class Spinner < Animation
+      ##
+      # Initializes the variables on the instance to prepare for the
+      # loop animation
+      #
+      # @param color [Hash] with the rgb+w values for the color
+      # @param code_thread [Thread] instance with main thread
+      def initialize(color, code_thread)
+        @everloop_comm = MatrixCreator::Comm.new(BASE_PORT)
+        @code_thread = code_thread
+
+        # Generating array of led messages
+        @led_array = (1..35).map do |i|
+          if i <= 5
+            MatrixMalos::LedValue.new(
+              red: (color[:r] * i * 2) / 10,
+              green: (color[:g] * i * 2) / 10,
+              blue: (color[:b] * i * 2) / 10,
+              white: (color[:w] * i * 2) / 10
+            )
+          else
+            MatrixMalos::LedValue.new(red: 0, green: 0, blue: 0, white: 0)
+          end
+        end
+      end
+
+      ##
+      # Loop animation until main code thread finishes
+      def loop_animation
+        loop do
+          everloop_image = MatrixMalos::EverloopImage.new(led: @led_array)
+          msg = MatrixMalos::DriverConfig.new(image: everloop_image)
+          @everloop_comm.send_configuration(msg)
+
+          sleep(ANIMATION_SPEED)
+
+          break if @code_thread[:finished]
+
+          # Rotate the 5 led instances order in the array
+          @led_array.rotate!(-1)
+        end
+      end
+    end
+  end
+end

data/lib/matrix_creator/humidity.rb

@@ -0,0 +1,48 @@
+# Load Dependencies
+require 'matrix_creator/driver_base'
+
+module MatrixCreator
+  # Module: Humidity
+  #
+  # Communicate with the Humidity driver
+  module Humidity
+    # Configuration values for the Humidity driver
+    HUMIDITY_CONFIG = MatrixCreator.settings[:devices][:humidity]
+
+    # Base port to send data to Humidity driver
+    BASE_PORT = HUMIDITY_CONFIG[:port]
+
+    ##
+    # Detects and returns information from the Humidity driver
+    #
+    # @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 3 values for the Humidity driver
+    #   MatrixCreator::Humidity.detect(max_resp: 3)
+    #
+    # @example Detect values for the Humidity driver for 30 seconds
+    #   MatrixCreator::Humidity.detect(max_secs: 30)
+    #
+    # @example Detect values for the Humidity driver with a speed of 0.5 seconds per response
+    #   MatrixCreator::Humidity.detect(max_secs: 30, speed: 0.5)
+    #
+    # @example Detect values for the Humidity driver for 15 seconds and process data when received
+    #   MatrixCreator::Humidity.detect(max_resp: 10){ |data|
+    #     // Do something with the data
+    #   }
+    #
+    def self.detect(options = {}, &block)
+      MatrixCreator::DriverBase.detect(BASE_PORT, MatrixMalos::Humidity, options, block)
+    end
+
+    ##
+    # Detects one response from the Humidity driver and returns its value
+    #
+    # @return [Hash] object with the Humidity response values
+    #
+    def self.detect_once
+      detect(max_resp: 1).first
+    end
+  end
+end

data/lib/matrix_creator/imu.rb

@@ -0,0 +1,48 @@
+# Load Dependencies
+require 'matrix_creator/driver_base'
+
+module MatrixCreator
+  # Module: IMU
+  #
+  # Communicate with the IMU driver
+  module Imu
+    # Configuration values for the IMU driver
+    IMU_CONFIG = MatrixCreator.settings[:devices][:imu]
+
+    # Base port to send data to IMU driver
+    BASE_PORT = IMU_CONFIG[:port]
+
+    ##
+    # Detects and returns information from the IMU driver
+    #
+    # @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 3 values for the IMU driver
+    #   MatrixCreator::Imu.detect(max_resp: 3)
+    #
+    # @example Detect values for the IMU driver for 30 seconds
+    #   MatrixCreator::Imu.detect(max_secs: 30)
+    #
+    # @example Detect values for the IMU driver with a speed of 0.5 seconds per response
+    #   MatrixCreator::Imu.detect(max_secs: 30, speed: 0.5)
+    #
+    # @example Detect values for the IMU driver for 15 seconds and process data when received
+    #   MatrixCreator::Imu.detect(max_resp: 10){ |data|
+    #     // Do something with the data
+    #   }
+    #
+    def self.detect(options = {}, &block)
+      MatrixCreator::DriverBase.detect(BASE_PORT, MatrixMalos::Imu, options, block)
+    end
+
+    ##
+    # Detects one response from the IMU driver and returns its value
+    #
+    # @return [Hash] object with the IMU response values
+    #
+    def self.detect_once
+      detect(max_resp: 1).first
+    end
+  end
+end

data/lib/matrix_creator/pressure.rb

@@ -0,0 +1,48 @@
+# Load Dependencies
+require 'matrix_creator/driver_base'
+
+module MatrixCreator
+  # Module: Pressure
+  #
+  # Communicate with the Pressure driver
+  module Pressure
+    # Configuration values for the Pressure driver
+    PRESSURE_CONFIG = MatrixCreator.settings[:devices][:pressure]
+
+    # Base port to send data to Pressure driver
+    BASE_PORT = PRESSURE_CONFIG[:port]
+
+    ##
+    # Detects and returns information from the Pressure driver
+    #
+    # @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 3 values for the Pressure driver
+    #   MatrixCreator::Pressure.detect(max_resp: 3)
+    #
+    # @example Detect values for the Pressure driver for 30 seconds
+    #   MatrixCreator::Pressure.detect(max_secs: 30)
+    #
+    # @example Detect values for the Pressure driver with a speed of 0.5 seconds per response
+    #   MatrixCreator::Pressure.detect(max_secs: 30, speed: 0.5)
+    #
+    # @example Detect values for the Pressure driver for 15 seconds and process data when received
+    #   MatrixCreator::Pressure.detect(max_resp: 10){ |data|
+    #     // Do something with the data
+    #   }
+    #
+    def self.detect(options = {}, &block)
+      MatrixCreator::DriverBase.detect(BASE_PORT, MatrixMalos::Pressure, options, block)
+    end
+
+    ##
+    # Detects one response from the Pressure driver and returns its value
+    #
+    # @return [Hash] object with the Pressure response values
+    #
+    def self.detect_once
+      detect(max_resp: 1).first
+    end
+  end
+end

data/lib/matrix_creator/uv.rb

@@ -0,0 +1,48 @@
+# Load Dependencies
+require 'matrix_creator/driver_base'
+
+module MatrixCreator
+  # Module: UV
+  #
+  # Communicate with the UV driver
+  module Uv
+    # Configuration values for the UV driver
+    UV_CONFIG = MatrixCreator.settings[:devices][:uv]
+
+    # Base port to send data to UV driver
+    BASE_PORT = UV_CONFIG[:port]
+
+    ##
+    # Detects and returns information from the UV driver
+    #
+    # @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 3 values for the UV driver
+    #   MatrixCreator::Uv.detect(max_resp: 3)
+    #
+    # @example Detect values for the UV driver for 30 seconds
+    #   MatrixCreator::Uv.detect(max_secs: 30)
+    #
+    # @example Detect values for the UV driver with a speed of 0.5 seconds per response
+    #   MatrixCreator::Uv.detect(max_secs: 30, speed: 0.5)
+    #
+    # @example Detect values for the UV driver for 15 seconds and process data when received
+    #   MatrixCreator::Uv.detect(max_resp: 10){ |data|
+    #     // Do something with the data
+    #   }
+    #
+    def self.detect(options = {}, &block)
+      MatrixCreator::DriverBase.detect(BASE_PORT, MatrixMalos::UV, options, block)
+    end
+
+    ##
+    # Detects one response from the UV driver and returns its value
+    #
+    # @return [Hash] object with the UV response values
+    #
+    def self.detect_once
+      detect(max_resp: 1).first
+    end
+  end
+end