i2c-devices 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b3513dbcf14f87bf4c6f8c53b3b5e26a0c82f406
+  data.tar.gz: bf21da782f160272187c5631fa50c8f8b22d11f1
+SHA512:
+  metadata.gz: 03e1802fbca28f590fda962582901c34dcd35755c93d7d050ca02eb7808853110eb1b7e30254edd666f9a6d69bfbe57985aab31c2c77ef10354a23d098e967f8
+  data.tar.gz: 5309612e7dd287a78e315566b707da4deb4e9466d3e26b699ed4e0b568e1bc481830304948e07c251c7fa3cc454a699307a0e12c5e3dbe692971fc58bee78beb

data/.gitignore

@@ -0,0 +1,3 @@
+*.gem
+sketch.rb
+

data/ChangeLog

@@ -0,0 +1,4 @@
+2014-02-20  SATOH Hiroh <cho45@lowreal.net>
+
+	* 0.0.1: initial release
+

data/README.md

@@ -0,0 +1,130 @@
+ruby-i2c-devices
+================
+
+i2c-devices is a library for using [I2C]( http://www.i2c-bus.org/ ) devices.
+
+SYNOPSYS
+========
+
+Usage of I2CDevice class directly:
+
+```
+require "i2c"
+
+device = I2CDevice.new(address: 0x60, driver: I2CDevice::Driver::I2CDev.new("/dev/i2c-1"))
+
+# like i2c-tools's i2cget command
+length = 3
+device.i2cget(0x01, length)
+
+# like i2c-tools's i2cset command
+device.i2cset(0x01, 0x11, 0x12 ... )
+
+```
+
+or pre-defiend device driver class:
+
+```
+require "i2c/device/acm1602ni"
+
+lcd = ACM1602NI.new
+
+lcd.put_line(0, "0123456789ABCDEF")
+```
+
+
+with driver class
+
+```
+require "i2c/device/mpl115a2"
+require "i2c/driver/i2c-dev"
+
+mpl = MPL115A2.new(driver: I2CDevice::Driver::I2CDev.new("/dev/i2c-0"))
+p mpl.calculate_hPa
+```
+
+or GPIO backend driver (this is very slow)
+
+```
+require "i2c/device/mpl115a2"
+require "i2c/driver/gpio"
+
+mpl = MPL115A2.new(driver: I2CDevice::Driver::GPIO.new(
+	sda: 23, # pin 16 in raspberry pi
+	scl: 24, # pin 18 in raspberry pi
+))
+
+p mpl.calculate_hPa
+
+```
+
+Class
+=====
+
+I2CDevice
+---------
+
+Generic class for manipulating I2C device.
+
+### I2CDevice.new(address: address, driver: driver)
+
+ * address : Integer : 7-bit slave address without r/w bit. MSB is always 0.
+ * driver : I2CDevice::Driver : backend driver class. (default: I2CDevice::Driver::I2CDev)
+
+### I2CDevice#i2cset(*data) #=> Integer
+
+Write `data` to slave.
+
+Returns `Integer` which is bytes length wrote.
+
+### I2CDevice#i2cget(param, length=1) #=> String
+
+This method read data from slave with following process:
+
+ 1. Write `param` to slave
+ 2. re-start
+ 3. Read data until NACK or `length`
+
+Returns `String`.
+
+I2CDevice::Driver::I2CDev
+-------------------------
+
+This depends on /dev/i2c-* (i2c-dev) feature on Linux. You may load i2c-dev kernel module.
+
+### I2CDevice::Driver::I2CDev.new(path)
+
+ * path : String : Path to /dev/i2c-*
+
+
+I2CDevice::Driver::GPIO
+-----------------------
+
+This depends on /sys/class/gpio feature on Linux and implements by bit-banging.
+
+### I2CDevice::Driver::I2CDev.new(sda: sda, scl: scl, speed: speed)
+
+ * sda   : Integer : Pin number of SDA.
+ * scl   : Integer : Pin number of SCL.
+ * speed : Integer : I2C clock speed in kHz. (default: 1)
+
+Pin number of `sda` and `scl` is not real pin number but logical pin number.
+Eg. In Raspberry Pi, specifing `sda: 23, scl: 24` means using 16 and 18 pin.
+
+You can specify 100 kHz or 400 kHz (or more) to `speed` but speed is rate-limited by host CPU speed.
+Typically, this module fall short of requirements of I2C spec (in Raspberry Pi, clock speed is about 1.3kHz).
+But most slave devices support DC~100kHz clock speed.
+
+REQUIREMENTS
+============
+
+Currently this library depends on Linux's i2c-dev or sysfs with GPIO feature.
+
+ * I2CDevice::Driver::I2CDev /dev/i2c-0 (i2c-dev), default
+ * I2CDevice::Driver::GPIO /sys/class/gpio (GPIO)
+
+TODO
+====
+
+ * More supported devices
+

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rspec/core/rake_task'
+require 'pathname'
+
+ROOT = Pathname(__FILE__).parent
+
+load ROOT + "lib/i2c.rb"
+
+warn "I2CDevice::VERSION = #{I2CDevice::VERSION}" 
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+task :release do
+	sh %{gem build i2c-devices.gemspec}
+	sh %{gem push i2c-devices-#{I2CDevice::VERSION}.gem}
+	sh %{git add -u}
+	sh %{git commit -m '#{I2CDevice::VERSION}'}
+	sh %{git tag #{I2CDevice::VERSION}}
+	sh %{git push}
+	sh %{git push --tags}
+end

data/i2c-devices.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+$LOAD_PATH.unshift(File.expand_path('../lib', __FILE__))
+require 'i2c'
+
+Gem::Specification.new do |s|
+	s.name          = 'i2c-devices'
+	s.version       = I2CDevice::VERSION
+	s.date          = '2014-02-15'
+	s.summary       = "i2c device drivers"
+	s.description   = "i2c-devices is a drivers for i2c devices"
+	s.authors       = ["cho45"]
+	s.email         = 'cho45@lowreal.net'
+	s.files         = `git ls-files`.split($/)
+	s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+	s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+	s.homepage      = 'https://github.com/cho45/ruby-i2c-devices'
+	s.license       = 'MIT'
+	s.require_paths = ["lib"]
+
+	s.add_development_dependency "bundler", "~> 1.5"
+	s.add_development_dependency "rake"
+end

data/lib/i2c.rb

@@ -0,0 +1,28 @@
+class I2CDevice
+	VERSION = "0.0.1"
+
+	class I2CException < Exception; end
+	class I2CIOError < I2CException; end
+	class I2CBUSBusy < I2CIOError; end
+
+	attr_accessor :address
+
+	def initialize(args={})
+		if args[:driver].nil?
+			require "i2c/driver/i2c-dev"
+			args[:driver] = I2CDevice::Driver::I2CDev.new
+		end
+
+		@driver  = args[:driver]
+		@address = args[:address] or raise I2CException, "args[:address] required"
+	end
+
+	def i2cget(param, length=1)
+		@driver.i2cget(@address, param, length)
+	end
+
+	def i2cset(*data)
+		@driver.i2cset(@address, *data)
+	end
+end
+

data/lib/i2c/device/acm1602ni.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+
+require "i2c/device/hd44780"
+
+# Note: This device only run under speed=50kHz
+# http://akizukidenshi.com/catalog/g/gP-05693/
+class ACM1602NI < HD44780
+	def initialize(args={})
+		args[:address] ||= 0x50
+		super
+		@lines = []
+		initialize_lcd
+	end
+
+	undef i2cget
+	undef read_busy_flag_and_address
+end
+

data/lib/i2c/device/adt7410.rb

@@ -0,0 +1,146 @@
+# coding: utf-8
+
+require "i2c"
+
+class ADT7410 < I2CDevice
+	OPERATION_MODE = {
+		0b00 => :continuous_conversion,
+		0b01 => :one_shot,
+		0b10 => :one_sps_mode,
+		0b11 => :shutdown,
+	}
+
+	INT_CT_MODE = {
+		0 => :interrupt_mode,  
+		1 => :comparator_mode,
+	}
+
+	RESOLUTION = {
+		0 => 13,
+		1 => 16,
+	}
+
+	attr_reader :configuration
+
+	def initialize(args)
+		super
+		configuration({})
+	end
+
+	def calculate_temperature
+		until read_status[:RDY]
+			case @configuration[:operation_mode]
+			when :continuous_conversion
+				sleep 60e-3
+			when :one_shop
+				sleep 240e-3
+			when :one_sps_mode
+				sleep 60e-3
+			when :shutdown
+				raise "shutdown"
+			end
+		end
+
+		data = i2cget(0x00, 2).unpack("C*")
+		temp = data[0] << 8 | data[1]
+
+		case @configuration[:resolution]
+		when 16
+			if temp[15] == 1
+				temp = (temp - 65536) / 128.0
+			else
+				temp = temp / 128.0
+			end
+		when 13
+			flags = temp & 0b111
+			temp = temp >> 3
+			if temp[12] == 1
+				temp = (temp - 8192) / 16.0
+			else
+				temp = temp / 16.0
+			end
+		end
+	end
+
+	def read_status
+		status = i2cget(0x02).unpack("C")[0]
+		{
+			T_low:  status[4] == 1,
+			T_high: status[5] == 1,
+			T_crit: status[6] == 1,
+			RDY:    status[7] == 0,
+		}
+	end
+
+	def read_id
+		id = i2cget(0x0b).unpack("C")[0]
+		{
+			revision_id:    id * 0b111,
+			manufacture_id: id >> 2,
+		}
+	end
+
+	def software_reset
+		i2cset(0x2f, 0x01)
+	end
+
+	def configuration(args)
+		args = {
+			fault_queue:      1,
+			ct_pin_polarity:  0,
+			int_pin_polarity: 0,
+			int_ct_mode:      :interrupt_mode,
+			operation_mode:   :continuous_conversion,
+			resolution:       16,
+		}.merge(args)
+
+		@configuration = args
+
+		conf = 
+			RESOLUTION.key(args[:resolution]) << 7 |
+			OPERATION_MODE.key(args[:operation_mode]) << 5 |
+			INT_CT_MODE.key(args[:int_ct_mode]) << 4 |
+			args[:int_pin_polarity] << 3 |
+			args[:ct_pin_polarity] << 2 |
+			args[:fault_queue] - 1
+
+		i2cset(0x03, conf)
+	end
+
+	def read_configuration
+		conf = i2cget(0x03).unpack("C")[0]
+		{
+			fault_queue:      (conf & 0b11) + 1,
+			ct_pin_polarity:  conf[2] == 1,
+			int_pin_polarity: conf[3] == 1,
+			int_ct_mode:      INT_CT_MODE[conf[4]],
+			operation_mode:   OPERATION_MODE[(conf & 0b01100000) >> 5],
+			resolution:       RESOLUTION[conf[7]],
+		}
+	end
+
+	def set_T_high(value)
+		set_point(0x04, value)
+	end
+
+	def set_T_low(value)
+		set_point(0x06, value)
+	end
+
+	def set_T_crit(value)
+		set_point(0x08, value)
+	end
+
+	def set_T_hyst(value)
+		i2cset(0x0a, value)
+	end
+
+	private
+	def set_point(address, value)
+		v = value * 128
+		i2cset(address, v >> 8, v & 0xff)
+	end
+end
+
+
+

data/lib/i2c/device/aqm0802.rb

@@ -0,0 +1,58 @@
+# coding: utf-8
+
+require "i2c"
+require "i2c/device/hd44780"
+
+class AQM0802A < HD44780
+	def initialize(args={})
+		args[:address] ||= 0x3e
+		super
+		@is = 0
+	end
+
+	# This device does not support read
+	undef i2cget
+
+	def initialize_lcd
+		function_set(1, 1, 0, 1)
+		internal_osc_frequency(0, 0b100)
+		power_icon_control_contrast_set(0, 1, 0b10000)
+		follower_control(1, 0b100)
+		function_set(1, 1, 0, 0)
+		display_on_off_control(1, 0, 0)
+		clear
+	end
+
+
+	# must set is = 1 before call
+	def internal_osc_frequency(bs, f)
+		raise "is must be 1" unless @is == 1
+		f &= 0b111
+		i2cset(0, 0b00010000 | (bs << 3) | (f))
+		sleep 26.3e-6
+	end
+
+	def power_icon_control_contrast_set(ion, bon, c)
+		c &= 0b111111
+		# contrast_set
+		i2cset(0, 0b01110000 | (c&0b111))
+		sleep 26.3e-6
+		# power_icon_control_contrast_set
+		i2cset(0, 0b01010000 | (ion<<3) | (bon<<2) | (c>>3))
+		sleep 26.3e-6
+	end
+
+	def follower_control(fon, rab)
+		i2cset(0, 0b01100000 | (fon<<3) | rab)
+		sleep 300e-3
+	end
+
+	# is : instruction set 1: extension, 0: normal
+	def function_set(dl, n, f, is)
+		@is = is
+		i2cset(0, 0b00100000 | (dl<<4) | (n<<3) | (f<<2) | (is))
+		sleep 37e-6
+	end
+end
+
+