apiotics_factory 1.0.0

data/lib/templates/grove_pi/i2c/device/bmp180.rb

@@ -0,0 +1,207 @@
+require 'i2c'
+
+# Implements the I2C-Device BMP085/BMP180
+# This code was inspired by https://github.com/adafruit/Adafruit_Python_BMP
+#
+# Datasheet: https://www.adafruit.com/datasheets/BST-BMP180-DS000-09.pdf
+#
+# Currently this code was tested on a Banana Pi with a BMP185 device. It should work on a Raspberry or any other Linux with I2C-Dev
+#
+# ==Example
+#   Using i2c-2 device (e.g. if you using a banana pi)
+#
+#   bmp = I2CDevice::Bmp180.new(driver: I2CDevice::Driver::I2CDev.new("/dev/i2c-2"), mode: 0)
+#   puts "#{bmp.read_temperature / 10.0}°C"
+#   sleep 1
+#   puts "#{bmp.read_pressure / 100.0}hPa abs"
+#   sleep 1
+#   m_above_sealevel = 500 # position realtive to sealevel in m
+#   puts "#{bmp.read_sealevel_pressure(m_above_sealevel) / 100.0}hPa rel"
+#
+class I2CDevice::Bmp180 < I2CDevice
+    # BMP085 default address.
+    BMP085_I2CADDR           = 0x77
+
+    # Operating Modes
+    BMP085_ULTRALOWPOWER     = 0
+    BMP085_STANDARD          = 1
+    BMP085_HIGHRES           = 2
+    BMP085_ULTRAHIGHRES      = 3
+
+    # BMP085 Registers
+    BMP085_CAL_AC1           = 0xAA  # R   Calibration data (16 bits)
+    BMP085_CAL_AC2           = 0xAC  # R   Calibration data (16 bits)
+    BMP085_CAL_AC3           = 0xAE  # R   Calibration data (16 bits)
+    BMP085_CAL_AC4           = 0xB0  # R   Calibration data (16 bits) unsigned
+    BMP085_CAL_AC5           = 0xB2  # R   Calibration data (16 bits) unsigned
+    BMP085_CAL_AC6           = 0xB4  # R   Calibration data (16 bits) unsigned
+    BMP085_CAL_B1            = 0xB6  # R   Calibration data (16 bits)
+    BMP085_CAL_B2            = 0xB8  # R   Calibration data (16 bits)
+    BMP085_CAL_MB            = 0xBA  # R   Calibration data (16 bits)
+    BMP085_CAL_MC            = 0xBC  # R   Calibration data (16 bits)
+    BMP085_CAL_MD            = 0xBE  # R   Calibration data (16 bits)
+    BMP085_CONTROL           = 0xF4
+    BMP085_TEMPDATA          = 0xF6
+    BMP085_PRESSUREDATA      = 0xF6
+
+    # Commands
+    BMP085_READTEMPCMD       = 0x2E
+    BMP085_READPRESSURECMD   = 0x34
+
+    # initialize the device and read the calibration registers
+    #
+    # ==params
+    #  * args : hash defaults to {}
+    #  ** :mode : one of BMP085_ULTRALOWPOWER | BMP085_STANDARD | BMP085_HIGHRES | BMP085_ULTRAHIGHRES defaults to BMP085_STANDARD see datasheet for more information
+    #  ** :address : device address defaults to 0x77
+    def initialize(args={})
+        @mode = args.delete(:mode) || BMP085_STANDARD
+        args = {
+        address: BMP085_I2CADDR
+        }.merge(args)
+
+        super args
+
+        raise "Mode must be between #{BMP085_ULTRALOWPOWER} and #{BMP085_ULTRAHIGHRES}" unless [BMP085_ULTRALOWPOWER, BMP085_STANDARD, BMP085_HIGHRES, BMP085_ULTRAHIGHRES].include?(@mode)
+
+        calibration
+    end
+
+    # read the current real temperature in 0.1°C
+    def read_temperature
+        return calc_real_temperature(read_raw_temperature)
+    end
+
+    # read the current relative pressure in Pa
+    def read_pressure
+        return calc_real_pressure(read_raw_temperature, read_raw_pressure)
+    end
+
+    # Read current temperature and realtive pressure
+    #
+    # ==return
+    #  * temperature in 0.1°C, pressure in Pa
+    def read_temperature_and_pressure
+        ut = read_raw_temperature
+        up = read_raw_pressure
+
+        return calc_real_temperature(ut), calc_real_pressure(ut, up)
+    end
+
+    # calculate the current pressure at sealevel from the current relative pressure and the gitven altitude
+    #
+    # ==params
+    #  * altitude : curren altitude above sealevel in m defaults to 0
+    def read_sealevel_pressure(altitude = 0.0)
+        pressure = read_pressure()
+        return cacl_sealevel_pressure(pressure, altitude)
+    end
+
+    # calculate the current pressure at sealevel from the given relative pressure and the gitven altitude
+    #
+    # ==params
+    #  * altitude : curren altitude above sealevel in m
+    #  * pressure : current relative pressure in Pa
+    def cacl_sealevel_pressure(pressure, altitude)
+        return pressure.to_f / ((1.0 - altitude.to_f / 44330.0) ** 5.255)
+    end
+    
+    # get the calibration values
+    #
+    # ==return
+    #  array of calibration data
+    def get_cal
+        return @cal_AC1, @cal_AC2, @cal_AC3, @cal_AC4, @cal_AC5, @cal_AC6, @cal_B1, @cal_B2, @cal_MB, @cal_MC, @cal_MD
+    end
+
+  private
+    # read the current raw temperature value
+    def read_raw_temperature
+        i2cset(BMP085_CONTROL, BMP085_READTEMPCMD)
+        sleep 0.005
+        return i2cget(BMP085_TEMPDATA, 2).unpack('s>')[0]
+    end
+
+    # read the current raw pressure value
+    def read_raw_pressure
+        i2cset(BMP085_CONTROL, BMP085_READPRESSURECMD + (@mode << 6))
+
+        if @mode == BMP085_ULTRALOWPOWER
+        sleep 0.005
+        elsif @mode == BMP085_HIGHRES
+        sleep 0.014
+        elsif @mode == BMP085_ULTRAHIGHRES
+        sleep 0.026
+        else
+        sleep 0.008
+        end
+
+        sleep 1 # safety for testing
+
+        msb, lsb, xlsb  = i2cget(BMP085_PRESSUREDATA, 3).unpack('C*')
+        up  = ((msb << 16) + (lsb << 8) + xlsb) >> (8 - @mode)
+
+        return up
+    end
+
+    # load the calibration registers into instance variables
+    def calibration
+        @cal_AC1, @cal_AC2, @cal_AC3, @cal_AC4, @cal_AC5, @cal_AC6, @cal_B1, @cal_B2,
+            @cal_MB, @cal_MC, @cal_MD = i2cget(BMP085_CAL_AC1, 22).unpack('s>s>s>S>S>S>s>s>s>s>s>')
+    end
+
+    # calculate the read temperature using the calibration registers
+    #
+    # ==params
+    #  * ut : raw templerature value
+    # ==return
+    #  true temperature in 0.1°C -> 150 = 15.0 °C
+    def calc_real_temperature(ut)
+        x1 = ((ut - @cal_AC6) * @cal_AC5)  / 2**15
+        x2 = (@cal_MC * 2**11) / (x1 + @cal_MD)
+        b5 = x1 + x2
+        t = (b5 + 8) / 2**4
+
+        return t
+    end
+
+    # calculate the read pressure using the calibration registers
+    #
+    # ==params
+    #  * up : raw pressure value
+    # ==return
+    #  true pressure in Pa
+    def calc_real_pressure(ut, up)
+        x1 = ((ut - @cal_AC6) * @cal_AC5) / 2**15
+        x2 = (@cal_MC * 2**11) / (x1 + @cal_MD)
+        b5 = x1 + x2
+
+        # Pressure Calculations
+        b6 = b5 - 4000
+        x1 = (@cal_B2 * (b6 * b6) / 2**12) / 2**11
+        x2 = (@cal_AC2 * b6) / 2**11
+        x3 = x1 + x2
+        b3 = (((@cal_AC1 * 4 + x3) << @mode) + 2) / 4
+
+        x1 = (@cal_AC3 * b6) / 2**13
+        x2 = (@cal_B1 * ((b6 * b6) / 2**12)) / 2**16
+        x3 = ((x1 + x2) + 2) / 2**2
+        b4 = (@cal_AC4 * (x3 + 32768)) / 2**15
+
+        b7 = (up - b3) * (50000 >> @mode)
+
+        if b7 < 0x80000000
+            pr = (b7 * 2) / b4
+        else
+            pr = (b7 / b4) * 2
+        end
+
+        x1 = (pr / 2**8) * (pr / 2**8)
+        x1 = (x1 * 3038) / 2**16
+        x2 = (-7357 * pr) / 2**16
+        pr += ((x1 + x2 + 3791) / 2**4)
+
+        return pr
+    end
+
+end

