bitwizard 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a2f5266eca9ddb2e732db8ff87c674881adf6f1a
+  data.tar.gz: 1646160e172499d225f23b04519bb8d12b6d425d
+SHA512:
+  metadata.gz: c965fdbf80b846d6e6e2a22bd1861cf0ac66303148214e4c72a096bcce55ab54d533f5b31434cdc2bbc2c0375366d1b830b07b3b45f7d94b53f4aceb6024cac5
+  data.tar.gz: 2e97dd74df33ead09a1d70f5bf49ceeb35643c14f76d06b898cc1673e35a4328e40960b30c7fe0c6948297508293c19076d7fb0e588a966c245deae09e5767e5

data/bin/bitwizardctl

@@ -0,0 +1,327 @@
+#!/usr/bin/env ruby
+
+require 'bitwizard'
+require 'optparse'
+require 'readline'
+
+class BasicLogger
+	def debug(string)
+		puts string
+	end
+end
+
+Options = {
+	:bus => :spi,
+	:verbose => false,
+	:scan => true
+}
+
+class BitWizardCTL
+
+	DetailedHelp = {
+		:scan => { :text => "Scans for available boards" },
+		:list => { :text => "Lists all the found boards" },
+		:eeprom => { :args => "<addr>", :text => "Read the eeprom from the specified address(es), or all found boards if none given" },
+		:exit => { :text => "Exits the program" },
+		:help => { :text => "Lists all the valid commands, or detailed help for a given command" },
+		:pwm => { :args => "<addr> [port [value/'enable'/'disable']]", :text => "Get/Set the PWM value for a certain port on a board" },
+		:stepper => { :args => "<addr> <'current'/'target'/'delay'> [value]", :text => "Get/Set a value for a stepper motor on the specified board" },
+		:motor => { :args => "<addr> <'A'/'B'> <speed/'stop'>", :text => "Change speed of a motor on the specified board" }
+	}
+
+	def initialize
+		@defaultlogger = BasicLogger.new if Options[:verbose]
+		@boards = {}
+	end
+
+	def run!
+		if Options[:scan] then
+			cmd_scan
+			puts
+		end
+
+		complete = Proc.new { |line|
+			ret = []
+			DetailedHelp.each do |cmd, help|
+				data = line.split
+				data << "" if line.end_with? " "
+
+				ret << cmd.to_s unless data
+				next unless data
+
+				if data.length > 1 then
+					next unless cmd.to_s == data[0]
+					break if cmd.to_s == data[0] and not help.has_key? :args
+
+					arg_data = help[:args].split[data.length - 2]
+
+					if arg_data == "<addr>" then
+						#p @boards
+						@boards.each do |addr,_|
+							straddr = "0x#{addr.to_s(16)}"
+							ret << "#{straddr}" if /^#{Regexp.escape(data[1])}/ =~ straddr
+						end
+					elsif cmd == :stepper and data.length == 3 then
+						["current","target","delay"].each do |str|
+							ret << "#{str}" if /^#{Regexp.escape(data[2])}/ =~ str
+						end
+					elsif cmd == :motor then
+						if data.length == 3 then
+							["A","B"].each do |str|
+								ret << "#{str}" if data[2].length == 0 or data[2] == str
+							end
+						elsif data.length == 4 and data[3].length > 0 then
+							ret << "stop" if "stop".start_with? data[3]
+						end
+					elsif cmd == :pwm and data.length == 4 then
+						["enable", "disable"].each do |str|
+							ret << "#{str}" if str.start_with? data[3]
+						end if data[3].length > 0
+					end
+
+					if ret.length == 1 then
+						ret = [ data[0..-2].join(" ") + " " + ret[0] ]
+					end
+				else
+					ret << cmd.to_s if /^#{Regexp.escape(line)}/ =~ cmd.to_s
+				end
+			end
+
+			ret
+		}
+
+		Readline.completer_word_break_characters = ""
+		Readline.completion_append_character = " "
+		Readline.completion_proc = complete
+
+		while line = Readline.readline("[BitWizard]\# ", true) do
+			run_cmd!(*line.split)
+		end
+	end
+
+	def run_cmd!(*args)
+		command = args.shift
+		if respond_to? "cmd_#{command}".to_sym, true then
+			begin
+				send("cmd_#{command}".to_sym, *args)
+			rescue ArgumentError => ex
+				puts "  \e[31m#{ex}\e[0m"
+				if Options[:verbose] then
+					ex.backtrace.each do |line|
+						puts "    #{line}"
+					end
+				end
+			end
+		else
+			puts "Unknown command '#{command}', try 'help' for a list of valid ones"
+		end
+	end
+
+	private
+
+	def parse_addr(addr)
+		addr = eval addr if /^0x[0-9a-fA-F]{1,2}$/ =~ addr
+		addr = addr.to_i unless addr.is_a? Fixnum
+
+		raise ArgumentError.new "Address must be between 0x00 and 0xff" unless (0..255).include? addr
+		addr
+	end
+
+	def get_board(addr)
+		board = @boards[addr] if @boards.has_key? addr
+		unless board then
+			board = BitWizard::Board.detect :address => addr, :bus => Options[:bus], :logger => (@defaultlogger if Options[:verbose])
+			@boards[addr] = board if board.valid?
+		end
+
+		raise ArgumentError.new "No valid board on 0x#{addr.to_s(16)}" unless board.valid?
+		board
+	end
+
+	def cmd_help(*)
+		longestcmd = 0
+		DetailedHelp.each do |cmd,data|
+			curlen = cmd.length
+			curlen += data[:args].length if data.has_key? :args
+			longestcmd = curlen if curlen > longestcmd
+		end
+
+		puts "Available commands:"
+		DetailedHelp.each do |cmd, help|
+			puts "  #{cmd} #{help[:args] if help.has_key? :args} #{" " * (longestcmd - cmd.length - (help[:args] and help[:args].length or 0))}#{help[:text]}"
+		end
+	end
+
+	def cmd_exit(*)
+		exit
+	end
+
+	def cmd_scan(*)
+		puts "Scanning for boards..."
+
+		@boards = { }
+		(0..0xff).step(2) do |address|
+			begin
+				temp = BitWizard::Board.detect :address => address, :bus => Options[:bus], :logger => (@defaultlogger if Options[:verbose])
+				next unless temp.valid?
+
+				@boards[temp.address] = temp
+				puts "0x#{address.to_s(16)}: #{temp.type} (#{temp.version})"
+			rescue ArgumentError
+			end
+		end
+	end
+
+	def cmd_list(*)
+		@boards.each do |_, board|
+			puts "0x#{board.address.to_s(16)}: #{board.type} (#{board.version})"
+		end
+	end
+
+	def cmd_eeprom(*args)
+		if args.count == 0 then
+			@boards.each do |_, board|
+				puts "0x#{board.address.to_s(16)}: #{board.read(0x02, 4).pack("C*").unpack("l>")[0]}"
+			end
+		elsif args.count == 1 then
+			begin
+				addr = parse_addr args[0]
+				board = get_board addr
+				puts "0x#{addr.to_s(16)}: #{board.read(0x02, 4).pack("C*").unpack("l>")[0]}"
+			rescue ArgumentError => err
+				puts "0x#{addr.to_s(16)}: #{err}"
+			end
+		end
+	end
+
+	def cmd_pwm(*args)
+		raise ArgumentError.new "Wrong number of arguments (#{args.count} for 1-3)" unless (1..3).include? args.count
+		addr, port, value = *args if args.count == 3
+		value = value.to_i if not ["enable","disable"].include? value
+		addr, port = *args if args.count == 2
+		port = port.to_i if port
+		addr = args[0] if args.count == 1
+
+		raise ArgumentError.new "Value must be between 0 and 255" unless value.is_a? String or (0..255).include? value
+
+		addr = parse_addr addr
+		board = get_board addr
+
+		raise ArgumentError.new "Board doesn't support PWM actions" unless board.known_board[:features].include? :pwm
+
+		puts "0x#{addr.to_s(16)}:"
+
+		if port then
+			if value.is_a? String then
+				succ = board.pwm_disable port if value == "disable"
+				succ = board.pwm_enable port if value == "enable"
+				puts "  PWM \##{port}: #{value == "off" ? "disabled" : "enabled"}." if succ
+				pust "  Failed to change PWM status on port \##{port}" unless succ
+			else
+				ports = board.pwm_ports
+				unless ports.include? port then
+					puts "  PWM not enabled on port #{port}"
+					return
+				end
+
+				board[port] = value if value
+				puts "  PWM \##{port}: #{((board[port] / 255.0) * 100).round(2)}% (#{board[port]})"
+			end
+		else
+			board.pwm_ports.each do |port|
+				puts "  PWM \##{port}: #{((board[port] / 255.0) * 100).round(2)}% (#{board[port]})"
+			end
+		end
+	end
+
+	def cmd_stepper(*args)
+		raise ArgumentError.new "Wrong number of arguments (#{args.count} for 2-3)" unless (2..3).include? args.count
+
+		addr, type, value = *args if args.count == 3
+		value = value.to_i if value
+		addr, type = *args if args.count == 2
+		type = type.to_sym
+
+		raise ArgumentError.new "Value to #{args.count == 3 ? "set" : "read"} must be 'current', 'target', or 'delay'" unless [:current, :target, :delay].include? type
+		
+		addr = parse_addr addr
+		board = get_board addr
+
+		raise ArgumentError.new "Board doesn't support stepper actions" unless board.known_board[:features].include? :stepper
+
+		case type
+		when :current
+			board.stepper_position = value if value
+			puts "0x#{addr.to_s(16)}'s current position: #{board.stepper_position}"
+		when :target
+			board.stepper_target = value if value
+			puts "0x#{addr.to_s(16)}'s target position: #{board.stepper_target}"
+		when :delay
+			board.stepper_delay = value if value
+			puts "0x#{addr.to_s(16)}'s step delay: #{board.stepper_delay / 10.0}ms (#{board.stepper_delay})"
+		end
+	end
+
+	def cmd_motor(*args)
+		raise ArgumentError.new "Wrong number of arguments (#{args.count} for 3)" unless args.count == 3
+
+		addr, motor, value = *args
+		motor = motor.to_sym
+		value = value.to_i unless value == "stop"
+
+		raise ArgumentError.new "Motor must be 'A' or 'B'" unless [:A,:B].include? motor
+		raise ArgumentError.new "Value must be between -255 - 255" unless value.is_a? String or (-255..255).include? value
+		
+		addr = parse_addr addr
+		board = get_board addr
+
+		raise ArgumentError.new "Board doesn't support motor actions" unless board.known_board[:features].include? :motor
+
+		if value.is_a? String
+			board.motor_stop motor
+		else
+			board.motor_spin motor, value
+		end
+	end
+
+end
+
+OptionParser.new do |opts|
+	opts.banner = "Usage: #{File.basename($0)} [options] [command [arguments]]"
+	opts.separator ""
+	opts.separator "Options:"
+
+	opts.on("-i", "--i2c", "Use I2C instead of SPI") do |i|
+		Options[:bus] = :i2c
+	end
+
+	opts.on("-s", "--skip", "Skip the scan on start") do
+		Options[:scan] = false
+	end
+
+	opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+		Options[:verbose] = v
+	end
+
+	opts.on("-h", "--help", "Shows this text") do
+		puts opts
+		exit
+	end
+
+	opts.separator ""
+	opts.separator "Commands:"
+
+	BitWizardCTL::DetailedHelp.each do |cmd, help|
+		opts.separator "  #{cmd}#{help.has_key? :args and " #{help[:args]}" or ""}"
+		opts.separator "    #{help[:text]}"
+
+	end
+end.parse!
+
+ctl = BitWizardCTL.new
+
+if ARGV.count > 0 then
+	ctl.run_cmd!(*ARGV)
+else
+	ctl.run!
+end

