motorcontrolboard 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in motorcontrolboard.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Francesco Sacchi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+# Motorcontrolboard
+
+Interface library for MotorControlBoard board
+http://irawiki.disco.unimib.it/irawiki/index.php/INFIND2011/12_Motor_control_board 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'motorcontrolboard'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install motorcontrolboard
+
+## Usage
+
+	#!/usr/bin/env ruby
+	require 'motorcontrolboard'
+
+	#params for serial port
+	initParams = {  'port' => "/dev/ttyUSB0",
+					'baud_rate' => 57600,
+					'vidpid' => '10c4:ea60'}
+
+	@m = MotorControlBoard.new(initParams)
+	@m.initData('init.yaml')
+	@m.connect
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/motorcontrolboard.rb

@@ -0,0 +1,243 @@
+#!/usr/bin/env ruby
+require "rubygems"
+require 'timeout'
+
+require_relative "motorcontrolboard/mcb_connection.rb"
+require_relative "motorcontrolboard/mcb_data.rb"
+
+
+# This class implements an interface to communicate with a Motor Control Board
+# (http://irawiki.disco.unimib.it/irawiki/index.php/INFIND2011/12_Motor_control_board)
+# 
+# It uses an internal representation of the commands that can be sent to the board
+# and also the representation of the memory locations where is possible to write/read
+# along with the position, the type and the actual value.
+# 
+# A row in the internal representation, which corresponds to a memory location
+# in the physical board, is composed by some fields:
+# * mask_name: a symbol to target the field. Is derived from the mask defined in the serial header file of the firmware. The symbol is obtained by removing the initial MASK_ and making the name lowercase
+# * position: the position of the memory location, starting from zero
+# * type: the tipe of the memory location. It can be one among FLSC accoring to the ARRAY::pack documentation
+# * value: the value of the memory location
+# * valid: a valid bit. If set, the row will be involved in the next read/write command
+class MotorControlBoard
+    # Accept as argument an hash specifying #port, #vidpid, and or #baud_rate
+    # #data has to be initialized with the apposite function #initData
+    def initialize(args = {})
+        @port = args['port'] || '/dev/ttyUSB0'
+        @baud_rate = args['baud_rate'] || 57600
+        @vidpid = args['vidpid']
+    end
+
+    
+    # Return the mask of the valid bits of the internal representation
+    # 
+    # The data get sorted but the position is not taken in account so for example if a position is missing a zero will not be added.
+    # The user is responsible to provide consistent data
+    def dataMask
+        sortData()
+        '0b' + @data.inject(''){|mem, ob| ob['valid'].to_s + mem    }
+    end
+
+    # Return the values according to valid bit
+    # 
+    # The data get sorted but the position is not taken in account
+    # Values are also packed according to their type
+    def dataValues
+        sortData()
+        @data.select{|data| data['valid']==1}.inject("") {|acc, val| acc << [val['value']].pack(val['type'])}
+    end
+
+    # Set the valid bit according to a given mask
+    def maskToValid(mask)
+        maskToPos(mask).each do |pos|
+            (@data.select{|row| row['position']==pos}.first)['valid']=1
+        end
+    end
+
+
+    # Return a mask according to the names passed as parameters
+    # 
+    # The length of the mask will be the max pos + 1 so if there are missing/duplicated positions the mask will be inconsistent
+    def maskFromNames(*names)
+        mask = '0'*(getMaxPos()+1)
+        names.each do |name|
+            mask[positionFromName(name)]='1'
+        end
+
+        mask='0b'+mask.reverse
+    end
+    # Return the position given the name
+    def positionFromName(name)
+        (@data.select{|newData| newData['mask_name']==name}.first)['position']
+    end
+
+    # Return the mask conresponding to the given position
+    def maskByPos(pos)
+        return "0b"+"1"+"0"*pos
+    end
+
+    # Return the byte length of a type used by pack/unpack
+    def lenByType(type)
+        case type
+        when 'L', 'F'
+            4
+        when 'S'
+            2
+        when 'C'
+            1
+        else
+            0
+        end
+    end
+
+    # Return an array of poses given a mask
+    def maskToPos(mask)
+        pos = []
+        mask[2..-1].reverse.each_char.with_index do |e, i| 
+            if e=='1' 
+                pos << i
+             end
+         end
+        pos
+    end
+
+    # commands
+    def sendCommand(command)
+        startByte()
+        sendC(command)
+        if @echo
+            puts 'sent: ' + command
+            puts 'waiting for return'
+            rec = @sp.getc
+            puts 'received: ' + rec
+            puts 'does they match? ' + (command==rec).to_s
+        end
+    end
+    
+    # Send the command set
+    def cmd_set
+        self.sendCommand('S')
+    end
+    # Send the command get
+    def cmd_get
+        self.sendCommand('G')
+    end
+    # Send the command start
+    def cmd_start
+        self.sendCommand('x')
+    end
+    # Send the command gorunning
+    def cmd_gorunning
+        self.sendCommand('a')
+    end
+    # Send the command gocalib
+    def cmd_gocalib
+        self.sendCommand('b')
+    end
+    # Send the command goinit
+    def cmd_goinit
+        self.sendCommand('i')
+    end
+    # Send the command coast
+    def cmd_coast
+        self.sendCommand('j')
+    end
+    # Send the command uncoast
+    def cmd_uncoast
+        self.sendCommand('u')
+    end
+    # Send the command reset
+    def cmd_reset
+        self.sendCommand('r')
+    end
+    # Send the command whois and return the result
+    def cmd_whois
+        self.sendCommand('w')
+        who = ""
+        while (char = @sp.getc) != "\u0000"
+            who << char
+        end
+        who
+    end
+        
+
+    # Set data according to valid bit. The value saved in the internal representation will be set
+    def setByValid()
+        mask = dataMask()
+        values = dataValues()
+        cmd_set()
+        sleep 0.1
+        self.sendS([Integer(mask)].pack('L'))
+        sleep 0.1
+        self.sendS(values)
+    end
+
+    # Send single data by name
+    # 
+    # Params:
+    # +name+:: The symbol matching the name of the mask
+    # +val+:: The value to assign
+    def setByName(name, val)
+        dataResetValid
+        maskToValid(maskFromNames(name))
+        (@data.select {|row| row['mask_name']==name}.first)['value']=val
+        setByValid()
+    end
+
+    # yet to be implemented.. is this useful?
+    def setByPos(pos, val)
+    end
+
+
+    # Read data at the given position
+    def getSingleData(pos)
+        getByMask(maskByPos(pos))
+    end
+
+    # Read data according to the given names
+    def getByNames(*names)
+        getByMask(maskFromNames(*names))
+    end
+
+    # Read data according to the given mask
+    def getByMask(mask)
+        dataResetValid
+        maskToValid(mask)
+        getByValid
+    end
+    
+    # Get data according to the valid bit
+    def getByValid()
+        mask = dataMask()
+        if (Integer(mask)!=0) 
+            @data = @data.sort_by { |row| row['position'] }
+            len = validDataLength
+            cmd_get()
+            sleep 0.1
+            self.sendS([Integer(mask)].pack('L'))
+            result = []
+            readBytes = []
+            begin
+                Timeout::timeout(1) do
+                    len.times {readBytes << @spr.getc}
+                    readBytes.reverse!
+
+                    @data.select{|data| data['valid']==1}.each do |row| #do we need to revert this??
+                        data=""
+                        lenByType(row['type']).times do
+                            data << readBytes.pop
+                        end
+                        value = data.unpack(row['type']).first
+                        row['value'] = value
+                        result << {'mask_name'=>row['mask_name'], 'value' => value}
+                    end
+                end
+            rescue
+                puts 'Timeout to read with mask ' + mask
+                puts 'Read ' + readBytes.length.to_s + '/' + len.to_s + ' bytes'
+            end
+            return result
+        end
+    end
+end

