denko 0.13.6 → 0.15.0

data/lib/denko/digital_io/rotary_encoder.rb

@@ -3,104 +3,126 @@ module Denko
     class RotaryEncoder
       include Behaviors::MultiPin
       include Behaviors::Callbacks
+      include Behaviors::Lifecycle
+
+      before_initialize do
+        # Allow pins to be given as printed on common parts.
+        unless params[:pins][:a]
+          params[:pins][:a] = params[:pins][:clk] if params[:pins][:clk]
+          params[:pins][:a] = params[:pins][:clock] if params[:pins][:clock]
+        end
+        unless params[:pins][:b]
+          params[:pins][:b] = params[:pins][:dt] if params[:pins][:dt]
+          params[:pins][:b] = params[:pins][:data] if params[:pins][:data]
+        end
+
+        # But always refer to them as a and b internally.
+        [:clk, :clock, :dt, :data].each { |key| params[:pins].delete(key) }
+      end
+
+      def initialize_pins(params={})
+        proxy_pin :a, DigitalIO::Input
+        proxy_pin :b, DigitalIO::Input
+      end
+
+      after_initialize do
+        a.debounce_time = debounce_time
+        b.debounce_time = debounce_time
+        a.listen(divider)
+        b.listen(divider)
+
+        # Let initial state settle.
+        sleep 0.010
 
-      def initialize_pins(options={})
-        proxy_pin :clock, DigitalIO::Input
-        proxy_pin :data,  DigitalIO::Input
-      end
-
-      def after_initialize(options={})
-        super(options)
-        self.steps_per_revolution = options[:steps_per_revolution] || 30
-        @reverse = false
-
-        # Avoid repeated memory allocation.
-        self.state = { steps: 0, angle: 0 }
-        @reading   = { steps: 0, angle: 0, change: 0}
-        
-        # DigitalInputs listen with default divider automatically. Override here.
-        @divider = options[:divider] || 1
-        clock.listen(@divider)
-        data.listen(@divider)
-        
         observe_pins
         reset
       end
-      
-      attr_reader :reversed
+
+      # PiBoard will use GPIO alerts, default to 1 microsecond debounce time.
+      def debounce_time
+        @debounce_time ||= params[:debounce_time] || 1
+      end
+
+      # Board will default to 1ms digital listeners.
+      def divider
+        @divider ||= params[:divider] || 1
+      end
+
+      def reversed
+        @reversed ||= false || params[:reversed] || params[:reverse]
+      end
 
       def reverse
         @reversed = !@reversed
       end
 
-      def steps_per_revolution
-        (360 / @degrees_per_step).to_i
+      def counts_per_revolution
+        @counts_per_revolution ||= params[:counts_per_revolution] || params[:cpr] || 60
+      end
+
+      def degrees_per_count
+        @degrees_per_count ||= (360 / counts_per_revolution.to_f)
       end
-      
-      def steps_per_revolution=(step_count)
-        @degrees_per_step = 360.to_f / step_count
+
+      def state
+        @state ||= { count: 0, angle: 0 }
       end
-      
+
+      def reading
+        @reading ||= { count: 0, angle: 0, change: 0 }
+      end
+
       def angle
         state[:angle]
       end
 
-      def steps
-        state[:steps]
+      def count
+        state[:count]
       end
-      
+
       def reset
-        self.state = {steps: 0, angle: 0}
+        self.state = {count: 0, angle: 0}
       end
-      
+
       private
 
       def observe_pins
-        #
-        # This is a quirk of listeners reading in numerical order.
-        # When observing the pins, attach a callback to the higher numbered pin (trailing),
-        # then read state of the lower numbered (leading). If not, direction will be reversed.
-        #
-        if clock.pin > data.pin
-          trailing = clock
-          leading = data
-        else
-          trailing = data
-          leading = clock
+        a.add_callback do |a_state|
+          self.update((a_state == b.state) ? 1 : -1)
         end
-        
-        trailing.add_callback do |trailing_state|
-          change = (trailing_state == leading.state) ? 1 : -1
-          change = -change if trailing == clock
-          self.update(change)
+
+        b.add_callback do |b_state|
+          self.update((b_state == a.state) ? -1 : 1)
         end
       end
-      
+
       #
       # Take data (+/- 1 step change) and calculate new state.
-      # Return a hash with the new :steps and :angle. Pass through raw
+      # Return a hash with the new :count and :angle. Pass through raw
       # value in :change, so callbacks can use any of these.
       #
       def pre_callback_filter(step)
         step = -step if reversed
 
-        @reading[:change] = step
-        @state_mutex.synchronize do
-          @reading[:steps] = @state[:steps] + step
-        end      
-        @reading[:angle] = @reading[:steps] * @degrees_per_step % 360
-        
-        @reading
+        @state_mutex.lock
+        reading[:count] = @state[:count] + step
+        @state_mutex.unlock
+
+        reading[:change] = step
+        reading[:angle]  = reading[:count] * degrees_per_count % 360
+
+        reading
       end
 
       #
       # After callbacks, set state to the hash from before, except change.
       #
       def update_state(reading)
-        @state_mutex.synchronize do
-          @state[:steps]  = reading[:steps]
-          @state[:angle]  = reading[:angle]
-        end
+        @state_mutex.lock
+        @state[:count] = reading[:count]
+        @state[:angle] = reading[:angle]
+        @state_mutex.unlock
+        @state
       end
     end
   end

data/lib/denko/digital_io.rb

@@ -1,9 +1,28 @@
+# Represent files to be autoloaded in CRuby as an Array.
+# This allows Mruby::Build to parse and preload them instead.
+DIGITAL_IO_FILES = [
+  [:Input,          "input"],
+  [:Output,         "output"],
+  [:Button,         "button"],
+  [:Relay,          "relay"],
+  [:RotaryEncoder,  "rotary_encoder"],
+  [:PCF8574,        "pcf8574"],
+]
+
+# On mruby, define this early since bit-bang I2C, SPI and 1-Wire depend on it.
+DIGITAL_IO_EARLY_FILES = [
+  [:CBitBang, "c_bit_bang"],
+]
+
 module Denko
   module DigitalIO
-    autoload :Input,          "#{__dir__}/digital_io/input"
-    autoload :Output,         "#{__dir__}/digital_io/output"
-    autoload :Button,         "#{__dir__}/digital_io/button"
-    autoload :Relay,          "#{__dir__}/digital_io/relay"
-    autoload :RotaryEncoder,  "#{__dir__}/digital_io/rotary_encoder"
+    (DIGITAL_IO_EARLY_FILES + DIGITAL_IO_FILES).each do |file|
+      file_path = "#{__dir__}/digital_io/#{file[1]}"
+      if file[0]
+        autoload file[0], file_path
+      else
+        require file_path
+      end
+    end
   end
 end