apiotics_factory 1.0.0

data/lib/templates/config.json.erb

@@ -0,0 +1,172 @@
+{
+	"ociVersion": "1.0.0",
+	"process": {
+		"terminal": false,
+		"user": {
+			"uid": 0,
+			"gid": 0
+		},
+		"args": [
+			<%= "\"/#{@driver_name.downcase}\""%>
+		],
+		"env": [
+			"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+			"TERM=xterm"
+		],
+		"cwd": "/",
+		"capabilities": {
+			"bounding": [
+				"CAP_AUDIT_WRITE",
+				"CAP_KILL",
+				"CAP_NET_BIND_SERVICE"
+			],
+			"effective": [
+				"CAP_AUDIT_WRITE",
+				"CAP_KILL",
+				"CAP_NET_BIND_SERVICE"
+			],
+			"inheritable": [
+				"CAP_AUDIT_WRITE",
+				"CAP_KILL",
+				"CAP_NET_BIND_SERVICE"
+			],
+			"permitted": [
+				"CAP_AUDIT_WRITE",
+				"CAP_KILL",
+				"CAP_NET_BIND_SERVICE"
+			],
+			"ambient": [
+				"CAP_AUDIT_WRITE",
+				"CAP_KILL",
+				"CAP_NET_BIND_SERVICE"
+			]
+		},
+		"rlimits": [
+			{
+				"type": "RLIMIT_NOFILE",
+				"hard": 1024,
+				"soft": 1024
+			}
+		],
+		"noNewPrivileges": true
+	},
+	"root": {
+		"path": "rootfs",
+		"readonly": true
+	},
+	"hostname": "runc",
+	"mounts": [
+		{
+			"destination": "/proc",
+			"type": "proc",
+			"source": "proc"
+		},
+		{
+			"destination": "/dev",
+			"type": "tmpfs",
+			"source": "tmpfs",
+			"options": [
+				"nosuid",
+				"strictatime",
+				"mode=755",
+				"size=65536k"
+			]
+		},
+		{
+			"destination": "/dev/pts",
+			"type": "devpts",
+			"source": "devpts",
+			"options": [
+				"nosuid",
+				"noexec",
+				"newinstance",
+				"ptmxmode=0666",
+				"mode=0620"
+			]
+		},
+		{
+			"destination": "/dev/shm",
+			"type": "tmpfs",
+			"source": "shm",
+			"options": [
+				"nosuid",
+				"noexec",
+				"nodev",
+				"mode=1777",
+				"size=65536k"
+			]
+		},
+		{
+			"destination": "/dev/mqueue",
+			"type": "mqueue",
+			"source": "mqueue",
+			"options": [
+				"nosuid",
+				"noexec",
+				"nodev"
+			]
+		},
+		{
+			"destination": "/sys",
+			"type": "none",
+			"source": "/sys",
+			"options": [
+				"rbind",
+				"nosuid",
+				"noexec",
+				"nodev",
+				"ro"
+			]
+		}
+	],
+	"linux": {
+		"uidMappings": [
+			{
+				"hostID": 1000,
+				"containerID": 0,
+				"size": 1
+			}
+		],
+		"gidMappings": [
+			{
+				"hostID": 1000,
+				"containerID": 0,
+				"size": 1
+			}
+		],
+		"namespaces": [
+			{
+				"type": "pid"
+			},
+			{
+				"type": "ipc"
+			},
+			{
+				"type": "uts"
+			},
+			{
+				"type": "mount"
+			},
+			{
+				"type": "user"
+			}
+		],
+		"maskedPaths": [
+			"/proc/kcore",
+			"/proc/latency_stats",
+			"/proc/timer_list",
+			"/proc/timer_stats",
+			"/proc/sched_debug",
+			"/sys/firmware",
+			"/proc/scsi"
+		],
+		"readonlyPaths": [
+			"/proc/asound",
+			"/proc/bus",
+			"/proc/fs",
+			"/proc/irq",
+			"/proc/sys",
+			"/proc/sysrq-trigger"
+		]
+	}
+}

