def open(self, port_index=0):
"Connect to bus adapter"
_i2c_bus.open(self)
# TODO, need to support multiple instances of bus_aadvark_i2c with single adapter.
# This way it is possible to connect multiple i2c slaves to same bus.
self._handle = aa.aa_open(port_index)
if self._handle < 0:
if (self._handle == -7):
raise BusException(
'bus_aadvark_i2c.open failed with error code %d (Aardvark disconnected)'
% self._handle)
else:
raise BusException(
'bus_aadvark_i2c.open failed with error code %d' %
self._handle)
# IO direction now all input, do this before AA_CONFIG_GPIO_I2C
aa.aa_gpio_direction(
self._handle,
int(evkit_config.get('aardvark_i2c', 'aa_gpio_direction'), 16))
## select pullup or floating
#aa.aa_gpio_pullup(self._handle, aa.AA_GPIO_SCK | aa.AA_GPIO_MOSI) # pullup for gpio lines
aa.aa_gpio_pullup(
self._handle,
int(evkit_config.get('aardvark_i2c', 'aa_gpio_pullup'), 16))
#todo slave address selection GPIO to output
# Ensure that the I2C subsystem is enabled
aa.aa_configure(self._handle, aa.AA_CONFIG_GPIO_I2C)
# Enable the I2C bus pullup resistors (2.2k resistors).
# This command is only effective on v2.0 hardware or greater.
# The pullup resistors on the v1.02 hardware are enabled by default.
aa.aa_i2c_pullup(
self._handle,
self.aa_i2c_pullup[evkit_config.get('aardvark_i2c',
'aa_i2c_pullup')])
# Power the board using the Aardvark adapter's power supply.
# This command is only effective on v2.0 hardware or greater.
# The power pins on the v1.02 hardware are not enabled by default.
aa.aa_target_power(
self._handle,
self.aa_target_power[evkit_config.get('aardvark_i2c',
'aa_target_power')])
# Set the bitrate
requested = self._bitrate
self._bitrate = aa.aa_i2c_bitrate(self._handle, self._bitrate)
if requested != self._bitrate:
logger.warning('Bitrate set to %d kHz. Wanted to set %d kHz' %
(self._bitrate, requested))
def open(self, port_index=0):
assert evkit_config.get(
'spi', 'ss_polarity') in ['ACTIVE_LOW', 'ACTIVE_HIGH']
assert evkit_config.get('spi', 'bitorder') in ['MSB', 'LSB']
_spi_bus.open(self)
self._handle = aa.aa_open(port_index)
if self._handle < 0:
if (self._handle == -7):
raise BusException(
'bus_aadvark_spi.open failed with error code %d (Aardvark disconnected)'
% self._handle)
else:
raise BusException(
'bus_aadvark_spi.open failed with error code %d' %
self._handle)
aa.aa_gpio_direction(self._handle,
int(
evkit_config.get('aardvark_spi',
'aa_gpio_direction'),
16)) # IO direction
## select pullup or floating
#aa.aa_gpio_pullup(self._handle, aa.AA_GPIO_SCL | aa.AA_GPIO_SDA) # pullup
aa.aa_gpio_pullup(
self._handle,
int(evkit_config.get('aardvark_spi', 'aa_gpio_pullup'), 16))
aa.aa_configure(self._handle,
aa.AA_CONFIG_SPI_GPIO) # SPI subsystem is enabled
aa.aa_target_power(
self._handle,
self._aa_target_power[evkit_config.get('aardvark_spi',
'aa_target_power')])
aa.aa_spi_configure(
self._handle, self._cpol, self._cpha,
self._bitorder[evkit_config.get('spi', 'bitorder')])
aa.aa_spi_master_ss_polarity(
self._handle,
self._ss_polarity[evkit_config.get('spi', 'ss_polarity')])
requested = self._bitrate
self._bitrate = aa.aa_spi_bitrate(self._handle,
self._bitrate) # Set the bitrate
if requested != self._bitrate:
logger.warning(
"Warning Bitrate set to %d kHz. Wanted to set %d kHz" %
(self._bitrate, requested))
def __init__(self, aadvark_index=None):
_i2c_bus.__init__(self)
self._handle = None
if not smbus_found:
raise BusException(
'Please install smbus python module: sudo apt-get install python-smbus'
)
if gpio_found:
self._has_gpio = True
self.bus_gpio_list = [1, 2]
self._gpio_pin_index = [
evkit_config.getint('linux_gpio', 'pin1_index'),
evkit_config.getint('linux_gpio', 'pin2_index')
]
# TODO synch logic with bus_serial
gpio.setup(self._gpio_pin_index[0], gpio.IN)
gpio.setup(self._gpio_pin_index[1], gpio.IN)
if self.check_are_we_on_raspi(): #disable SPI if on raspi
logger.debug(
'This is Raspberry Pi: Disabling SPI bus so we can use I2C'
)
gpio.setup(10, gpio.IN) #MOSI
gpio.setup(9, gpio.IN) #MISO
gpio.setup(11, gpio.IN) #SCLK
else:
logger.debug('This is not Raspberry Pi.')
def get_com_port(self):
# TODO consider using : from serial.tools import list_ports_windows
if self.config_section == 'serial_com_kx_iot':
result = self.check_com_port("SELECT * FROM Win32_PnPEntity WHERE Description = 'USB Serial Port' AND NOT PNPDeviceID LIKE 'ROOT\\%'")
elif self.config_section.startswith('serial_com_nrf51dk'):
result = self.check_com_port("SELECT * FROM Win32_PnPEntity WHERE Description = 'JLink CDC UART Port' AND NOT PNPDeviceID LIKE 'ROOT\\%'")
if result == None:
result = self.check_com_port("SELECT * FROM Win32_PnPEntity WHERE Description = 'USB Serial Device' AND NOT PNPDeviceID LIKE 'ROOT\\%'")
if result == None:
result = self.check_com_port("SELECT * FROM Win32_PnPEntity WHERE Description = 'mbed Serial Port' AND NOT PNPDeviceID LIKE 'ROOT\\%'")
elif self.config_section == "serial_com_cypress":
for desc in ["Cypress USB UART", "USB Serial Device"]:
result = self.check_com_port("SELECT * FROM Win32_PnPEntity WHERE Description = '%s' AND NOT PNPDeviceID LIKE 'ROOT\\%%'" % desc)
if result is not None:
break
else: #Arduino
result = self.check_com_port("SELECT * FROM Win32_PnPEntity WHERE Description = 'Arduino Uno' AND NOT PNPDeviceID LIKE 'ROOT\\%'")
if result == None:
result = self.check_com_port("SELECT * FROM Win32_PnPEntity WHERE Description = 'USB Serial Device' AND NOT PNPDeviceID LIKE 'ROOT\\%'")
if result == None:
raise BusException('Automatic search found no devices')
else:
logger.info('Automatic port choice: %s', result)
return result
def write_register(self, sensor, register, data):
if register is None: # Pure SPI command write without address
data_out = array('B', [data])
length = 1 ## FIXME len(data)
elif isinstance(data, int): # normal address set and data write
length = 2 ## FIXME multiwrite
data_out = array('B', [register, data])
elif data is None:
# special case : one byte write
length = 1
data_out = array('B', [register])
else:
raise BusException('Datatype "%s" not supported.' % type(data))
# todo check sensor chip select parameters from self._sensortable
res, dummy_data = aa.aa_spi_write(self._handle, data_out,
0) # write the reg.address and data
if res != length:
raise BusException('Unable write to SPI slave.')
def read_register(self, sensor, register, length=1):
sad = self._sensortable[sensor]
self.send_message(proto.read_req(sad, register, length))
resp = self.receive_message(proto.EVKIT_MSG_READ_RESP)
try:
resp = proto.unpack_response_data(resp)
except proto.ProtocolBus1Exception:
raise BusException('No response from bus 1')
return self._format_resp(resp[1])
def __init__(self, aadvark_index=None):
_i2c_bus.__init__(self)
self.bus_gpio_list = [1, 2]
self._has_gpio = True
self._handle = None
self._bitrate = None
if not aardvark_found:
raise BusException('Aardvark libraries not found/installed.')
(num, ports, unique_ids) = aa.aa_find_devices_ext(16, 16)
if (num == 0):
raise BusException('Aardvark i2c/spi host adapter not connected.')
elif (num == -2):
raise BusException(
'Aardvark i2c/spi host adapter never connected.')
else:
self._ports = ports[0]
if (num > 1):
logger.warning(
'More that 1 Aardvark ports found. Selecting 1st one.')
def write_register(self, sensor, register, data):
if isinstance(data, int):
length = 2
data_out = array('B', [register, data])
elif isinstance(data, list) or isinstance(data, tuple):
data = list(data)
length = 1 + len(data)
data_out = array('B', [register] + data)
elif data is None:
# special case : one byte write
length = 1
data_out = array('B', [register])
else:
raise BusException('Datatype "%s" not supported.' % type(data))
sad = self._sensortable[sensor]
res = aa.aa_i2c_write(self._handle, sad, aa.AA_I2C_NO_FLAGS, data_out)
if res != length:
raise BusException(
'Unable write to I2C slave at address 0x%x for sensor %s' %
(sad, sensor))
def read_register(self, sensor, register, length=1):
data_in = aa.array_u08(1 + length)
data_out = array('B', [0 for i in range(1 + length)])
data_out[0] = register | self.MASKR
try:
(count, data_in) = aa.aa_spi_write(self._handle, data_out,
data_in) # write address
except TypeError:
raise BusException('Cannot read sensor from SPI bus.')
#logger.debug( 'count,length %d %d ' %(count,length))
assert count == length + 1
return data_in[1:]
def read_register(self, sensor, register, length=1):
sad = self._sensortable[sensor]
# todo check write status first
aa.aa_i2c_write(self._handle, sad, aa.AA_I2C_NO_STOP,
array('B', [register])) # write address
(count, data_in) = aa.aa_i2c_read(self._handle, sad,
aa.AA_I2C_NO_FLAGS,
length) # read data
if count != length:
raise BusException(
'No response from I2C slave at address 0x%x for sensor %s' %
(sad, sensor))
return data_in
def __init__(self):
_spi_bus.__init__(self)
self.bus_gpio_list = [1, 2]
self._has_gpio = True
self._handle = None
self._bitrate = None
if not aardvark_found:
raise BusException('Aardvark libraries not found/installed.')
(num, ports, unique_ids) = aa.aa_find_devices_ext(16, 16)
if (num == 0):
raise BusException('Aardvark i2c/spi host adapter not connected.')
elif (num == -2):
raise BusException(
'Aardvark i2c/spi host adapter never connected.')
else:
self._ports = ports[0]
if (num > 1):
logger.warning(
'More that 1 Aardvark ports found. Selecting 1st one.')
self.MASKR = int(evkit_config.get('spi', 'maskr'),
2) # SPI's read address mask
def read_register(self, sensor, register, length=1):
arr = array.array('B')
sad = self._sensortable[sensor]
resp = ''
for t in range(length):
for i in range(5):
try:
data = self._handle.read_byte_data(sad, register)
register += 1
resp += chr(data)
if len(resp) == length:
arr.fromstring(resp)
return arr
break
except (IOError):
#logger.debug('Slave not responding at address %x' % sad)
continue
raise BusException(
'No response from I2C slave at address 0x%x for sensor %s' %
(sad, sensor))