data/lib/templates/grove_pi/i2c/device/d6t-44l.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+
+class I2CDevice::D6T44L < I2CDevice
+	class InvalidParityException < Exception; end
+
+	def initialize(args={})
+		args[:address] = 0x0a
+		super
+	end
+
+	def read_data
+		data = i2cget(0x4c, 35)
+		unless checkPEC(data, false)
+			raise InvalidParityException
+		end
+
+		# PTAT はセンサ内部の参照温度データ
+		ptat, *pixels = data[0..-2].unpack("v*")
+		{
+			:PTAT => ptat,
+			:PIXELS => pixels.each_slice(4).to_a
+		}
+	end
+
+	private
+	def calc_crc(data)
+		8.times do
+			tmp = data
+			data = (data << 1) & 0xff
+			if tmp & 0x80 != 0
+				data ^= 0x07
+			end
+		end
+		data
+	end
+
+	def checkPEC(data, userr=true)
+		crc = 0
+		if userr
+			crc = calc_crc(0x14)
+			crc = calc_crc(0x4c ^ crc)
+			crc = calc_crc(0x15 ^ crc)
+		else
+			crc = calc_crc(0x15)
+		end
+		(data.size - 1).times do |i|
+			crc = calc_crc(data[i].ord ^ crc)
+		end
+		data[data.size-1].ord == crc
+	end
+end