data/lib/bitwizard.rb

@@ -0,0 +1,219 @@
+require 'pi_piper'
+
+module BitWizard
+
+	class Board
+
+		#Detects the type of board on the given address and creates the correct handler class for it.
+		#
+		# @param [Number] address The address to check.
+		# @param [optional, Hash] options A Hash of options.
+		# @option options [Symbol] :bus The type of bus the board is connected on. (:spi or :i2c)
+		# @option options [Logger] :logger A logger you want to attach to the board.
+		def Board.detect(options)
+			options = {
+				:address => -1,
+				:bus => :spi,
+				:logger => NullLogger.new
+			}.merge(options).merge({
+				:type => :auto_detect,
+				:skip_check => false
+			})
+
+			options[:logger] = NullLogger.new unless options[:logger]
+
+			temp = BitWizard::Board.new options
+			correct = temp.known_board[:constructor].call(options.merge({:skip_check => true})) if temp.valid?
+
+			correct.instance_variable_set(:@type, temp.type)
+			correct.instance_variable_set(:@version, temp.version)
+			correct.instance_variable_set(:@known_board, temp.known_board)
+
+			correct
+		end
+
+		attr_reader :type, :version, :address, :bus, :known_board
+		attr_accessor :logger
+
+		#Creates a generic board handle for reading and writing directly.
+		#
+		# @param [Hash] options A hash of options.
+		# @option options [Fixnum] :address The address of the board. (0x00..0xff)
+		# @option options [Symbol] :type The board type, defaults to auto detecting. (identifier)
+		# @option options [Symbol] :bus The bus it's connected to. (:spi or :i2c)
+		# @option options [Boolean] :skip_check Skip the self check that runs on creation.
+		# @option options [Logger] :logger Add a logger here to log data that's sent and received.
+		def initialize(options)
+			options = {
+				:address => -1,
+				:type => :auto_detect,
+				:bus => :spi,
+				:skip_check => false,
+				:logger => NullLogger.new
+			}.merge(options)
+
+			raise ArgumentError.new "Bus must be :spi or :i2c." unless options[:bus] == :spi or options[:bus] == :i2c
+
+			@logger = options[:logger]
+			@address = options[:address]
+			@type = options[:type]
+			@bus = options[:bus]
+
+			self_check! unless options[:skip_check]
+		end
+
+		#Returns if the board has a valid communication address
+		def valid?
+			return false if @address == -1 or @type == :auto_detect
+			true
+		end
+
+		#Writes a value to the board, either a single byte or several in the form of a string
+		#
+		# @param [Number] reg The registry address to write to
+		# @param [Number|String] value The data to write to the board
+		def write(reg, value)
+			raise ArgumentError.new "#{reg} is not a valid register, must be a number between 0x00..0xff" unless reg.is_a? Fixnum and (0..255).include? reg
+			raise ArgumentError.new "#{value} is not a valid value, must be a single byte or a string" unless (value.is_a? Fixnum and (0..255).include? value) or (value.is_a? String)
+
+			value = value.unpack("C*") if value.is_a? String
+			return spi_write(reg, value) if @bus == :spi
+			return i2c_write(reg, value) if @bus == :i2c
+		end
+
+		#Reads a value from the board
+		#
+		# @param [Number] reg The registry address to read from
+		# @param [Number] count The number of bytes to read
+		def read(reg, count)
+			raise ArgumentError.new "#{reg} is not a valid register, must be a number between 0x00..0xff" unless reg.is_a? Fixnum and (0..255).include? reg
+
+			return spi_read(reg, count) if @bus == :spi
+			return i2c_read(reg, count) if @bus == :i2c
+		end
+
+		#Changes the boards address
+		#
+		# The new address needs to follow these criteria;
+		#   * Must be a 8-bit number between 0x00 and 0xff
+		#   * Must not have it's least significant bit set
+		#
+		# @param [Number] new_address The new address of the board
+		def address=(new_address)
+			raise ArgumentError.new "#{new_address} is not a valid address" unless new_address.is_a? Fixnum and (0..255).include? new_address and new_address|1 != new_address
+
+			old_address = @address
+			@address = new_address
+			identifier = read(0x01, 20).pack("C*").split("\0")[0]
+			@address = old_address
+
+			Known_Boards.each do |name, data|
+				if name =~ identifier then
+					raise ArgumentError.new "Another board (#{identifier}) already exists on #{new_address}!"
+				end
+			end
+
+			write 0xf1, 0x55
+			write 0xf2, 0xaa
+			write 0xf0, new_address
+
+			@address = new_address
+		end
+
+		private
+
+		class NullLogger
+			def debug(*) end
+		end
+
+		#Performs a self check of the board
+		#
+		# This includes contacting the board and checking that it's of the correct type.
+		def self_check!
+			found_board = nil
+			Known_Boards.each do |name, data|
+				if name =~ @type then
+					@address = data[:default_address] unless (0..255).include? @address
+					found_board = {
+						:name => name,
+						:data => data
+					}
+					break
+				end
+			end
+			raise ArgumentError.new "Don't know what board '#{@type}' is." if not found_board and @type != :auto_detect
+			raise ArgumentError.new "Board type is 'auto_detect', but invalid address #{@address} given." if @type == :auto_detect and not (0..255).include? @address
+
+			identifier = read(0x01, 20).pack("C*").split("\0")[0]
+			raise ArgumentError.new "No response from board" if identifier.empty?
+
+			if @type == :auto_detect then
+				Known_Boards.each do |name, data|
+					if name =~ identifier then
+						@type, @version = *identifier.split
+						@type = @type.to_sym
+						@known_board = data
+						break
+					end
+				end
+
+				raise ArgumentError.new "No known board of type '#{identifier}'." if @type == :auto_detect and not identifier.empty?
+			else
+				Known_Boards.each do |name, data|
+					if name =~ identifier then
+						@version = identifier.split[1]
+						@known_board = data
+						raise ArgumentError.new "Board reports type #{real_name}, which does not match #{@type}" unless found_board[:data] == data
+						break
+					end
+				end
+			end
+
+			true
+		end
+
+		def spi_write(reg, value)
+			@logger.debug("SPI [0x#{@address.to_s(16)}] <-- 0x#{reg.to_s(16)}: #{value.is_a? Array and value.pack("C*").inspect or value.inspect}")
+			PiPiper::Spi.begin do |spi|
+				spi.write @address, reg, *value if value.is_a? Array
+				spi.write @address, reg, value unless value.is_a? Array
+			end
+		end
+
+		def spi_read(reg, count)
+			data = PiPiper::Spi.begin do |spi|
+				spi.write @address | 1, reg, *Array.new(count, 0)
+			end[2..-1]
+			@logger.debug("SPI [0x#{@address.to_s(16)}] --> 0x#{reg.to_s(16)}: #{data.pack("C*").inspect}")
+			data
+		end
+
+		def i2c_write(reg, value)
+			@logger.debug("I2C [0x#{@address.to_s(16)}] <-- 0x#{reg.to_s(16)}: #{value.is_a? Array and value.pack("C*").inspect or value.inspect}")
+			PiPiper::I2C.begin do |i2c|
+				data = [reg]
+				data << value unless value.is_a? Array
+				data += value if value.is_a? Array
+
+				i2c.write({ :to => @address, :data => data })
+			end
+		end
+
+		def i2c_read(reg, count)
+			data = PiPiper::I2C.begin do |i2c|
+				i2c.write({ :to => @address | 1, :data => [reg, *Array.new(count, 0)] })
+				i2c.read count
+			end
+			@logger.debug("I2C [0x#{@address.to_s(16)}] --> 0x#{reg.to_s(16)}: #{data.pack("C*").inspect}")
+			data
+		end
+	end
+
+	#A list of boards the library knows how to handle.
+	Known_Boards = {
+		
+	} unless defined? Known_Boards
+
+end
+
+Dir[File.dirname(__FILE__) + "/bitwizard/*.rb"].each { |file| require file }