data/lib/motorcontrolboard/mcb_connection.rb

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+require "serialport"
+class MotorControlBoard
+	# Descriptor of the vid/pid of the board. Something like '10c4:ea60'.
+    # Can be obtained through a command like 'lsusb'.
+    # 
+    # Setting this variable allow to discover the port where the board is conencted automatically
+	attr_accessor :vidpid
+    # String describing the port where the board is connected.
+    # Usually is something like '/dev/ttyUSB0'. Can be auto-discovered, setting the #vidpid variable if the vid:pid of the board is known
+    attr_accessor :port
+    # Baud rate of the connection. In the actual firmware version it should be 57600
+    attr_accessor :baud_rate
+    # attr_reader :sp
+
+    # Shortcut to set a '/dev/ttyUSBx' port. It also connects to that port
+    # 
+    # Params:
+    # +num+:: number of the ttyUSB port to be set
+    def setPort(num)
+        @port = '/dev/ttyUSB' + num.to_s
+        connect
+    end
+
+    # Connect to serial port specified by @port member
+    # 
+    # If @vidpid is set, it checks if that device is connected to a serial port and that port is chosen, regardless of the @port value.
+    # If block given it closes the connection at the end of the block
+    def connect
+    	if findPort()
+    		puts "Automatically selected port #{@port}"
+    	end
+        data_bits = 8
+        stop_bits = 1
+        parity = SerialPort::NONE
+        begin
+            @sp = SerialPort.new(@port, @baud_rate, data_bits, stop_bits, parity)
+            @spr = SerialPort.new(@port, @baud_rate, data_bits, stop_bits, parity)
+            @open = true
+
+        rescue
+            puts 'ERROR: Unable to find serial port ' + @port
+            @open = false
+        end
+
+        if block_given?
+            yield
+            self.disconnect
+            p "port closed"
+        end
+        @open
+    end
+
+    # Disconnect from serial port
+    def disconnect
+        if @open
+            @open = false
+            @sp.close
+            @spr.close
+        end
+    end
+
+    # Find the port to which the board is connected, looking for the specified @vidpid
+    def findPort
+    	begin
+    		if @vidpid
+		    	busNumber = Integer(`lsusb|grep #{@vidpid}`[4..6])
+		    	port = `ls /sys/bus/usb-serial/devices/ -ltrah |grep usb#{busNumber}`.chop
+		    	@port = '/dev/'+port.gsub(/ttyUSB[0-9]+/).first
+		    else
+		    	false
+		    end
+	    rescue
+	    	false
+	    end
+    end
+
+    # Send a single char
+    def sendC(char)
+        if (!@open)
+            connect()
+        end
+        @sp.putc char.chr
+    end
+
+    # Send a string of char
+    def sendS(string)
+        string.each_char do |char| 
+            sendC(char) 
+        end
+        # puts 'sent: ' + string
+        # puts 'waiting for return'
+        # rec = ''
+        # string.length.times {rec << @sp.getc}
+        # puts 'received: ' + rec
+        # match = (string.eql? rec.force_encoding('ASCII-8BIT'))
+        # puts 'equal: ' + match.to_s
+        # if !match
+        #     string.length.times.with_index do |i| 
+        #         puts string[i].ord + ' ' + rec[i].force_encoding('ASCII-8BIT').ord + ' ' + (string[i].encode('ASCII-8BIT') == rec[i].force_encoding('ASCII-8BIT')).to_s
+        #     end
+        # end
+
+    end
+
+    def startByte()
+        sendC(0x55)
+        sleep 0.1
+    end
+end