data/lib/templates/grove_pi/i2c/device/hd44780.rb

@@ -0,0 +1,172 @@
+# coding: utf-8
+
+require "i2c"
+
+# I2C interface with HD44780 compatible commands
+class I2CDevice::HD44780 < I2CDevice
+	MAP = Hash[
+		[
+			"｡｢｣､・ｦｧｨｩｪｫｬｭｮｯｰｱｲｳｴｵｶｷｸｹｺｻｼｽｾｿﾀﾁﾂﾃﾄﾅﾆﾇﾈﾉﾊﾋﾌﾍﾎﾏﾐﾑﾒﾓﾔﾕﾖﾗﾘﾙﾚﾛﾜﾝﾞﾟ".split(//).map {|c|
+				c.force_encoding(Encoding::BINARY)
+			},
+			(0b10100001..0b11011111).map {|c|
+				c.chr
+			}
+		].transpose
+	]
+
+	def initialize(args={})
+		super
+		@lines = []
+		initialize_lcd
+	end
+
+	# Initialize LCD controller sequence
+	# Display is cleared.
+	def initialize_lcd
+		function_set(1, 1, 0)
+		sleep 4.1e-3
+		function_set(1, 1, 0)
+		sleep 100e-6
+		function_set(1, 1, 0)
+		function_set(1, 1, 0)
+		display_on_off_control(1, 0, 0)
+		clear
+	end
+
+	# <tt>line</tt>  :: [Integer]      Line number
+	# <tt>str</tt>   :: [String]       Display string
+	# <tt>force</tt> :: [true | false] Write data forcely.
+	#
+	# Note: This method keep previous put_line strings and does not write without change.
+	# You must specify _force_ to override this behaviour.
+	def put_line(line, str, force=false)
+		str.force_encoding(Encoding::BINARY)
+		str.gsub!(/#{MAP.keys.join('|')}/, MAP)
+
+		str = "%- 16s" % str
+
+		if force || str != @lines[line]
+			# set ddram address
+			set_ddram_address(0x40 * line)
+			sleep 60e-6
+			i2cset(*str.unpack("C*").map {|i| [0x80, i] }.flatten)
+			sleep 60e-6
+		end
+		@lines[line] = str
+	end
+
+	# <tt>n</tt>     :: [Integer] Character code.
+	# <tt>array</tt> :: [Array[Integer]] Character data.
+	# Usage:
+	#     lcd.define_character(0, [
+	#         0,1,1,1,0,
+	#         1,0,0,0,1,
+	#         1,1,0,1,1,
+	#         1,0,1,0,1,
+	#         1,1,0,1,1,
+	#         1,0,0,0,1,
+	#         1,0,0,0,1,
+	#         0,1,1,1,0,
+	#     ])
+	def define_character(n, array)
+		raise "n < 8" unless n < 8
+		raise "array size must be 40 (5x8)" unless array.size == 40
+
+		array = array.each_slice(5).map {|i|
+			i.inject {|r,i| (r << 1) + i }
+		}
+		set_cgram_address(8 * n)
+		sleep 60e-6
+		i2cset(*array.map {|i| [0x80, i] }.flatten)
+		sleep 60e-6
+	end
+
+	def clear_display
+		@lines.clear
+		i2cset(0, 0b00000001)
+		sleep 2.16e-3
+	end
+
+	alias clear clear_display
+
+	def return_home
+		i2cset(0, 0b00000010)
+		sleep 1.52e-3
+	end
+
+	# <tt>i_d</tt> :: [Integer] Increment or decrement
+	#                           0 :: Decrement
+	#                           1 :: Increment
+	# <tt>s</tt>   :: [Integer] Shift entire display
+	#                           0 :: Right
+	#                           1 :: Left
+	def entry_mode_set(i_d, s)
+		i2cset(0, 0b00000100 | (i_d<<1) | (s))
+		sleep 60e-6
+	end
+
+	# <tt>d</tt> :: [Integer] Set entire display on/off
+	#                         0 :: Off
+	#                         1 :: On
+	# <tt>c</tt> :: [Integer] Cursor on/off
+	#                         0 :: Off
+	#                         1 :: On
+	# <tt>b</tt> :: [Integer] Blink cursor
+	#                         0 :: Off
+	#                         1 :: On
+	def display_on_off_control(d, c, b)
+		i2cset(0, 0b00001000 | (d<<2) | (c<<1) | (b))
+		sleep 60e-6
+	end
+
+	# <tt>s_c</tt> :: [Integer] Cursor or display
+	#                           0 :: Cursor shift
+	#                           1 :: Display shift
+	# <tt>r_l</tt> :: [Integer] Direction
+	#                           0 :: Left
+	#                           1 :: Right
+	def cursor_or_display_shift(s_c, r_l)
+		i2cset(0, 0b00010000 | (s_c<<3) | (r_l<<2))
+		sleep 60e-6
+	end
+
+	# <tt>dl</tt> :: [Integer] Data length
+	#                          0 :: 4bit 
+	#                          1 :: 8bit 
+	# <tt>n</tt>  :: [Integer] Number of display lines
+	#                          0 :: 1-line
+	#                          1 :: 2-line
+	# <tt>f</tt>  :: [Integer] Character font
+	#                          0 :: Normal
+	#                          1 :: Double font
+	def function_set(dl, n, f)
+		i2cset(0, 0b00100000 | (dl<<4) | (n<<3) | (f<<2))
+		sleep 60e-6
+	end
+
+	# <tt>address</tt> :: [Integer] CGRAM address 6-bit
+	def set_cgram_address(address)
+		address = address & 0b00111111
+		i2cset(0, 0b01000000 | address)
+		sleep 60e-6
+	end
+
+	# <tt>address</tt> :: [Integer] DDRAM address 7-bit
+	def set_ddram_address(address)
+		address = address & 0b01111111
+		i2cset(0, 0b10000000 | address)
+		sleep 60e-6
+	end
+
+	# <tt>Returns</tt> :: [Hash] Result
+	#                            :busy            :: [true | false] Busy flag
+	#                            :address_counter :: [Integer] Current address count. 7-bit
+	def read_busy_flag_and_address
+		read = i2cget(0b01000000)
+		{
+			:busy => (read & 0b10000000) != 0,
+			:address_counter => read & 0b01111111
+		}
+	end
+end

data/lib/templates/grove_pi/i2c/device/hdc1000.rb

@@ -0,0 +1,42 @@
+# coding: utf-8
+
+require "i2c"
+
+# http://www.ti.com/product/HDC1000
+# A Digital humidity/temperature sensor
+
+class I2CDevice::HDC1000 < I2CDevice
+	def initialize(args = {})
+		args = {
+			address: 0x40
+		}.merge(args)
+		super args
+		configuration
+	end
+
+	def configuration
+		i2cset(
+			0x02, # Configuration register
+			0x10, # TRES 14bit
+			0x00  # HRES 14bit
+		)
+	end
+
+	def get_data
+		i2cset(0x00)
+		sleep 6.35e-3 + 6.5e-3
+		raw = i2cget(nil, 4).unpack("C4")
+		{
+			temperature: calc_temperature(raw[0], raw[1]),
+			humidity: calc_humidity(raw[2], raw[3])
+		}
+	end
+
+	def calc_temperature(d1, d2)
+	  ((d1<<8 | d2).to_f / 2**16 * 165) - 40
+	end
+
+	def calc_humidity(d1, d2)
+	  (d1<<8 | d2).to_f / 2**16 * 100
+	end
+end

data/lib/templates/grove_pi/i2c/device/mpl115a2.rb

@@ -0,0 +1,38 @@
+require "i2c"
+
+class I2CDevice::MPL115A2 < I2CDevice
+	def initialize(args={})
+		args[:address] = 0x60
+		super
+		coefficient = i2cget(0x04, 8).unpack("n*")
+
+		@a0  = fixed_point(coefficient[0], 12)
+		@b1  = fixed_point(coefficient[1], 2)
+		@b2  = fixed_point(coefficient[2], 1)
+		@c12 = fixed_point(coefficient[3], 0) / (1<<9)
+	end
+
+	def fixed_point(fixed, int_bits)
+		msb = 15
+		deno = (1<<(msb-int_bits)).to_f
+		if (fixed & (1<<15)).zero?
+			fixed / deno
+		else
+			-( ( (~fixed & 0xffff) + 1) / deno )
+		end
+	end
+
+	def calculate_hPa
+		i2cset(0x12, 0x01) # CONVERT
+
+		sleep 0.003
+
+		data = i2cget(0x00, 4).unpack("n*")
+
+		p_adc = (data[0]) >> 6
+		t_adc = (data[1]) >> 6
+
+		p_comp = @a0 + (@b1 + @c12 * t_adc) * p_adc + @b2 * t_adc
+		hPa = p_comp * ( (1150 - 500) / 1023.0) + 500;
+	end
+end