denko 0.13.3 → 0.13.5

data/examples/sensor/neat_tph_readings.rb

@@ -0,0 +1,26 @@
+#
+# This helper method can be used in temp/pressure/humidity sensor examples.
+# Give a hash with readings as float values and it prints them neatly.
+#
+def print_tph_reading(reading)
+  # Time
+  print "#{Time.now.strftime '%Y-%m-%d %H:%M:%S'} - "
+  
+  # Temperature
+  formatted_temp = reading[:temperature].to_f.round(2).to_s.ljust(5, '0')
+  print "Temperature: #{formatted_temp} \xC2\xB0C"
+  
+  # Pressure
+  if reading[:pressure]
+    formatted_pressure = (reading[:pressure] / 101325).round(5).to_s.ljust(7, '0')
+    print " | Pressure #{formatted_pressure} atm"
+  end
+  
+  # Humidity  
+  if reading[:humidity]
+    formatted_humidity = reading[:humidity].round(2).to_s.ljust(5, '0')
+    print " | Humidity #{formatted_humidity} %"
+  end
+  
+  puts
+end

data/examples/sensor/qmp6988.rb

@@ -0,0 +1,53 @@
+#
+# Example using QMP6988 sensor over I2C, for air temperature and pressure.
+#
+require 'bundler/setup'
+require 'denko'
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+bus = Denko::I2C::Bus.new(board: board, pin: :SDA)
+sensor = Denko::Sensor::QMP6988.new(bus: bus) # address: 0x70 default
+
+# Verify chip_id.
+print "I2C device has chip ID: 0x#{sensor.chip_id.to_s(16).upcase}. "
+if sensor.chip_id == 0x5C
+  puts "This matches the QMP6988."
+else
+  puts "This does not match the QMP6988."
+end
+puts
+
+#
+# Change measurement settings:
+#   temperature_samples can be 1,2,4,8,16,32 or 64 (default: 1)
+#   pressure_samples    can be 1,2,4,8,16,32 or 64 (default: 1)
+#   iir_coefficient     can be 0,2,4,8,16 or 32    (default: 0)
+#
+# High accuracy settings from datasheet, with IIR of 2.
+sensor.temperature_samples = 2
+sensor.pressure_samples = 16
+sensor.iir_coefficient = 2
+
+#
+# Change mode (default: forced_mode)
+#
+# Buggy on ESP32S3 in forced mode. Data registers return zeroes on all but first read.
+# Can't recreate on ESP32 V1, AVR or SAMD21. Put it in contiuous mode just in case.
+sensor.continuous_mode
+# sensor.forced_mode
+
+#
+# Set standby time (between measurements) for continuous mode only:
+#   standby_time (given in ms) can be 1,5,20,250,500,1000,2000 or 4000 (default: 1)
+#
+# sensor.standby_time = 500
+
+# Get the shared #print_tph_reading method to print readings neatly.
+require_relative 'neat_tph_readings'
+
+# Poll it and print readings.
+sensor.poll(5) do |reading|
+  print_tph_reading(reading)
+end
+
+sleep

data/examples/sensor/rcwl9620.rb

@@ -0,0 +1,15 @@
+#
+# Example using an RCWL-9620 sensor over I2C to measure distance.
+#
+require 'bundler/setup'
+require 'denko'
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+bus = Denko::I2C::Bus.new(board: board, pin: :SDA)
+sensor = Denko::Sensor::RCWL9620.new(bus: bus) # address: 0x57 default
+
+sensor.poll(1) do |distance|
+  puts "Distance is #{distance} mm"
+end
+
+sleep

data/examples/sensor/sht3x.rb

