uchip 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b8066c01dd4b77f8fb6b0985b22cabb9e18580dda3b92e9281fcf1296aa4c841
+  data.tar.gz: d38dd83a5f1217a81fac540ccfcd93d204edb05d3e104fd3293381e8435aa93c
+SHA512:
+  metadata.gz: 8319df9cd48dfa190eb94f4ba38e44652d69d6498cea40ee5f3fb5164f00244f77dc3727ec5a7ed3c8e16230b30d6291f93617191ed226a857eca24eab74f928
+  data.tar.gz: 539c3c4200f155f341d03d227f199586918eac71e768e24edb16c30d89581f9422e871336f314db03769c668495ba2c12fd1fb5b7b6b3d19bfcaa19750fdf6cc

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Aaron Patterson
+
+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,37 @@
+# UChip
+
+This is a library for controlling Microchip Chips.  Specifically the MCP2221 and
+MCP2221A.
+
+## Examples
+
+See the `examples` folder for more examples, but here is an example of using
+GP0 as a GPIO:
+
+
+```ruby
+require "uchip/mcp2221"
+
+def hit_bell pin
+  pin.value = 0
+  pin.value = 1
+  sleep 0.009
+  pin.value = 0
+end
+
+# Find the first connected chip
+chip = UChip::MCP2221.first || raise("Couldn't find the chip!")
+
+pin = chip.pin 0
+pin.output!
+
+loop do
+  hit_bell pin
+  sleep 2
+end
+```
+
+## Problems
+
+Right now this library doesn't support DAC or ADC, but it should be trivial to
+implement.

data/examples/gpio.rb

@@ -0,0 +1,15 @@
+require "uchip/mcp2221"
+
+# Find the first connected chip
+chip = UChip::MCP2221.first || raise("Couldn't find the chip!")
+
+pin = chip.pin 0
+pin.output!
+
+loop do
+  pin.value = 0
+  pin.value = 1
+  sleep 0.01
+  pin.value = 0
+  sleep 5
+end

data/examples/pcf8563.rb

@@ -0,0 +1,65 @@
+require "uchip/mcp2221"
+
+# Example to read from a PCF8563 real time clock
+# https://www.nxp.com/docs/en/data-sheet/PCF8563.pdf
+
+# These are just encoding and decoding routines for data on the RTC.
+
+def bcd2dec val
+  ((val >> 4) * 10) + (val & 0xF)
+end
+
+def dec2bcd val
+  ((val / 10) << 4) | (val % 10)
+end
+
+def time2bcd time
+  [ time.sec,
+    time.min,
+    time.hour,
+    time.day,
+    time.wday,
+    time.month,
+    time.year % 2000
+  ].map { |x| dec2bcd(x) }
+end
+
+def bcd2time bytes
+  seconds, minutes, hours, days, weekdays, c_months, years = bytes
+  Time.local bcd2dec(years) + 2000,
+             bcd2dec(c_months & 0xF) + 1, # don't care about century flag
+             bcd2dec(days & 0x3F),
+             bcd2dec(hours & 0x3F),
+             bcd2dec(minutes & 0x7F),
+             bcd2dec(seconds & 0x7F)
+end
+
+# Find the first connected chip
+chip = UChip::MCP2221.first || raise("Couldn't find the chip!")
+
+# The write address is 0xA2, read address is 0xA3, so 0x51 (0xA3 >> 1) is
+# where we'll request a proxy
+i2c  = chip.i2c_on 0x51
+
+# Reset the I2C engine. I've noticed sometimes the engine gets messed up, so
+# just start off by putting it in a known state.
+i2c.cancel
+
+# Write the current time to the RTC, starting at address 0x2
+i2c.write 0x2.chr + time2bcd(Time.now).pack("C7")
+
+loop do
+  # Write 0 bytes at address 0x2. This moves the pointer to the seconds location
+  # inside the RTC.
+  i2c.write 0x2.chr
+
+  # Read 7 bytes
+  buf = i2c.read 7
+  p bcd2time(buf.bytes)
+  sleep 1
+rescue UChip::MCP2221::EmptyResponse
+  # if the chip gets messed up, reset the i2c engine and retry
+  puts "oh no"
+  i2c.cancel
+  retry
+end

data/examples/set_gpio.rb