data/lib/bitwizard/motor.rb

@@ -0,0 +1,155 @@
+module BitWizard
+	module Boards
+
+		class Motor < Board
+
+			#Create an instance of a Motor board
+			#
+			# @param [optional, Hash] options A Hash of options.
+			def initialize(options={})
+				options = {
+					:bus => :spi
+				}.merge(options)
+				options = options.merge({
+					:type => "#{options[:bus]}_motor".to_sym,
+				})
+
+				super(options)
+			end
+
+			#Start spinning a motor on a specific port
+			#
+			# @param [Symbol] port The port to spin (:A or :B)
+			# @param [Number] value The direction and speed of the motor (-255..255)
+			def motor_start(port, value)
+				raise ArgumentError.new("Port must be :A or :B") unless port == :A or port == :B
+				raise ArgumentError.new("Value must be an integer beween -255 and 255") unless value.is_a? Fixnum and (-255..255).include? value
+
+				basereg = 0x20
+				basereg = 0x30 if port == :B
+
+				if value < 0 then
+					write(basereg+1, -value)
+				elsif value > 0 then
+					write(basereg+1, value)
+				else
+					write(basereg+2, 1)
+				end
+			end
+
+			#Stop spinning a motor on a specific port
+			#
+			# This is the same as running start_motor with the value 0
+			#
+			# @param [Symbol] port The port to stop (:A or :B)
+			def motor_stop(port)
+				raise ArgumentError.new "Port must be :A or :B" unless port == :A or port == :B
+
+				motor_start(port, 0)
+			end
+
+			#Read the current position of the stepper motor
+			#
+			# @return [Number] The current stepper position
+			def stepper_position
+				read(0x40, 4).pack("C*").unpack("l>")[0]
+			end
+			#Set the current position of the stepper motor, without actually moving it
+			#
+			# @param [Number] position The new position of the stepper motor
+			def stepper_position=(position)
+				raise ArgumentError.new "Position must be an integer" unless position.is_a? Fixnum
+
+				write(0x40, [position].pack("l>"))
+			end
+
+			#Read the target position of the stepper motor
+			#
+			# @return [Number] The target position of the stepper
+			def stepper_target
+				read(0x41, 4).pack("C*").unpack("l>")[0]
+			end
+			#Set the target position of the stepper motor
+			#
+			# @param [Number] position The target position for the stepper motor
+			def stepper_target=(position)
+				raise ArgumentError.new "Position must be an integer" unless position.is_a? Fixnum
+
+				write(0x41, [position].pack("l>"))
+			end
+
+			#Read the step delay of the stepper motor
+			# 
+			# @return [Number] The stepdelay in tenths of a millisecond
+			def stepper_delay
+				read(0x43, 1)[0]
+			end
+			#Set the step delay of the stepper motor
+			#
+			# @param [Number] delay The new stepdelay, in tenths of a millisecond (maximum 255 - 25ms between steps)
+			def stepper_delay=(delay)
+				raise ArgumentError.new "Delay must be an integer between 0 and 255" unless delay.is_a? Fixnum and (0..255).include? delay
+
+				write(0x43, delay)
+			end
+
+			#Enables Pulse Width Modulation on the specified port
+			#
+			# @param [Number|Array] port The port/ports to enable PWM on
+			def pwm_enable(*port)
+				false # Board doesn't support enabling/disabling PWM
+			end
+
+			#Disables Pulse Width Modulation on the specified port
+			#
+			# @param [Number|Array] port The port/ports to disable PWM on
+			def pwm_disable(*port)
+				false # Board doesn't support enabling/disabling PWM
+			end
+
+			#Returns the ports that have PWM enabled
+			#
+			# @return [Array] An array containing the port numbers with PWM enabled
+			def pwm_ports
+				[1, 2, 3, 4] # Board doesn't support enabling/disabling PWM
+			end
+
+			#Checks if a port has PWM enabled
+			#
+			# @param [Number] port The port to check
+			# @return [Boolean] Is the port enabled for PWM control
+			def pwm_enabled?(port)
+				pwm_ports.include? port
+			end
+
+			#Read a PWM value from a port
+			#
+			# @param [Symbol] port The port to read from (1..4)
+			# @return [Number] The PWM value on the port
+			def [](port)
+				raise ArgumentError.new "Port must be an integer between 1 and 4" unless port.is_a? Fixnum and (1..4).include? port
+
+				read(0x50+(port-1), 1)[0]
+			end
+
+			#Set a PWM value from a port
+			#
+			# @param [Number] port The port to set (1..4)
+			# @param [Number] value The PWM value to set on the port (0..255)
+			def []=(port, value)
+				raise ArgumentError.new "Port must be an integer between 1 and 4" unless port.is_a? Fixnum and (1..4).include? port
+
+				write(0x50+(port-1), value)
+			end
+
+		end
+
+	end
+
+	Known_Boards[/(spi|i2c)_motor/] = {
+		:default_address => 0x90,
+		:constructor => Proc.new { |options| BitWizard::Boards::Motor.new options },
+		:features => [ :motor, :stepper, :pwm ]
+	}
+
+end

