i2c-devices 0.0.1

data/spec/device/adt7410_spec.rb

@@ -0,0 +1,87 @@
+#!rspec
+
+
+$LOAD_PATH.unshift "lib"
+
+require "tempfile"
+
+require "i2c/device/adt7410"
+require "i2c/driver/i2c-dev"
+require "i2c/mocki2cdevice"
+
+describe ADT7410 do
+	before do
+		@mock = MockI2CDevice.new
+		File.stub(:open) do
+			@mock.open
+		end
+		@driver = I2CDevice::Driver::I2CDev.new(@mock.path)
+	end
+
+	describe "#calculate_temperature" do
+		context "16bit" do
+			it "should treat positive fractial value" do
+				# status
+				@mock.memory[0x02] = 0b00000000
+				# temp
+				@mock.memory[0x00] = 0b00000000
+				@mock.memory[0x01] = 0b00000001
+
+				device = ADT7410.new(address: 0x50, driver: @driver)
+				expect(device.read_configuration).to eq({
+					:fault_queue      => 1,
+					:ct_pin_polarity  => false,
+					:int_pin_polarity => false,
+					:int_ct_mode      => :interrupt_mode,
+					:operation_mode   => :continuous_conversion,
+					:resolution       => 16
+				})
+				expect(device.calculate_temperature).to eq(0.0078125)
+			end
+
+			it "should treat negative value" do
+				# status
+				@mock.memory[0x02] = 0b00000000
+				# temp
+				@mock.memory[0x00] = 0b10000000
+				@mock.memory[0x01] = 0b00000000
+
+				device = ADT7410.new(address: 0x50, driver: @driver)
+				expect(device.calculate_temperature).to eq(-256)
+			end
+		end
+
+		context "13bit" do
+			it "should treat positive fractial value" do
+				# status
+				@mock.memory[0x02] = 0b00000000
+				# temp
+				@mock.memory[0x00] = 0b00000000
+				@mock.memory[0x01] = 0b00001000
+
+				device = ADT7410.new(address: 0x50, driver: @driver)
+				device.configuration({
+					resolution: 13,
+				})
+
+				expect(device.calculate_temperature).to eq(0.0625)
+			end
+
+			it "should treat negative value" do
+				# status
+				@mock.memory[0x02] = 0b00000000
+				# temp
+				@mock.memory[0x00] = 0b11100100
+				@mock.memory[0x01] = 0b10000000
+
+				device = ADT7410.new(address: 0x50, driver: @driver)
+				device.configuration({
+					resolution: 13,
+				})
+
+				expect(device.calculate_temperature).to eq(-55)
+			end
+		end
+	end
+end
+

data/spec/device/hd44780_spec.rb