@@ -0,0 +1,17 @@
+require "uchip/mcp2221"
+
+# This example changes the "startup" GPIO settings of the chip.
+
+# Find the first connected chip
+chip = UChip::MCP2221.first || raise("Couldn't find the chip!")
+
+# Get the GPIO settings
+settings = chip.gp_settings
+
+settings.gp0_designation = 0   # We want to use this pin as a GPIO
+settings.gp0_output_value = 0  # Set the default value to 0
+settings.gp0_direction = 0     # Set the direction to output
+
+# Write the settings to the chip.  Next time the chip starts, the default
+# settings for GP0 will reflect these settings
+chip.gp_settings = settings

data/lib/uchip/mcp2221.rb

@@ -0,0 +1,392 @@
+require 'myhidapi'
+
+module UChip
+  class MCP2221
+    extend Enumerable
+
+    class Error < StandardError; end
+    class CommandNotSupported < Error; end
+    class Busy < Error; end
+    class EmptyResponse < Error; end
+    class GPIOConfigurationError < Error; end
+
+    def self.each
+      MyHIDAPI.enumerate(0x04d8, 0x00dd).each { |dev| yield new dev }
+    end
+
+    def initialize dev
+      @dev = dev
+      @handle = dev.open
+    end
+
+    def usb_manufacturer
+      handle.manufacturer
+    end
+
+    def usb_product
+      handle.product
+    end
+
+    def read_flash section
+      buf = pad [0xB0, section].pack('C*')
+      write_request buf
+      check_response read_response, 0xB0
+    end
+
+    def write_flash section, bytes
+      buf = pad ([0xB1, section] + bytes).pack('C*')
+      write_request buf
+      check_response read_response, 0xB1
+    end
+
+    class ChipSettings
+      def initialize bytes
+        @bytes = bytes
+      end
+
+      def inspect
+        to_s.sub(/>$/, " #{decode(@bytes).inspect}>")
+      end
+
+      BIT_FIELDS = []
+      def self.bool_attr_accessor name, index, offset
+        bit_attr_accesor name, index, offset, 0x1
+      end
+
+      def self.bit_attr_accesor name, index, offset, mask
+        BIT_FIELDS << name
+        define_method(name) do
+          (bytes[index] >> offset) & mask
+        end
+
+        define_method(:"#{name}=") do |v|
+          bytes[index] &= ~(mask << offset)
+          bytes[index] |= ((mask & v) << offset)
+        end
+      end
+
+      #                                             bytes[i], shift, mask
+      bool_attr_accessor :cdc,                             0,     7
+      bool_attr_accessor :led_uart_rx,                     0,     6
+      bool_attr_accessor :led_uart_tx,                     0,     5
+      bool_attr_accessor :led_i2c,                         0,     4
+      bool_attr_accessor :sspnd,                           0,     3
+      bool_attr_accessor :usbcfg,                          0,     2
+      bit_attr_accesor   :security,                        0,     0, 0x3
+      bit_attr_accesor   :clock_output_divider,            1,     0, 0x1F
+      bit_attr_accesor   :dac_reference_voltage,           2,     6, 0x3
+      bool_attr_accessor :dac_reference_option,            2,     5
+      bit_attr_accesor   :dac_power_up_value,              2,     0, 0x1F
+      bool_attr_accessor :interrupt_detection_negative,    3,     6
+      bool_attr_accessor :interrupt_detection_positive,    3,     5
+      bit_attr_accesor   :adc_reference_voltage,           3,     3, 0x3
+      bool_attr_accessor :dac_voltage,                     3,     2
+
+      def decode bytes
+        BIT_FIELDS.each_with_object({}) { |n, o| o[n] = send n }.merge({
+          :vid                          => bytes[4] + (bytes[5] << 8),
+          :pid                          => bytes[6] + (bytes[7] << 8),
+          :usb_power_attributes         => bytes[8],
+          :usb_requested_mas            => bytes[9],
+        })
+      end
+
+      attr_reader :bytes
+    end
+
+    module FlashData
+      CHIP_SETTINGS         = 0x00
+      GP_SETTINGS           = 0x01
+      MANUFACTURER          = 0x02
+      PRODUCT               = 0x03
+      SERIAL_NUMBER         = 0x04
+      FACTORY_SERIAL_NUMBER = 0x05
+    end
+
+    def chip_settings
+      buf = read_flash(FlashData::CHIP_SETTINGS).bytes
+        .drop(2) # response header
+        .drop(2) # not care (according to data sheet)
+        .first(10)
+      ChipSettings.new buf
+    end
+
+    def chip_settings= settings
+      write_flash FlashData::CHIP_SETTINGS, settings.bytes
+    end
+
+    def gp_settings= settings
+      write_flash FlashData::GP_SETTINGS, settings.bytes
+    end
+
+    class GPSettings
+      attr_reader :bytes
+
+      def initialize bytes
+        @bytes = bytes
+      end
+
+      def inspect
+        to_s.sub(/>$/, " #{decode(@bytes).inspect}>")
+      end
+
+      def output_value_at i
+        (bytes[i] >> 4) & 0x1
+      end
+
+      def set_output_value_at i, v
+        bytes[i] &= ~(1 << 4)
+        bytes[i] |= (1 & v) << 4
+      end
+
+      def direction_at i
+        (bytes[i] >> 3) & 0x1
+      end
+
+      def set_direction_at i, v
+        bytes[i] &= ~(1 << 3)
+        bytes[i] |= (1 & v) << 3
+      end
+
+      def designation_at i
+        (bytes[i] >> 0) & 0x3
+      end
+
+      def set_designation_at i, v
+        bytes[i] &= ~(0x3 << 0)
+        bytes[i] |= (0x3 & v) << 0
+      end
+
+      4.times { |i|
+        [:output_value, :direction, :designation].each { |n|
+          define_method("gp#{i}_#{n}") { send("#{n}_at", i) }
+          define_method("gp#{i}_#{n}=") { |v| send("set_#{n}_at", i, v) }
+        }
+      }
+
+      def decode bytes
+        4.times.each_with_object({}) { |i, o|
+          o[:"gp#{i}_output_value"] = output_value_at(i)
+          o[:"gp#{i}_direction"]    = direction_at(i)
+          o[:"gp#{i}_designation"]  = designation_at(i)
+        }
+      end
+    end
+
+    def gp_settings
+      buf = read_flash(FlashData::GP_SETTINGS).bytes
+        .drop(2) # response header
+        .drop(2) # structure length, don't care
+        .first(4)
+      GPSettings.new buf
+    end
+
+    def manufacturer
+      byte_count, _, *rest = read_flash(FlashData::MANUFACTURER).bytes
+        .drop(2) # response header
+      rest[0, byte_count - 2].pack('U*')
+    end
+
+    def product
+      byte_count, _, *rest = read_flash(FlashData::PRODUCT).bytes
+        .drop(2) # response header
+      rest[0, byte_count - 2].pack('U*')
+    end
+
+    def serial_number
+      byte_count, _, *rest = read_flash(FlashData::SERIAL_NUMBER).bytes
+        .drop(2) # response header
+      rest[0, byte_count - 2].pack('U*')
+    end
+
+    def factory_serial_number
+      byte_count, _, *rest = read_flash(FlashData::FACTORY_SERIAL_NUMBER).bytes
+        .drop(2) # response header
+      rest[0, byte_count - 2].pack('U*')
+    end
+
+    def reset
+      buf = pad ([0x70, 0xAB, 0xCD, 0xEF]).pack('C*')
+      write_request buf
+    end
+
+    def i2c_write address, bytes
+      send_i2c_command 0x90, address, bytes.bytesize, bytes
+    end
+
+    def i2c_write_no_stop address, bytes
+      send_i2c_command 0x94, address, bytes.bytesize, bytes
+    end
+
+    def i2c_read_start address, length
+      send_i2c_command 0x91, address, length, "".b
+    end
+
+    def i2c_read_repeated_start address, length
+      send_i2c_command 0x93, address, length, "".b
+    end
+
+    def i2c_read
+      buf = pad 0x40.chr
+      write_request buf
+      buf = check_response read_response, 0x40
+      len = buf[3].ord
+      buf[4, len]
+    end
+
+    def i2c_cancel
+      buf = pad [0x10, 0x0, 0x10].pack('C*')
+      write_request buf
+      check_response read_response, 0x10
+    end
+
+    class I2CProxy
+      def initialize address, handler
+        @read_address  = (address << 1) | 1
+        @write_address = address << 1
+        @handler       = handler
+      end
+
+      def cancel; @handler.i2c_cancel; end
+
+      def write buf
+        @handler.i2c_write @write_address, buf
+      end
+
+      def read size
+        @handler.i2c_read_start @read_address, 8
+        @handler.i2c_read
+      end
+    end
+
+    def i2c_on address
+      I2CProxy.new address, self
+    end
+
+    class Pin < Struct.new :chip, :number
+      def output!
+        chip.configure_gpio number, :output
+      end
+
+      def value
+        chip.gpio_value number
+      end
+
+      def value= v
+        chip.set_gpio_value number, v
+      end
+    end
+
+    def pin number
+      Pin.new self, number
+    end
+
+    def gpio_value pin
+      cmd = 0x51
+      write_request pad cmd.chr
+      buf = check_response read_response, cmd
+      buf[2 + (pin * 2), 1].ord
+    end
+
+    def configure_gpio pin, mode, default = 0
+      settings = default << 4
+      case mode
+      when :input then mode = (1 << 3)
+      when :output then mode = 0
+      end
+      settings |= mode
+
+      # Read the current pin settings
+      bytes = sram.gp_settings.bytes
+      bytes[pin] = settings
+
+      cmd = 0x60
+      buf = pad ([cmd, 0x0,
+                 0x0, # clock output divider
+                 0x0, # DAC voltage reference
+                 0x0, # DAC output value
+                 0x0, # ADC voltage reference
+                 0x0, # interrupt detection
+                 (1 << 7), # Alter GPIO config
+      ] + bytes).pack('C*')
+      write_request buf
+      check_response read_response, cmd
+    end
+
+    def set_gpio_value pin, value
+      cmd = 0x50
+      pin_values = [
+        0x0, # Alter output
+        0x0, # Output Value
+        0x0, # Alter direction
+        0x0  # Direction value
+      ] * 4
+      pin_values[(pin * 4)]     = 0x1
+      pin_values[(pin * 4) + 1] = (value & 0x1)
+      buf = pad ([cmd, 0x0] + pin_values).pack('C*')
+      write_request buf
+      val = check_response(read_response, cmd)[3 + (pin * 2)].ord
+      if val == 0xEE
+        raise GPIOConfigurationError, "Pin #{pin} not configured as GPIO"
+      else
+        val
+      end
+    end
+
+    class SRAM
+      attr_reader :chip_settings, :gp_settings, :password
+
+      def initialize chip_settings, password, gp_settings
+        @chip_settings = chip_settings
+        @password      = password
+        @gp_settings   = gp_settings
+      end
+    end
+
+    def sram
+      cmd = 0x61
+      buf = pad cmd.chr
+      write_request buf
+      buf = check_response read_response, cmd
+      cs = ChipSettings.new buf[4, 10].bytes
+      pw = buf[14, 8]
+      gp = GPSettings.new buf[22, 4].bytes
+      SRAM.new cs, pw, gp
+    end
+
+    private
+
+    def send_i2c_command cmd, address, length, bytes
+      buf = pad [cmd, length & 0xFF, (length >> 16) & 0xFF, address].pack('C*') + bytes
+      write_request buf
+      check_response read_response, cmd
+    end
+
+    def pad buf
+      buf << ("\x0".b * (64 - buf.bytesize))
+    end
+
+    def check_response buf, type
+      raise Error, buf unless buf[0].ord == type
+      raise Busy, buf unless buf[1].ord == 0
+      buf
+    end
+
+    def read_response
+      # 300 ms timeout
+      #return @handle.read 64
+      @handle.read_timeout(64, 30) || raise(EmptyResponse)
+    end
+
+    def write_request buf
+      retries = 0
+      loop do
+        break if handle.write buf
+        retries += 1
+        raise "Too many retries" if retries > 3
+      end
+    end
+
+    attr_reader :handle
+  end
+end

data/uchip.gemspec

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |s|
+  s.platform    = Gem::Platform::RUBY
+  s.name        = "uchip"
+  s.version     = "1.0.0"
+  s.summary     = "Gem for controlling MCP2221a"
+  s.description = "This is a gem for controlling the MCP2221a chip over USB"
+
+  s.license = "MIT"
+
+  s.files = `git ls-files`.split("\n")
+  s.require_path = 'lib'
+
+  s.author   = "Aaron Patterson"
+  s.email    = "tenderlove@ruby-lang.org"
+  s.homepage = "https://github.com/tenderlove/uchip"
+
+  s.add_dependency "myhidapi", "~> 1.0"
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: uchip
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Aaron Patterson
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-09-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: myhidapi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: This is a gem for controlling the MCP2221a chip over USB
+email: tenderlove@ruby-lang.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- examples/gpio.rb
+- examples/pcf8563.rb
+- examples/set_gpio.rb
+- lib/uchip/mcp2221.rb
+- uchip.gemspec
+homepage: https://github.com/tenderlove/uchip
+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: []
+rubygems_version: 3.2.0.rc.1
+signing_key:
+specification_version: 4
+summary: Gem for controlling MCP2221a
+test_files: []