data/lib/bitwizard/nfets.rb

@@ -0,0 +1,186 @@
+module BitWizard
+	module Boards
+
+		class FETs < Board
+
+			attr_reader :num_FETs
+
+			#Create an instance of a FET board
+			#
+			# @param [optional, Hash] options A Hash of options.
+			# @option options [Number] :num The number of FETs on the board (3 or 7)
+			def initialize(options={})
+				options = {
+					:num => 3,
+					:bus => :spi
+				}.merge(options)
+				options = options.merge({
+					:type => "#{options[:bus]}_#{options[:num]}fets".to_sym,
+				})
+
+				raise ArgumentError.new "Number of FETs must be 3 or 7" unless options[:num] == 3 or options[:num] == 7
+
+				super(options)
+
+				@num_FETs = options[:num]
+			end
+
+			#Enables Pulse Width Modulation on the specified port
+			#
+			# @param [Number|Array] port The port/ports to enable PWM on
+			def pwm_enable(*port)
+				case port.count
+				when 0
+					raise ArgumentError.new "wrong number of arguments"
+				when 1
+					port = port.first
+				end
+
+				if port.is_a? Array then
+					port.each do |port|
+						pwm_enable port
+					end
+					return true
+				end
+				raise ArgumentError.new "Port must be an integer between 1 and #{@num_FETs}" unless port.is_a? Fixnum and (1..@num_FETs).include? port
+
+				port = 2**(port-1)
+
+				curPWM = read(0x5f, 1)[0]
+				tgtPWM = curPWM | port
+				write(0x5f, tgtPWM)
+
+				true
+			end
+
+			#Disables Pulse Width Modulation on the specified port
+			#
+			# @param [Number|Array] port The port/ports to disable PWM on
+			def pwm_disable(*port)
+				case port.count
+				when 0
+					raise ArgumentError.new "wrong number of arguments"
+				when 1
+					port = port.first
+				end
+
+				if port.is_a? Array then
+					port.each do |port|
+						pwm_disable port
+					end
+					return true
+				end
+				raise ArgumentError.new "Port must be an integer between 1 and #{@num_FETs}" unless port.is_a? Fixnum and (1..@num_FETs).include? port
+
+				port = 2**(port-1)
+
+				curPWM = read(0x5f, 1)[0]
+				tgtPWM = curPWM & ~port
+				write(0x5f, tgtPWM)
+
+				true
+			end
+
+			#Returns the ports that have PWM enabled
+			#
+			# @return [Array] An array containing the port numbers with PWM enabled
+			def pwm_ports
+				curPWM = read(0x5f, 1)[0]
+
+				ret = []
+				(1..@num_FETs).each do |port|
+					ret << port if curPWM & 2**(port-1) > 0
+				end
+				ret
+			end
+
+			#Checks if a port has PWM enabled
+			#
+			# @param [Number] port The port to check
+			# @return [Boolean] Is the port enabled for PWM control
+			def pwm_enabled?(port)
+				pwm_ports.include? port
+			end	
+
+			#Read the current position of the stepper motor
+			#
+			# @return [Number] The current stepper position
+			def stepper_position
+				read(0x40, 4).pack("C*").unpack("l>")[0]
+			end
+			#Set the current position of the stepper motor, without actually moving it
+			#
+			# @param [Number] position The new position of the stepper motor
+			def stepper_position=(position)
+				raise ArgumentError.new "Position must be an integer" unless position.is_a? Fixnum
+
+				write(0x40, [position].pack("l>"))
+			end
+
+			#Read the target position of the stepper motor
+			#
+			# @return [Number] The target position of the stepper
+			def stepper_target
+				read(0x41, 4).pack("C*").unpack("l>")[0]
+			end
+			#Set the target position of the stepper motor
+			#
+			# @param [Number] position The target position for the stepper motor
+			def stepper_target=(position)
+				raise ArgumentError.new "Position must be an integer" unless position.is_a? Fixnum
+
+				write(0x41, [position].pack("l>"))
+			end
+
+			#Read the step delay of the stepper motor
+			# 
+			# @return [Number] The stepdelay in tenths of a millisecond
+			def stepper_delay
+				read(0x43, 1)[0]
+			end
+			#Set the step delay of the stepper motor
+			#
+			# @param [Number] delay The new stepdelay, in tenths of a millisecond (maximum 255 - 25ms between steps)
+			def stepper_delay=(delay)
+				raise ArgumentError.new "Delay must be an integer between 0 and 255" unless delay.is_a? Fixnum and (0..255).include? delay
+
+				write(0x43, delay)
+			end
+
+			#Returns the PWM value on the specified port
+			#
+			# @param [Number] port The port to read the value from
+			# @return [Number] The PWM value on the port (0..255)
+			def [](port)
+				raise ArgumentError.new "Port must be an integer between 1 and #{@num_FETs}" unless port.is_a? Fixnum and (1..@num_FETs).include? port
+
+				return read(0x50 + (port-1), 1)[0]
+			end
+
+			#Sets the PWM value on the specified port
+			#
+			# @param [Number] port The port to set the value on
+			# @param [Number] value The PWM value to set (0..255)
+			def []=(port, value)
+				raise ArgumentError.new "Port must be an integer between 1 and #{@num_FETs}" unless port.is_a? Fixnum and (1..@num_FETs).include? port
+				raise ArgumentError.new "Value must be an integer between 0 and 255" unless value.is_a? Fixnum and (0..255).include? value
+
+				write(0x50 + (port-1), value)
+			end
+
+		end
+
+	end
+
+	Known_Boards[/(spi|i2c)_3fets/] = {
+		:default_address => 0x8a,
+		:constructor => Proc.new { |options| BitWizard::Boards::FETs.new options.merge({ :num => 3 }) },
+		:features => [ :input, :output, :stepper, :pwm ]
+	}
+	Known_Boards[/(spi|i2c)_7fets/] = {
+		:default_address => 0x88,
+		:constructor => Proc.new { |options| BitWizard::Boards::FETs.new options.merge({ :num => 7 }) },
+		:features => [ :input, :output, :stepper, :pwm ]
+	}
+
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: bitwizard
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Alexander "Ace" Olofsson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pi_piper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby library for controlling the BitWizard boards over SPI and I2C
+email: ace@haxalot.com
+executables:
+- bitwizardctl
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/bitwizard.rb
+- lib/bitwizard/nfets.rb
+- lib/bitwizard/motor.rb
+- bin/bitwizardctl
+homepage: https://github.com/ace13/BitWizard-Ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Ruby library for BitWizard boards
+test_files: []