@@ -0,0 +1,155 @@
+#!rspec
+
+
+$LOAD_PATH.unshift "lib"
+
+require "tempfile"
+
+require "i2c/device/hd44780"
+require "i2c/driver/i2c-dev"
+
+describe HD44780 do
+	before do
+		@i2cout = ""
+		@i2cin  = ""
+		@ioctl  = nil
+
+		ioctl = proc do |cmd, arg|
+			@ioctl = [ cmd, arg ]
+		end
+
+		syswrite = proc do |str|
+			@i2cout << str
+		end
+
+		sysread = proc do |n|
+			@i2cin
+		end
+
+		@temp = Tempfile.new("i2c")
+		file = nil
+		open = File.method(:open)
+		File.stub(:open) do
+			file = open.call(@temp.path, "r+")
+			file.define_singleton_method(:ioctl) {|cmd,arg| ioctl.call(ioctl) }
+			file.define_singleton_method(:syswrite) {|str| syswrite.call(str) }
+			file.define_singleton_method(:sysread) {|n| sysread.call(n) }
+			file
+		end
+		@driver = I2CDevice::Driver::I2CDev.new(@temp.path)
+	end
+
+	describe "#initialize_lcd" do
+		it "should initialize lcd" do
+			lcd = HD44780.new(address: 0x10, driver: @driver)
+
+			expect(@i2cout.unpack("C*")).to eq([
+				0b00000000,
+				0b00111000,
+				0b00000000,
+				0b00111000,
+				0b00000000,
+				0b00111000,
+				0b00000000,
+				0b00111000,
+				0b00000000,
+				0b00001100,
+				0b00000000,
+				0b00000001,
+			])
+		end
+	end
+
+	describe "#put_line" do
+		it "should be put_line 1/2" do
+			lcd = HD44780.new(address: 0x10, driver: @driver)
+
+			@i2cout.clear
+
+			lcd.put_line(0, "0123456789abcdef")
+
+			expect(@i2cout.unpack("C*")).to eq([
+				# set_ddram_address
+				0b00000000, 0b10000000,
+
+				# write commands
+				0b10000000, "0".ord,
+				0b10000000, "1".ord,
+				0b10000000, "2".ord,
+				0b10000000, "3".ord,
+				0b10000000, "4".ord,
+				0b10000000, "5".ord,
+				0b10000000, "6".ord,
+				0b10000000, "7".ord,
+				0b10000000, "8".ord,
+				0b10000000, "9".ord,
+				0b10000000, "a".ord,
+				0b10000000, "b".ord,
+				0b10000000, "c".ord,
+				0b10000000, "d".ord,
+				0b10000000, "e".ord,
+				0b10000000, "f".ord,
+			])
+
+			@i2cout.clear
+
+			lcd.put_line(1, "0123456789abcdef")
+
+			expect(@i2cout.unpack("C*")).to eq([
+				# set_ddram_address
+				0b00000000, 0b11000000,
+
+				# write commands
+				0b10000000, "0".ord,
+				0b10000000, "1".ord,
+				0b10000000, "2".ord,
+				0b10000000, "3".ord,
+				0b10000000, "4".ord,
+				0b10000000, "5".ord,
+				0b10000000, "6".ord,
+				0b10000000, "7".ord,
+				0b10000000, "8".ord,
+				0b10000000, "9".ord,
+				0b10000000, "a".ord,
+				0b10000000, "b".ord,
+				0b10000000, "c".ord,
+				0b10000000, "d".ord,
+				0b10000000, "e".ord,
+				0b10000000, "f".ord,
+			])
+		end
+	end
+
+	describe "#define_character" do
+		it "should define character" do
+			lcd = HD44780.new(address: 0x10, driver: @driver)
+
+			@i2cout.clear
+
+			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,
+			])
+
+			expect(@i2cout.unpack("C*")).to eq([
+				# set_cgram_address
+				0b00000000, 0b01000000,
+
+				0b10000000, 0b00001110,
+				0b10000000, 0b00010001,
+				0b10000000, 0b00011011,
+				0b10000000, 0b00010101,
+				0b10000000, 0b00011011,
+				0b10000000, 0b00010001,
+				0b10000000, 0b00010001,
+				0b10000000, 0b00001110,
+			])
+		end
+	end
+end

data/spec/driver/gpio_spec.rb

