i2c-devices 0.0.1

data/lib/i2c/device/hd44780.rb

@@ -0,0 +1,137 @@
+# coding: utf-8
+
+require "i2c"
+
+# I2C interface with HD44780 compatible commands
+class 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
+
+	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
+
+	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
+
+	# 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
+		@lines.clear
+		clear_display
+	end
+
+	def clear_display
+		i2cset(0, 0b00000001)
+		sleep 2.16e-3
+	end
+
+	def return_home
+		i2cset(0, 0b00000010)
+		sleep 1.52e-3
+	end
+
+	# i_d : increment or decrement: 1: increment, 0: decrement
+	# s   : shift entire display: 1: left, 0: right
+	def entry_mode_set(i_d, s)
+		i2cset(0, 0b00000100 | (i_d<<1) | (s))
+		sleep 60e-6
+	end
+
+	# d: set entire display on/off
+	# c: cursor on/off
+	# b: blink cursor
+	def display_on_off_control(d, c, b)
+		i2cset(0, 0b00001000 | (d<<2) | (c<<1) | (b))
+		sleep 60e-6
+	end
+
+	def cursor_or_display_shift(s_c, r_l)
+		i2cset(0, 0b00010000 | (s_c<<3) | (r_l<<2))
+		sleep 60e-6
+	end
+
+	# dl  data_length: 1: 8bit, 0: 4bit
+	# n   number_of_display_lines: 1: 2-line, 0: 1-line
+	# f   character_font: 1: double font, 0: normal
+	def function_set(dl, n, f)
+		i2cset(0, 0b00100000 | (dl<<4) | (n<<3) | (f<<2))
+		sleep 60e-6
+	end
+
+	def set_cgram_address(address)
+		address = address & 0b00111111
+		i2cset(0, 0b01000000 | address)
+		sleep 60e-6
+	end
+
+	def set_ddram_address(address)
+		address = address & 0b01111111
+		i2cset(0, 0b10000000 | address)
+		sleep 60e-6
+	end
+
+	def read_busy_flag_and_address
+		read = i2cget(0b01000000)
+		{
+			:busy => (read & 0b10000000) != 0,
+			:address_counter => read & 0b01111111
+		}
+	end
+end

data/lib/i2c/device/mpl115a2.rb

@@ -0,0 +1,39 @@
+
+require "i2c"
+
+class 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

data/lib/i2c/driver/gpio.rb

@@ -0,0 +1,198 @@
+require "i2c"
+=begin
+Generic software I2C Driver based on /sys/class/gpio.
+THIS MODULE WORKS WITH VERY SLOW SPEED ABOUT JUST 1kHz (normaly 100kHz).
+=end
+
+module I2CDevice::Driver
+	class GPIO
+		@@DEBUG = false
+
+		def self.export(pin)
+			File.open("/sys/class/gpio/export", "w") do |f|
+				f.syswrite(pin)
+			end
+		end
+
+		def self.unexport(pin)
+			File.open("/sys/class/gpio/unexport", "w") do |f|
+				f.syswrite(pin)
+			end
+		end
+
+		def self.direction(pin, direction)
+			# [:in, :out, :high, :low].include?(direction) or raise "direction must be :in, :out, :high or :low"
+			File.open("/sys/class/gpio/gpio#{pin}/direction", "w") do |f|
+				f.syswrite(direction)
+			end
+		end
+
+		def self.read(pin)
+			File.open("/sys/class/gpio/gpio#{pin}/value", "r") do |f|
+				f.sysread(1).to_i
+			end
+		end
+
+		def self.write(pin, val)
+			File.open("/sys/class/gpio/gpio#{pin}/value", "w") do |f|
+				f.syswrite(val && val.nonzero?? "1" : "0")
+			end
+		end
+
+		def self.finalizer(ports)
+			proc do
+				ports.each do |pin|
+					GPIO.unexport(pin)
+				end
+			end
+		end
+
+		attr_reader :sda, :scl, :speed
+
+		def initialize(opts={})
+			@sda = opts[:sda] or raise "opts[:sda] = [gpio pin number] is required"
+			@scl = opts[:scl] or raise "opts[:scl] = [gpio pin number] is required"
+			@speed = opts[:speed] || 1 # kHz but insane
+			@clock = 1.0 / (@speed * 1000)
+
+			begin
+				GPIO.export(@sda)
+				GPIO.export(@scl)
+			rescue Errno::EBUSY => e
+			end
+			ObjectSpace.define_finalizer(self, self.class.finalizer([@scl, @sda]))
+			begin
+				GPIO.direction(@sda, :high)
+				GPIO.direction(@scl, :high)
+				GPIO.direction(@sda, :in)
+				GPIO.direction(@scl, :in)
+			rescue Errno::EACCES => e # writing to gpio after export is failed in a while
+				retry
+			end
+		end
+
+		def i2cget(address, param, length=1)
+			ret = ""
+			start_condition
+			unless write( (address << 1) + 0)
+				raise I2CDevice::I2CIOError, "Unknown slave device (address:#{address})"
+			end
+			write(param)
+			stop_condition # AVR stucked with SCL low without this (Does not AVR support Sr condition?)
+			start_condition
+			unless write( (address << 1) + 1)
+				raise I2CDevice::I2CIOError, "Unknown slave device (address:#{address})"
+			end
+			length.times do |n|
+				ret << read(n != length - 1).chr
+			end
+			ret
+		ensure
+			stop_condition
+		end
+
+		def i2cset(address, *data)
+			sent = 0
+			start_condition
+			unless write( (address << 1) + 0)
+				raise I2CDevice::I2CIOError, "Unknown slave device (address:#{address})"
+			end
+			data.each do |c|
+				unless write(c)
+					break
+				end
+				sent += 1
+			end
+			sent
+		ensure
+			stop_condition
+		end
+
+		private
+
+		def start_condition
+			p :start_condition if @@DEBUG
+			sleep @clock
+			GPIO.direction(@sda, :in)
+			GPIO.direction(@scl, :in)
+			if GPIO.read(@scl) == 0
+				raise I2CDevice::I2CBUSBusy, "BUS is busy"
+			end
+
+			sleep @clock / 2
+			GPIO.direction(@scl, :high)
+			sleep @clock / 2
+			GPIO.direction(@sda, :low)
+			sleep @clock
+		end
+
+		def stop_condition
+			p :stop_condition if @@DEBUG
+			GPIO.direction(@scl, :low)
+			sleep @clock / 2
+			GPIO.direction(@sda, :low)
+			sleep @clock / 2
+			GPIO.direction(@scl, :in)
+			sleep @clock / 2
+			GPIO.direction(@sda, :in)
+			sleep @clock / 2
+		end
+
+		def write(byte)
+			p [:write, byte] if @@DEBUG
+			GPIO.direction(@scl, :low)
+			sleep @clock
+
+			7.downto(0) do |n|
+				GPIO.direction(@sda, byte[n] == 1 ? :high : :low)
+				GPIO.direction(@scl, :in)
+				until GPIO.read(@scl) == 1
+					# clock streching
+					sleep @clock
+				end
+				sleep @clock
+				GPIO.direction(@scl, :low)
+				GPIO.write(@sda, false)
+				sleep @clock
+			end
+
+			GPIO.direction(@sda, :in)
+			GPIO.direction(@scl, :in)
+			sleep @clock / 2
+			ack = GPIO.read(@sda) == 0
+			sleep @clock / 2
+			while GPIO.read(@scl) == 0
+				sleep @clock
+			end
+			GPIO.direction(@scl, :low)
+			ack
+		end
+
+		def read(ack=true)
+			p [:read, ack] if @@DEBUG
+			ret = 0
+
+			GPIO.direction(@scl, :low)
+			sleep @clock
+			GPIO.direction(@sda, :in)
+
+			8.times do
+				GPIO.direction(@scl, :in)
+				sleep @clock / 2
+				ret = (ret << 1) | GPIO.read(@sda)
+				sleep @clock / 2
+				GPIO.direction(@scl, :low)
+				sleep @clock
+			end
+
+			GPIO.direction(@sda, ack ? :low : :high)
+
+			GPIO.write(@scl, true)
+			sleep @clock
+			GPIO.write(@scl, false)
+			sleep @clock
+			ret
+		end
+	end
+end
+