data/lib/motorcontrolboard/mcb_data.rb

@@ -0,0 +1,118 @@
+#!/usr/bin/env ruby
+require "yaml"
+
+class MotorControlBoard
+
+    # Internal representation of the board memory, as array of hashes
+    attr_reader :data
+
+    # Init the internal representation loading the given file.
+    # 
+    # Params:
+    # +initFile+:: the path to a yaml file containing the data structure to be used.
+    # The file should contain at least mask_name, position and type. 
+    # Also if value and valid are present they will be set to 0.
+    # Other fields are permitted although they will not be used:
+    # this functionality is not tested.
+    # 
+    # Data will be sorted by position
+	def initData(initFile)
+        @data = []
+        initData = YAML.load_file(initFile)
+        initData.each do |datum|
+            datum['value']=0
+            datum['valid']=0
+        end
+        @data = initData
+        sortData()
+    end 
+
+    # Return internal data in yaml format
+    def saveData
+        YAML.dump @data
+    end
+
+    # Dump internal data to yaml format and save to file
+    # Params:
+    # +path+:: path where to save the yaml data
+    def saveDataToFile(path)
+        File.open(path, 'w') do |f|
+            YAML.dump(@data, f)
+        end
+    end
+
+    # Return the index of the matching row diven some search params in hash format
+    # 
+    # Params:
+    # +needle+:: the hash to search. Search is performed by mask_name, position and type.
+    # 
+    # If the result contains one row only, its index is returned, otherwise nil is returned
+    def findData(needle)
+        result = @data
+        result = result.select { |a| a['mask_name']==needle['mask_name']} if needle['mask_name'] != nil
+        result = result.select { |a| a['position']==needle['position']} if needle['position'] != nil
+        result = result.select { |a| a['type']==needle['type']} if needle['type'] != nil
+        if result.length == 1        
+            @data.index result.first
+        else
+            nil
+        end
+    end
+
+    # Add data to internal representation
+    # 
+    # Params:
+    # +newData+:: data to add in array of hashes format 
+    # If the valid field is present, only rows with valid==1 will be taken into account.
+    # The matching row, selected with the #findData method, is updated with the new value and the valid bit is set
+    def addData(newData)
+        if newData[0]['valid'] != nil 
+            newData = newData.select{|newData| newData['valid']==1}
+        end
+        newData.each do |newValidDatum|
+            if (index = findData(newValidDatum))
+                @data[index]['value'] = newValidDatum['value']
+                @data[index]['valid'] = 1
+            else
+                puts 'Unable to find entry matching mask_name and position'
+                puts newValidDatum
+            end
+        end
+        sortData()
+    end
+    # Load data from a yaml representation
+    # 
+    # #addData is called so that everything is stored in the internal state
+    def loadData(dataToLoad)
+        addData(YAML.load(dataToLoad))
+    end
+
+    # Load a yaml file and saves to state with #addData
+    def loadDataFromFile(path)
+        addData(YAML.load_file(path))
+    end
+
+    # Set valid bit to 0 for each row
+    def dataResetValid
+        @data.each {|row| row['valid']=0}
+    end
+
+    # Set valid bit to 1 for each row
+    def dataSetValid
+        @data.each {|row| row['valid']=1}
+    end
+    
+    # Sort data by position
+    def sortData
+        @data = @data.sort_by { |row| row['position'] }
+    end
+
+    # Return the maximum value of the position field among all data
+    def getMaxPos
+        @data.max_by {|row| row['position']}['position']
+    end
+
+    def validDataLength
+        @data.select{|row| row['valid']==1}.inject(0){|sum, row| sum+lenByType(row['type'])}
+    end
+end

data/lib/motorcontrolboard/version.rb

@@ -0,0 +1,3 @@
+module Motorcontrolboard
+  VERSION = "0.0.1"
+end

data/motorcontrolboard.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/motorcontrolboard/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Francesco Sacchi"]
+  gem.email         = ["depsir@gmail.com"]
+  gem.description   = %q{Interface library for MotorControlBoard board}
+  gem.summary       = %q{}
+  gem.homepage      = "http://irawiki.disco.unimib.it/irawiki/index.php/INFIND2011/12_Motor_control_board"
+
+  gem.add_dependency('serialport', '>= 1.1.0')
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "motorcontrolboard"
+  gem.require_paths = ["lib"]
+  gem.version       = Motorcontrolboard::VERSION
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: motorcontrolboard
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Francesco Sacchi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: serialport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+description: Interface library for MotorControlBoard board
+email:
+- depsir@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/motorcontrolboard.rb
+- lib/motorcontrolboard/mcb_connection.rb
+- lib/motorcontrolboard/mcb_data.rb
+- lib/motorcontrolboard/version.rb
+- motorcontrolboard.gemspec
+homepage: http://irawiki.disco.unimib.it/irawiki/index.php/INFIND2011/12_Motor_control_board
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: ''
+test_files: []