@@ -0,0 +1,514 @@
+#!rspec
+
+$LOAD_PATH.unshift "lib"
+
+require "i2c"
+require "i2c/driver/gpio"
+require "tempfile"
+
+class GPIOTimeline
+	attr_reader :events
+
+	def initialize
+		@timeline = {}
+		@pins = []
+		@events = []
+		@defaults = {}
+		@watchers = {}
+	end
+
+	def define(pin)
+		unless @timeline.include?(pin)
+			default(pin, 0)
+			@timeline[pin] = []
+			@watchers[pin] = []
+			@pins << pin
+		end
+	end
+
+	def add(pin, state)
+		event = {
+			time:  Time.now,
+			state: state,
+			pin: pin,
+		}
+		@events << event
+		@timeline[pin] << event
+		@watchers[pin].each do |watcher|
+			watcher[:count][:total] += 1
+			watcher[:count][state.zero?? :low : :high] += 1
+			watcher[:block].call(state, watcher[:count])
+		end
+	end
+
+	def mark(label, position=:top)
+		event = {
+			time: Time.now,
+			label: label,
+			position: position,
+		}
+		@events << event
+	end
+
+	def default(pin, state=nil)
+		unless state.nil?
+			@defaults[pin] = state
+		end
+		@defaults[pin]
+	end
+
+	def state(pin)
+		@timeline[pin].last[:state]
+	end
+
+	def watch(pin, &block)
+		watcher= {
+			pin: pin,
+			block: block,
+			count: {
+				total: 0,
+				low: 0,
+				high: 0,
+			}
+		}
+		@watchers[pin] << watcher
+		unwatch = lambda {
+			@watchers[pin].delete(watcher)
+		}
+	end
+
+	def dump
+		require "cairo"
+
+		width  = 1240
+		height = 300
+
+		surface = Cairo::ImageSurface.new(Cairo::FORMAT_ARGB32, width, height)
+		context = Cairo::Context.new(surface)
+
+		total = @events.last[:time] - @events.first[:time]
+		start = @events.first[:time]
+		px_per_sec = (width - 20) / total
+
+		h = 50
+
+		context.select_font_face("Lucida Console")
+		context.line_width = 3
+	
+		@events.select {|i| i[:label] }.each do |event|
+			n = event[:time] - start
+			label = event[:label]
+			context.set_source_rgb(0.7, 0.7, 0.7)
+			context.stroke do
+				context.move_to(n * px_per_sec, 0)
+				context.line_to(n * px_per_sec, height)
+			end
+			context.set_source_rgb(0.3, 0.3, 0.3)
+			context.move_to(n * px_per_sec + 5, event[:position] == :top ? 20 : height - 20)
+			context.set_font_size(10)
+			context.show_text(label.to_s)
+		end
+
+		context.set_source_rgb(0.3, 0.3, 0.3)
+		context.line_width = 2
+
+		pin_count = 1
+		@pins.each do |pin|
+			context.save do
+				prev = 0
+				context.translate(0, 100 * pin_count)
+
+				context.move_to(0, prev)
+				context.line_to(10, prev)
+
+				context.translate(10, 0)
+
+				@timeline[pin].each do |event|
+					n = event[:time] - start
+
+					context.line_to(n * px_per_sec, prev * -h)
+					context.line_to(n * px_per_sec, event[:state] * -h)
+					prev = event[:state]
+				end
+
+				context.line_to(width, prev * -h)
+
+				context.stroke
+			end
+			pin_count += 1
+		end
+
+		surface.write_to_png("/tmp/dump.png")
+	end
+end
+
+describe I2CDevice::Driver::GPIO do
+	before do
+		@timeline = timeline = GPIOTimeline.new
+
+		I2CDevice::Driver::GPIO.define_singleton_method(:export) do |pin|
+			timeline.define(pin)
+		end
+
+		I2CDevice::Driver::GPIO.define_singleton_method(:unexport) do |pin|
+		end
+
+		I2CDevice::Driver::GPIO.define_singleton_method(:direction) do |pin, direction|
+			# p [:direction, pin]
+			state = 1
+			case direction
+			when :in
+				state = timeline.default(pin) # pulled-up
+			when :out
+				state = 0
+			when :high
+				state = 1
+			when :low
+				state = 0
+			end
+			timeline.add(pin, state)
+		end
+
+		I2CDevice::Driver::GPIO.define_singleton_method(:read) do |pin|
+			timeline.state(pin)
+		end
+
+		I2CDevice::Driver::GPIO.define_singleton_method(:write) do |pin, val|
+			timeline.add(pin, val ? 1 : 0)
+		end
+
+		@driver = I2CDevice::Driver::GPIO.new(
+			sda: 23,
+			scl: 24,
+			speed: 1,
+		)
+		@timeline.events.clear
+		@timeline.default(@driver.scl, 1)
+		@timeline.default(@driver.sda, 1)
+	end
+
+	describe "i2c protocol" do
+		it "should set start condition correctly" do
+			@driver.send(:start_condition)
+			expect(@timeline.state(@driver.scl)).to be(1)
+			expect(@timeline.state(@driver.sda)).to be(0)
+			expect(@timeline.events.map {|i| [i[:pin], i[:state]] }).to eq([[@driver.sda, 1], [@driver.scl, 1], [@driver.scl, 1], [@driver.sda, 0]])
+		end
+
+		it "should throw exception when bus is busy" do
+			@timeline.default(@driver.scl, 0)
+			expect { @driver.send(:start_condition) }.to raise_error(I2CDevice::I2CBUSBusy)
+		end
+
+		it "should set stop condition correctly" do
+			@driver.send(:start_condition)
+
+			@timeline.events.clear
+			@driver.send(:stop_condition)
+			expect(@timeline.events.map {|i| [i[:pin], i[:state]] }).to eq([ [@driver.scl, 0], [@driver.sda, 0], [@driver.scl, 1], [@driver.sda, 1] ])
+			expect(@timeline.state(@driver.scl)).to be(1)
+			expect(@timeline.state(@driver.sda)).to be(1)
+		end
+
+		it "should write 1 byte correctly and receive nack" do
+			@timeline.mark(:start)
+			@driver.send(:start_condition)
+
+			@timeline.mark(:write)
+			ret = @driver.send(:write, 0b01010011)
+			expect(@timeline.events.drop_while {|i| i[:label] != :write }.select {|i| i[:pin] == @driver.scl }.map {|i| i[:state] }).to eq([0, 1] * 9 + [0])
+			expect(ret).to be(false)
+			expect(@timeline.state(@driver.scl)).to be(0)
+
+			@timeline.mark(:stop)
+			@driver.send(:stop_condition)
+		end
+
+		it "should write 1 byte correctly and receive ack" do
+			@timeline.mark(:start)
+			@driver.send(:start_condition)
+
+			unwatch = @timeline.watch(@driver.scl) do |state, count|
+				case
+				when count[:high] == 8 && state == 0
+					# return ack
+					@timeline.default(@driver.sda, 0)
+				when count[:high] == 9 && state == 1
+					@timeline.mark("ack")
+				when count[:high] == 9 && state == 0
+					@timeline.default(@driver.sda, 1)
+					unwatch.call
+				end
+			end
+
+			@timeline.mark(:write)
+			ret = @driver.send(:write, 0b11111111)
+			expect(@timeline.events.drop_while {|i| i[:label] != :write}.select {|i| i[:pin] == @driver.scl }.map {|i| i[:state] }).to eq([0, 1] * 9 + [0])
+			expect(ret).to be(true)
+			expect(@timeline.state(@driver.scl)).to be(0)
+
+			@timeline.mark(:stop)
+			@driver.send(:stop_condition)
+		end
+
+		it "should read 1 byte correctly and return ack" do
+			@timeline.mark(:start)
+			@driver.send(:start_condition)
+
+			send = 0b00000000
+			unwatch = @timeline.watch(@driver.scl) do |state, count|
+				case
+				when count[:high] < 8 && state == 0
+					# send bit
+					bit = send[ 7 - count[:high] ]
+					@timeline.default(@driver.sda, bit)
+					@timeline.add(@driver.sda, bit)
+				when count[:high] == 9 && state == 1
+					# read ack
+					@timeline.mark(:ack)
+					expect(@timeline.state(@driver.sda)).to be(0)
+					unwatch.call
+					@timeline.default(@driver.sda, 1)
+				end
+			end
+			@timeline.mark(:read)
+			ret = @driver.send(:read, true)
+			expect(ret).to be(send)
+
+			send = 0b01010101
+			unwatch = @timeline.watch(@driver.scl) do |state, count|
+				case
+				when count[:high] < 8 && state == 0
+					# send bit
+					bit = send[ 7 - count[:high] ]
+					@timeline.default(@driver.sda, bit)
+					@timeline.add(@driver.sda, bit)
+				when count[:high] <= 8 && state == 1
+					@timeline.mark("#{8 - count[:high]}", :bottom)
+				when count[:high] == 9 && state == 1
+					# read ack
+					@timeline.mark(:ack)
+					expect(@timeline.state(@driver.sda)).to be(0)
+					unwatch.call
+					@timeline.default(@driver.sda, 1)
+				end
+			end
+			ret = @driver.send(:read, true)
+			expect(ret).to be(send)
+
+			@timeline.mark(:stop)
+			@driver.send(:stop_condition)
+		end
+
+		it "should read 1 byte correctly and return nack" do
+			@timeline.mark(:start)
+			@driver.send(:start_condition)
+
+			send = 0b01010101
+			unwatch = @timeline.watch(@driver.scl) do |state, count|
+				case
+				when count[:high] < 8 && state == 0
+					# send bit
+					bit = send[ 7 - count[:high] ]
+					@timeline.default(@driver.sda, bit)
+					@timeline.add(@driver.sda, bit)
+				when count[:high] == 9 && state == 1
+					# read ack
+					@timeline.mark(:nack)
+					expect(@timeline.state(@driver.sda)).to be(1)
+					unwatch.call
+					@timeline.default(@driver.sda, 1)
+				end
+			end
+			ret = @driver.send(:read, false)
+			expect(ret).to be(send)
+
+			@timeline.mark(:stop)
+			@driver.send(:stop_condition)
+		end
+	end
+
+	describe "i2c abstract interface:" do
+		it "should initialize with sda, scl properties" do
+			expect { I2CDevice::Driver::GPIO.new() }.to raise_error(/required/)
+			expect { I2CDevice::Driver::GPIO.new(sda: 1) }.to raise_error
+			expect { I2CDevice::Driver::GPIO.new(sda: 1, scl: 2) }.not_to raise_error
+		end
+
+		context "unknown slave address:" do
+			describe "i2cset" do
+				it "should throw exception on unknown slave address" do
+					expect { @driver.i2cset(0x20, 0x00) }.to raise_error(I2CDevice::I2CIOError)
+
+					expect(@timeline.state(@driver.scl)).to be(1)
+					expect(@timeline.state(@driver.sda)).to be(1)
+				end
+			end
+
+			describe "i2cget" do
+				it "should throw exception on unknown slave address" do
+					expect { @driver.i2cget(0x20, 0x00) }.to raise_error(I2CDevice::I2CIOError)
+
+					expect(@timeline.state(@driver.scl)).to be(1)
+					expect(@timeline.state(@driver.sda)).to be(1)
+				end
+			end
+		end
+
+		context "valid slave address:" do
+			before do
+				@status = :stop
+				@received = []
+				@memory = [0x00] * 5
+				@max_receive = 3
+
+				unwatch_scl = nil
+				@timeline.watch(@driver.sda) do |state, count|
+					case
+					when @timeline.state(@driver.scl) == 1 && state == 0
+						@status  = :start
+						@timeline.mark(@status)
+						address = 0
+						data    = 0
+						rw      = nil
+						read_address = 0
+						ack     = 1
+						unwatch_scl.call if unwatch_scl
+						unwatch_scl = @timeline.watch(@driver.scl) do |state, count|
+							# p [@status, state, count]
+							case @status
+							when :start
+								case
+								when state == 1 && count[:high] < 8
+									@timeline.mark(8 - count[:high], :bottom)
+									address = (address << 1) | @timeline.state(@driver.sda)
+								when state == 1 && count[:high] == 8
+									@timeline.mark('rw', :bottom)
+									rw = @timeline.state(@driver.sda)
+									# p " 0b%08b == 0b%08b %02x" % [0x20, address, address]
+								when state == 0 && count[:high] == 8
+									if address == 0x20
+										# ack
+										@timeline.default(@driver.sda, 0)
+									else
+										@status = :unkown
+										@timeline.mark(@status)
+									end
+								when state == 1 && count[:high] == 9
+									@timeline.mark('ack')
+								when state == 0 && count[:high] == 9
+									# reset
+									count[:high] = 0
+									count[:low] = 0
+									@timeline.default(@driver.sda, 1)
+									if rw.zero?
+										@status = :write
+									else
+										@status = :read
+										read_address = @received[0]
+									end
+								end
+							when :write
+								case
+								when state == 1 && count[:high] <= 8
+									@timeline.mark(8 - count[:high], :bottom)
+									data = (data << 1) | @timeline.state(@driver.sda)
+								when state == 0 && count[:high] == 8
+									if @received.size < @max_receive
+										@received << data
+										# ack
+										@timeline.default(@driver.sda, 0)
+									end
+								when state == 1 && count[:high] == 9
+									@timeline.mark(@received.size <= @max_receive ? 'ack' : 'nack')
+								when state == 0 && count[:high] == 9
+									# reset
+									data = 0
+									count[:high] = 0
+									count[:low] = 0
+									@timeline.default(@driver.sda, 1)
+									unless @received.size <= @max_receive
+										@status = :stop
+									end
+								end
+							when :read
+								case
+								when state == 0 && count[:high] < 8
+									# send bit
+									bit = @memory[read_address][ 7 - count[:high] ]
+									@timeline.default(@driver.sda, bit)
+									@timeline.add(@driver.sda, bit)
+								when state == 1 && count[:high] <= 8
+									@timeline.mark(8 - count[:high], :bottom)
+								when state == 0 && count[:high] == 8
+									@timeline.default(@driver.sda, 1)
+								when state == 1 && count[:high] == 9
+									ack = @timeline.state(@driver.sda)
+									if ack == 0
+										@timeline.mark("ack")
+									else
+										@timeline.mark("nack")
+										@status = :stop
+									end
+								when state == 0 && count[:high] == 9
+									read_address += 1
+									count[:high] = 0
+									count[:low] = 0
+								end
+							end
+						end
+					when @timeline.state(@driver.scl) == 1 && state == 1
+						@status = :stop
+						@timeline.mark(@status)
+						unwatch_scl.call
+					end
+				end
+			end
+
+			describe "i2cset" do
+				it "should works successfully" do
+					wrote = @driver.i2cset(0x20, 0x0f)
+					expect(wrote).to be(1)
+					expect(@received).to eq([0x0f])
+
+					expect(@timeline.state(@driver.scl)).to be(1)
+					expect(@timeline.state(@driver.sda)).to be(1)
+				end
+
+				it "should write until nack" do
+					@max_receive = 3
+					wrote = @driver.i2cset(0x20, 0x01, 0x02, 0x03, 0x04, 0x05)
+					expect(wrote).to be(3)
+					expect(@received).to eq([0x01, 0x02, 0x03])
+
+					expect(@timeline.state(@driver.scl)).to be(1)
+					expect(@timeline.state(@driver.sda)).to be(1)
+				end
+			end
+
+			describe "i2cget" do
+				it "should works successfully" do
+					@max_receive = 1
+					@memory = (0..4).to_a
+					got = @driver.i2cget(0x20, 0x01)
+					expect(got).to eq("\x01")
+
+					expect(@timeline.state(@driver.scl)).to be(1)
+					expect(@timeline.state(@driver.sda)).to be(1)
+				end
+
+				it "should works with length argument" do
+					@max_receive = 1
+					@memory = (0..4).to_a
+					got = @driver.i2cget(0x20, 0x01, 3)
+					expect(got).to eq("\x01\x02\x03")
+
+					expect(@timeline.state(@driver.scl)).to be(1)
+					expect(@timeline.state(@driver.sda)).to be(1)
+
+					@timeline.dump
+				end
+			end
+		end
+	end
+end