data/lib/i2c/driver/i2c-dev.rb

@@ -0,0 +1,53 @@
+
+require "i2c"
+
+module I2CDevice::Driver
+	class I2CDev
+		# ioctl command
+		# Ref. https://www.kernel.org/pub/linux/kernel/people/marcelo/linux-2.4/include/linux/i2c.h
+		I2C_RETRIES     = 0x0701
+		I2C_TIMEOUT     = 0x0702
+		I2C_SLAVE       = 0x0703
+		I2C_SLAVE_FORCE = 0x0706
+		I2C_TENBIT      = 0x0704
+		I2C_FUNCS       = 0x0705
+		I2C_RDWR        = 0x0707
+		I2C_SMBUS       = 0x0720
+		I2C_UDELAY      = 0x0705
+		I2C_MDELAY      = 0x0706
+
+		def initialize(path=nil)
+			if path.nil?
+				path = Dir.glob("/dev/i2c-*").sort.last
+			end
+
+			unless File.exist?(path)
+				raise I2CDevice::I2CIOError, "/dev/i2c-0 is required"
+			end
+
+			@path = path
+		end
+
+		def i2cget(address, param, length)
+			i2c = File.open(@path, "r+")
+			i2c.ioctl(I2C_SLAVE, address)
+			i2c.syswrite(param.chr)
+			ret = i2c.sysread(length)
+			i2c.close
+			ret
+		rescue Errno::EIO => e
+			raise I2CDevice::I2CIOError, e.message
+		end
+
+		def i2cset(address, *data)
+			i2c = File.open(@path, "r+")
+			i2c.ioctl(I2C_SLAVE, address)
+			i2c.syswrite(data.pack("C*"))
+			i2c.close
+		rescue Errno::EIO => e
+			raise I2CDevice::I2CIOError, e.message
+		end
+	end
+end
+
+

data/lib/i2c/mocki2cdevice.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+
+class MockI2CDevice
+	attr_reader :memory
+	attr_reader :ioctl
+	attr_reader :state
+
+	def initialize
+		@temp = Tempfile.new("i2c")
+		@ioctl = []
+		@memory = [ 0 ]
+		@address = nil
+		@state = nil
+	end
+
+	def path
+		@temp.path
+	end
+
+	def ioctl(cmd, arg)
+		@ioctl = [cmd, arg]
+		self
+	end
+
+	def open
+		@address = nil
+		@state = :init
+		self
+	end
+
+	def close
+		@address = nil
+		@state = nil
+		self
+	end
+
+	def syswrite(buf)
+		buf.unpack("C*").each do |c|
+			case @state
+			when :init
+				# p "@address = 0x%02x" % c
+				@address = c
+				@state = :wait
+			when :wait
+				# p "@memory[0x%02x] = 0b%08b" % [@address, c]
+				@memory[@address] = c
+				@address += 1
+			end
+		end
+	end
+
+	def sysread(size)
+		ret = []
+		case @state
+		when :init
+			raise "Invalid State"
+		when :wait
+			size.times do
+				ret << @memory[@address]
+				@address += 1
+			end
+		end
+		ret.pack("C*")
+	end
+end
+
+