@@ -0,0 +1,34 @@
+#
+# Example using SHT30/31/35 sensor over I2C, for temperature and humidity.
+#
+require 'bundler/setup'
+require 'denko'
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+bus = Denko::I2C::Bus.new(board: board, pin: :SDA)
+sensor = Denko::Sensor::SHT3X.new(bus: bus) # address: 0x44 default
+
+# Heater control
+sensor.heater_on
+puts "Heater on: #{sensor.heater_on?}"
+sensor.heater_off
+puts "Heater off: #{sensor.heater_off?}"
+
+# Reset (turns heater off)
+sensor.reset
+puts "Resetting..."
+puts "Heater off: #{sensor.heater_off?}"
+puts
+
+# Set repeatability= :low, :medium or :high (default). See datasheet for details.
+sensor.repeatability = :high
+
+# Get the shared #print_tph_reading method to print readings neatly.
+require_relative 'neat_tph_readings'
+
+# Poll it and print readings.
+sensor.poll(5) do |reading|
+  print_tph_reading(reading)
+end
+
+sleep

data/lib/denko/board/pulse.rb

@@ -22,5 +22,9 @@ module Denko
                             value: settings,
                             aux_message: aux
     end
+
+    def hcsr04_read(echo_pin, trigger_pin)
+      write Message.encode(command: 20, pin: echo_pin, value: trigger_pin)
+    end
   end
 end

data/lib/denko/board.rb

@@ -110,6 +110,7 @@ module Denko
     # Component generating convenience methods. TODO: add more!
     #
     def eeprom
+      raise StandardError, 'board has no built-in EEPROM, or EEPROM disabled in sketch' if @eeprom_length == 0
       @eeprom ||= EEPROM::BuiltIn.new(board: self)
     end
   end

data/lib/denko/sensor/bme280.rb

@@ -28,7 +28,7 @@ module Denko
       # be skipped, since the other 2 calculations depend on it.
       #
       # General formula:
-      #   2 ^ (n-1), where n is the decimal value of the bits, up to 16x max oversampling.
+      #   2 ** (n-1), where n is the decimal value of the bits, up to 16x max oversampling.
       #
       OVERSAMPLE_FACTORS = {
                               0  =>  0b000, # Sensor skipped. Value will be 0x800000.

data/lib/denko/sensor/bmp180.rb

@@ -0,0 +1,223 @@
+module Denko
+  module Sensor
+    class BMP180
+      include I2C::Peripheral
+      include Behaviors::Poller
+      
+      # Write this to register 0xE0 for soft reset
+      SOFT_RESET = 0xB6
+
+      #
+      # Pressure Oversample Setting Values
+      #
+      # General formula:
+      #   2 ** n, where n is the decimal value of the bits, up to 8x pressure oversampling.
+      #
+      OVERSAMPLE_FACTORS = {
+        1  =>  0b00,
+        2  =>  0b01,
+        4  =>  0b10,
+        8  =>  0b11,
+      }
+
+      def before_initialize(options={})
+        @i2c_address = 0x77
+        super(options)
+      end
+
+      def after_initialize(options={})
+        super(options)
+        
+        # Avoid repeated memory allocation for callback data and state.
+        @reading   = { temperature: nil, pressure: nil }
+        self.state = { temperature: nil, pressure: nil }
+
+        # Default to start conversion off, reading temperature, no pressure oversampling.
+        @register = 0b00001110
+        @calibration_data_loaded = false
+        @oss = 0b00
+
+        # Temporary storage for raw bytes, since two I2C reads are needed for temperature and pressure.
+        @raw_bytes = [0, 0, 0, 0, 0]
+
+        soft_reset
+      end
+
+      #
+      # Configuration Methods
+      #
+      def soft_reset
+        i2c_write(SOFT_RESET)
+      end
+
+      attr_reader :measurement_time
+      
+      def update_measurement_time
+        # Get oversample bits from current register setting.
+        oversample_exponent = (@register & 0b11000000) >> 6
+
+        # Calculate time in milliseconds.
+        extra_samples = (2 ** oversample_exponent) - 1
+        extra_time = extra_samples * 3
+        total_time = 4.5 + extra_time
+
+        # Sleep 1ms extra for safety and convert it to seconds.
+        @measurement_time = (total_time + 1) / 1000.0
+      end
+
+      def pressure_samples=(factor)
+        raise ArgumentError, "invalid oversampling factor: #{factor}" unless OVERSAMPLE_FACTORS.keys.include? factor
+        @oss = OVERSAMPLE_FACTORS[factor]
+      end
+    
+      def write_settings
+        update_measurement_time
+        i2c_write [0xF4, @register]
+      end
+
+      #
+      # Reading Methods
+      #
+      def _start_read_temperature
+        @register = 0x2E
+        write_settings
+      end
+
+      def _start_read_pressure
+        @register = 0x34 | (@oss << 6)
+        write_settings
+      end
+
+      def _read
+        get_calibration_data unless calibration_data_loaded
+
+        _start_read_temperature
+        sleep(@measurement_time)
+        i2c_read 0xF6, 2
+
+        _start_read_pressure
+        sleep(@measurement_time)
+        i2c_read 0xF6, 3
+      end
+
+      def pre_callback_filter(data)
+        # Temperature is 2 bytes.
+        if data.length == 2
+          @raw_bytes[0] = data[0]
+          @raw_bytes[1] = data[1]
+        # Pressure is 3 bytes and triggers callbacks.
+        elsif data.length == 3
+          @raw_bytes[2] = data[0]
+          @raw_bytes[3] = data[1]
+          @raw_bytes[4] = data[2]
+          return decode_reading(@raw_bytes)
+        # Calibration data is 22 bytes.
+        elsif data.length == 22
+          process_calibration(data)
+        end
+
+        # Anything other than pressure avoids callbacks.
+        return nil
+      end
+
+      def update_state(reading)
+        # Checking for Hash ignores calibration data and nil.
+        if reading.class == Hash
+          @state_mutex.synchronize do
+            @state[:temperature] = reading[:temperature]
+            @state[:pressure]    = reading[:pressure]
+          end
+        end
+      end
+
+      def [](key)
+        @state_mutex.synchronize do
+          return @state[key]
+        end
+      end
+      
+      #
+      # Decoding Methods
+      #
+      def decode_reading(bytes)
+        temperature, b5 = decode_temperature(bytes)
+        @reading[:temperature] = temperature
+        @reading[:pressure] = decode_pressure(bytes, b5)
+        @reading
+      end
+
+      def decode_temperature(bytes)
+        # Temperature is bytes [0..2], MSB first.
+        ut = bytes[0] << 8 | bytes[1]
+
+        # Calibration compensation from datasheet
+        x1 = (ut - @calibration[:ac6]) * @calibration[:ac5] / 32768
+        x2 = (@calibration[:mc] * 2048) / (x1 + @calibration[:md])
+        b5 = x1 + x2
+
+        # 160 instead of 16 since datasheet calculates to 0.1 C units.
+        # Float to force the final value into float, but keep b5 integer for pressure.
+        temperature = (b5 + 8) / 160.0
+
+        # Return temperature and b5 for pressure calculation.
+        [temperature, b5]
+      end
+      
+      def decode_pressure(bytes, b5)
+        # Pressure is bytes [2..3], MSB first.
+        up = ((bytes[2] << 16) | (bytes[3] << 8) | (bytes[4])) >> (8 - @oss)
+
+        # Calibration compensation from datasheet
+        b6 = b5 - 4000
+        x1 = (@calibration[:b2] * (b6 * b6 / 4096)) / 2048
+        x2 = @calibration[:ac2] * b6 / 2048
+        x3 = x1 + x2
+        b3 = (((@calibration[:ac1]*4 + x3) << @oss) + 2) / 4
+        x1 = @calibration[:ac3] * b6 / 8192
+        x2 = (@calibration[:b1] * (b6 * b6 / 4096)) / 65536
+        x3 = (x1 + x2 + 2) / 4
+        b4 = (@calibration[:ac4] * ((x3+32768) & 0xFFFF_FFFF)) / 32768
+        b7 = ((up & 0xFFFF_FFFF) - b3) * (50000 >> @oss)
+        if (b7 < 0x8000_0000)
+          p = (b7 * 2) / b4
+        else
+          p = (b7 / b4) * 2
+        end
+        x1 = (p / 256) * (p / 256)
+        x1 = (x1 * 3038) / 65536
+        x2 = (-7357 * p) / 65536
+        p = p + (x1 + x2 + 3791) / 16
+        pressure = p.to_f
+      end
+
+      #
+      # Calibration Methods
+      #
+      attr_reader :calibration_data_loaded
+      
+      def get_calibration_data        
+        #  Calibration data is 22 bytes starting at address 0xAA.
+        read_using -> { i2c_read(0xAA, 22) }
+      end
+
+      def process_calibration(bytes)
+        if bytes
+          @calibration = {
+            ac1: bytes[0..1].pack('C*').unpack('s>')[0],
+            ac2: bytes[2..3].pack('C*').unpack('s>')[0],
+            ac3: bytes[4..5].pack('C*').unpack('s>')[0],
+            ac4: bytes[6..7].pack('C*').unpack('S>')[0],
+            ac5: bytes[8..9].pack('C*').unpack('S>')[0],
+            ac6: bytes[10..11].pack('C*').unpack('S>')[0],
+            b1: bytes[12..13].pack('C*').unpack('s>')[0],
+            b2: bytes[14..15].pack('C*').unpack('s>')[0],
+            mb: bytes[16..17].pack('C*').unpack('s>')[0],
+            mc: bytes[18..19].pack('C*').unpack('s>')[0],
+            md: bytes[20..21].pack('C*').unpack('s>')[0],
+          }
+          @calibration_data_loaded = true
+        end
+      end
+    end
+  end
+end

data/lib/denko/sensor/generic_pir.rb

@@ -0,0 +1,8 @@
+module Denko
+  module Sensor
+    class GenericPIR < DigitalIO::Input
+      alias :on_motion_stop  :on_low
+      alias :on_motion_start :on_high
+    end
+  end
+end

data/lib/denko/sensor/hcsr04.rb

@@ -0,0 +1,33 @@
+module Denko
+  module Sensor
+    class HCSR04
+      # Speed of sound in meters per second.
+      SPEED_OF_SOUND = 343.0
+
+      include Behaviors::MultiPin
+      include Behaviors::Poller
+
+      def initialize_pins(options={})
+        proxy_pin :trigger, DigitalIO::Output
+        proxy_pin :echo,    DigitalIO::Input
+      end
+
+      def after_initialize(options={})
+        super(options)
+
+        # Receive values from echo pin.
+        echo.add_callback { |data| self.update(data) }
+      end
+
+      def _read
+        board.hcsr04_read(echo.pin, trigger.pin)
+      end
+
+      def pre_callback_filter(us)
+        # Data is microseconds roundtrip time. Convert to mm.
+        um = (us/2) * SPEED_OF_SOUND
+        mm = um / 1000.0
+      end
+    end
+  end
+end

data/lib/denko/sensor/htu21d.rb

@@ -128,8 +128,12 @@ module Denko
 
         # Bit 1 of LSB determines type of reading; 0 for temperature, 1 for humidity.
         if (bytes[1] & 0b00000010) > 0
+          # Calculate humidity and limit within 0-100 range.
+          humidity = (raw_value.to_f / 524.288) - 6
+          humidity = 0.0   if humidity < 0.0
+          humidity = 100.0 if humidity > 100.0
           @reading[0] = :humidity
-          @reading[1] = (raw_value.to_f / 524.288) - 6
+          @reading[1] = humidity
           @humidity.update(@reading[1])
         else
           @reading[0] = :temperature
@@ -138,7 +142,7 @@ module Denko
         end
         @reading
       end
-      
+
       def update_state(reading)
         @state_mutex.synchronize do
           @state[reading[0]] = reading[1]