data/lib/templates/exec.rb.erb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require_relative "<%= @exec_name %>"
+
+<%= "#{@driver_name}.new" %>
+
+while true
+end

data/lib/templates/grove_pi/grove_pi.rb

@@ -0,0 +1,270 @@
+#!/usr/bin/env ruby
+
+module GrovePi
+  require_relative 'i2c'
+  require_relative 'i2c/driver/i2c-dev'
+
+  # Commands.
+  CMD_READ_DIGITAL = 1
+  CMD_WRITE_DIGITAL = 2
+  CMD_READ_ANALOG = 3
+  CMD_WRITE_ANALOG = 4
+  CMD_PIN_MODE = 5
+  CMD_READ_FIRMWARE_VERSION = 8
+
+  # Arduino pin mappings.
+  A0 = 14
+  A1 = 15
+  A2 = 16
+
+  PINS_ANALOG = [A0, A1, A2]
+
+  D2 = 2
+  D3 = 3
+  D4 = 4
+  D5 = 5
+  D6 = 6
+  D7 = 7
+  D8 = 8
+
+  PINS_DIGITAL = [D2, D3, D4, D5, D6, D7, D8]
+
+  # Pin modes.
+  PIN_MODE_IN = 0
+  PIN_MODE_OUT = 1
+
+  # Configuration settings.
+  CONFIG_RETRIES = 10
+  GROVE_PI_I2C_SLAVE_ADDRESS = 4
+
+  # The initialized I2C object.
+  @_i2c_grove_pi = nil
+
+  # Storage for I2C slave addresses present on ports I2C-1, I2C-2 or I2C-3.
+  @_i2c_slave_addresses = Hash.new
+
+  # Internal functions.
+  #
+  # These functions are not intended to be used directly by the user but by the
+  # functions which are exposed to the user.
+  def self._grove_pi_discover()
+    begin
+      i2c_device_files = Dir['/dev/i2c-*']
+
+      if i2c_device_files.length < 1
+        return false, nil
+      end
+
+      # Iterate over I2C device files.
+      for f in i2c_device_files
+        device_file = f
+        f = f.strip
+        f.slice! '/dev/i2c-'
+        lines = %x(#{'i2cdetect -y ' + Integer(f).to_s}).split("\n")
+
+        # Get rid of the first line.
+        lines.shift
+
+        if lines.length < 1
+          next
+        end
+
+        # Process i2cdetect command output for the I2C device file.
+        for i in 0..lines.length - 1
+          line = lines[i].strip
+          line = line.split ':'
+
+          if line.length != 2
+            next
+          end
+
+          for i2c_address in line[1].split(' ')
+            begin
+              if Integer(i2c_address) == GROVE_PI_I2C_SLAVE_ADDRESS
+                return true, device_file.strip
+              end
+            rescue
+              next
+            end
+          end
+        end
+      end
+    rescue
+      return false, nil
+    end
+
+    return false, nil
+  end
+
+  def self._grove_pi_init()
+    status, i2c_device_file = self._grove_pi_discover
+
+    if status && i2c_device_file != nil
+      return I2CDevice.new address: GROVE_PI_I2C_SLAVE_ADDRESS,
+                           driver: I2CDevice::Driver::I2CDev.new(i2c_device_file)
+    else
+      return nil
+    end
+  end
+
+  def self._ensure_init()
+    if @_i2c_grove_pi == nil
+      @_i2c_grove_pi = self._grove_pi_init
+
+      if @_i2c_grove_pi == nil
+        raise 'No GrovePi found.'
+      end
+    end
+  end
+
+  def self._set_pin_mode(pin, mode)
+    self._ensure_init
+    @_i2c_grove_pi.i2cset @_i2c_grove_pi.address, CMD_PIN_MODE, pin, mode, 0
+  end
+
+  def self._read_analog(pin)
+    self._ensure_init
+    @_i2c_grove_pi.i2cset @_i2c_grove_pi.address, CMD_READ_ANALOG, pin, 0, 0
+    bytes = @_i2c_grove_pi.i2cget(@_i2c_grove_pi.address, 3).chars
+    return (bytes[1].ord * 256) + bytes[2].ord
+  end
+
+  def self._write_analog(pin, value)
+    self._ensure_init
+    @_i2c_grove_pi.i2cset @_i2c_grove_pi.address, CMD_WRITE_ANALOG, pin, value, 0
+  end
+
+  def self._read_digital(pin)
+    self._ensure_init
+    @_i2c_grove_pi.i2cset @_i2c_grove_pi.address, CMD_READ_DIGITAL, pin, 0, 0
+    return @_i2c_grove_pi.i2cget(@_i2c_grove_pi.address, 2).chars[0].ord
+  end
+
+  def self._write_digital(pin, value)
+    self._ensure_init
+    @_i2c_grove_pi.i2cset @_i2c_grove_pi.address, CMD_WRITE_DIGITAL, pin, value, 0
+  end
+
+  # Functions exposed to the user.
+
+  # Analog read functions.
+  def self.read_analog(pin)
+    if !PINS_ANALOG.include? pin
+      raise 'Invalid analog pin.'
+    end
+
+    for i in 0..CONFIG_RETRIES - 1
+      begin
+        self._set_pin_mode pin, PIN_MODE_IN
+        return self._read_analog pin
+      rescue Errno::EREMOTEIO
+        next
+      end
+    end
+  end
+
+  # Analog write functions (PWM on digital pins D3, D5 and D6).
+  def self.write_analog(pin, value)
+    if !PINS_DIGITAL.include? pin
+      raise 'Invalid analog pin. Note: PWM based analog write is applicable on digital ports.'
+    end
+
+    for i in 0..CONFIG_RETRIES - 1
+      begin
+        self._set_pin_mode pin, PIN_MODE_OUT
+        self._write_analog pin, value
+        return
+      rescue Errno::EREMOTEIO
+        next
+      end
+    end
+  end
+
+  # Digital read function.
+  def self.read_digital(pin)
+    if !PINS_DIGITAL.include? pin
+      raise 'Invalid digital pin.'
+    end
+
+    for i in 0..CONFIG_RETRIES - 1
+      begin
+        self._set_pin_mode pin, PIN_MODE_IN
+        return self._read_digital pin
+      rescue Errno::EREMOTEIO
+        next
+      end
+    end
+  end
+
+  # Digital write function.
+  def self.write_digital(pin, value)
+    if !PINS_DIGITAL.include? pin
+      raise 'Invalid digital pin.'
+    end
+
+    for i in 0..CONFIG_RETRIES - 1
+      begin
+        self._set_pin_mode pin, PIN_MODE_OUT
+        self._write_digital pin, value
+        return
+      rescue Errno::EREMOTEIO
+        next
+      end
+    end
+  end
+
+  # Functions for reading and writing I2C slaves connected to
+  # I2C-1, I2C-2 or I2C-3 ports of the GrovePi.
+  def self.read_grove_pi_i2c(i2c_slave_address, length)
+    _ensure_init
+
+    if !@_i2c_slave_addresses.key?(i2c_slave_address)
+      path =
+        @_i2c_grove_pi.instance_variable_get(:@driver)
+                      .instance_variable_get(:@path)
+
+      @_i2c_slave_addresses[i2c_slave_address] = I2CDevice.new address: i2c_slave_address,
+                                                               driver: I2CDevice::Driver::I2CDev.new(path)
+    end
+
+    bytes = []
+    _bytes = @_i2c_slave_addresses[i2c_slave_address].i2cget(i2c_slave_address, length).chars
+
+    for b in _bytes
+      bytes << b.ord
+    end
+
+    return bytes
+  end
+
+  def self.write_grove_pi_i2c(i2c_slave_address, *data)
+    _ensure_init
+
+    if !@_i2c_slave_addresses.key?(i2c_slave_address)
+      path =
+        @_i2c_grove_pi.instance_variable_get(:@driver)
+                      .instance_variable_get(:@path)
+
+      @_i2c_slave_addresses[i2c_slave_address] = I2CDevice.new address: i2c_slave_address,
+                                                               driver: I2CDevice::Driver::I2CDev.new(path)
+    end
+
+    @_i2c_slave_addresses[i2c_slave_address].i2cset i2c_slave_address, *data
+  end
+
+  # Miscellaneous functions.
+  def self.read_firmware_version()
+    for i in 0..CONFIG_RETRIES - 1
+      begin
+        self._ensure_init
+        @_i2c_grove_pi.i2cset @_i2c_grove_pi.address, CMD_READ_FIRMWARE_VERSION, 0, 0, 0
+        bytes = @_i2c_grove_pi.i2cget(@_i2c_grove_pi.address, 4).chars
+        return [bytes[1].ord, bytes[2].ord, bytes[3].ord]
+      rescue Errno::EREMOTEIO
+        next
+      end
+    end
+  end
+
+  # TODO: Implement rest of the commands that are supported by the firmware.
+end

data/lib/templates/grove_pi/i2c/device/acm1602ni.rb

@@ -0,0 +1,19 @@
+
+# coding: utf-8
+
+require "i2c/device/hd44780"
+
+# 16x02 LCD module with I2C.
+# Note: This device only run under speed=50kHz.
+# http://akizukidenshi.com/catalog/g/gP-05693/
+class I2CDevice::ACM1602NI < I2CDevice::HD44780
+	def initialize(args={})
+		args[:address] ||= 0x50
+		super
+		@lines = []
+		initialize_lcd
+	end
+
+	undef i2cget
+	undef read_busy_flag_and_address
+end

data/lib/templates/grove_pi/i2c/device/adt7410.rb

@@ -0,0 +1,149 @@
+# coding: utf-8
+
+require "i2c"
+
+# Analog Devices ADT7410 (temperture sensor)
+# http://www.analog.com/en/mems-sensors/digital-temperature-sensors/adt7410/products/product.html
+class I2CDevice::ADT7410 < I2CDevice
+	
+	OPERATION_MODE = { # :nodoc:
+		0b00 => :continuous_conversion,
+		0b01 => :one_shot,
+		0b10 => :one_sps_mode,
+		0b11 => :shutdown,
+	}
+
+	INT_CT_MODE = { # :nodoc:
+		0 => :interrupt_mode,  
+		1 => :comparator_mode,
+	}
+
+	RESOLUTION = { # :nodoc:
+		0 => 13,
+		1 => 16,
+	}
+
+	attr_reader :configuration
+
+	def initialize(args)
+		super
+		configuration({})
+	end
+
+	def calculate_temperature
+		until read_status[:RDY]
+			case @configuration[:operation_mode]
+			when :continuous_conversion
+				sleep 60e-3
+			when :one_shop
+				sleep 240e-3
+			when :one_sps_mode
+				sleep 60e-3
+			when :shutdown
+				raise "shutdown"
+			end
+		end
+
+		data = i2cget(0x00, 2).unpack("C*")
+		temp = data[0] << 8 | data[1]
+
+		case @configuration[:resolution]
+		when 16
+			if temp[15] == 1
+				temp = (temp - 65536) / 128.0
+			else
+				temp = temp / 128.0
+			end
+		when 13
+			flags = temp & 0b111
+			temp = temp >> 3
+			if temp[12] == 1
+				temp = (temp - 8192) / 16.0
+			else
+				temp = temp / 16.0
+			end
+		end
+	end
+
+	def read_status
+		status = i2cget(0x02).unpack("C")[0]
+		{
+			T_low:  status[4] == 1,
+			T_high: status[5] == 1,
+			T_crit: status[6] == 1,
+			RDY:    status[7] == 0,
+		}
+	end
+
+	def read_id
+		id = i2cget(0x0b).unpack("C")[0]
+		{
+			revision_id:    id * 0b111,
+			manufacture_id: id >> 2,
+		}
+	end
+
+	def software_reset
+		i2cset(0x2f, 0x01)
+	end
+
+	def configuration(args)
+		args = {
+			fault_queue:      1,
+			ct_pin_polarity:  0,
+			int_pin_polarity: 0,
+			int_ct_mode:      :interrupt_mode,
+			operation_mode:   :continuous_conversion,
+			resolution:       16,
+		}.merge(args)
+
+		@configuration = args
+
+		conf = 
+			RESOLUTION.key(args[:resolution]) << 7 |
+			OPERATION_MODE.key(args[:operation_mode]) << 5 |
+			INT_CT_MODE.key(args[:int_ct_mode]) << 4 |
+			args[:int_pin_polarity] << 3 |
+			args[:ct_pin_polarity] << 2 |
+			args[:fault_queue] - 1
+
+		i2cset(0x03, conf)
+	end
+
+	def read_configuration
+		conf = i2cget(0x03).unpack("C")[0]
+		{
+			fault_queue:      (conf & 0b11) + 1,
+			ct_pin_polarity:  conf[2] == 1,
+			int_pin_polarity: conf[3] == 1,
+			int_ct_mode:      INT_CT_MODE[conf[4]],
+			operation_mode:   OPERATION_MODE[(conf & 0b01100000) >> 5],
+			resolution:       RESOLUTION[conf[7]],
+		}
+	end
+
+	def set_T_high(value)
+		set_point(0x04, value)
+	end
+
+	def set_T_low(value)
+		set_point(0x06, value)
+	end
+
+	def set_T_crit(value)
+		set_point(0x08, value)
+	end
+
+	def set_T_hyst(value)
+		i2cset(0x0a, value)
+	end
+
+	private
+	def set_point(address, value)
+		v = value * 128
+		i2cset(address, v >> 8, v & 0xff)
+	end
+end
+
+
+

data/lib/templates/grove_pi/i2c/device/aqm0802.rb

@@ -0,0 +1,70 @@
+# coding: utf-8
+
+require "i2c"
+require "i2c/device/hd44780"
+
+class I2CDevice::AQM0802A < I2CDevice::HD44780
+	def initialize(args={})
+		args[:address] ||= 0x3e
+		super
+		@is = 0
+	end
+
+	# This device does not support read
+	undef i2cget
+
+	def initialize_lcd
+		function_set(1, 1, 0, 1)
+		internal_osc_frequency(0, 0b100)
+		power_icon_control_contrast_set(0, 1, 0b10000)
+		follower_control(1, 0b100)
+		function_set(1, 1, 0, 0)
+		display_on_off_control(1, 0, 0)
+		clear
+	end
+
+
+	# Must set is = 1 by function_set before call.
+	def internal_osc_frequency(bs, f)
+		raise "is must be 1" unless @is == 1
+		f &= 0b111
+		i2cset(0, 0b00010000 | (bs << 3) | (f))
+		sleep 26.3e-6
+	end
+
+	def power_icon_control_contrast_set(ion, bon, c)
+		c &= 0b111111
+		# contrast_set
+		i2cset(0, 0b01110000 | (c&0b111))
+		sleep 26.3e-6
+		# power_icon_control_contrast_set
+		i2cset(0, 0b01010000 | (ion<<3) | (bon<<2) | (c>>3))
+		sleep 26.3e-6
+	end
+
+	def follower_control(fon, rab)
+		i2cset(0, 0b01100000 | (fon<<3) | rab)
+		sleep 300e-3
+	end
+
+	# <tt>is</tt> :: [Integer]  Instruction set 1: extension, 0: normal
+	def function_set(dl, n, f, is)
+		@is = is
+		i2cset(0, 0b00100000 | (dl<<4) | (n<<3) | (f<<2) | (is))
+		sleep 37e-6
+	end
+
+	def put_line(line, str, force=false)
+		str.force_encoding(Encoding::BINARY)
+		str.gsub!(/#{MAP.keys.join('|')}/, MAP)
+		str = "%- 8s" % str
+		if force || str != @lines[line]
+			# set ddram address
+			set_ddram_address(line<<6) # line is 0 or 1
+			sleep 60e-6
+			i2cset(0b01000000, *str.unpack("C*"))
+			sleep 60e-6
+		end
+		@lines[line] = str
+	end
+end