def test_open_close(self):
for id in (1, '/dev/i2c-alias'):
bus = SMBus()
self.assertIsNone(bus.fd)
bus.open(id)
self.assertIsNotNone(bus.fd)
bus.close()
self.assertIsNone(bus.fd)
class AntennaDeployer(Device):
BUS_NUMBER = 1
PRIMARY_ADDRESS = 0x31
SECONDARY_ADDRESS = 0x32
EXPECTED_BYTES = {
AntennaDeployerCommand.SYSTEM_RESET: 0,
AntennaDeployerCommand.WATCHDOG_RESET: 0,
AntennaDeployerCommand.ARM_ANTS: 0,
AntennaDeployerCommand.DISARM_ANTS: 0,
AntennaDeployerCommand.DEPLOY_1: 0,
AntennaDeployerCommand.DEPLOY_2: 0,
AntennaDeployerCommand.DEPLOY_3: 0,
AntennaDeployerCommand.DEPLOY_4: 0,
AntennaDeployerCommand.AUTO_DEPLOY: 0,
AntennaDeployerCommand.CANCEL_DEPLOY: 0,
AntennaDeployerCommand.DEPLOY_1_OVERRIDE: 0,
AntennaDeployerCommand.DEPLOY_2_OVERRIDE: 0,
AntennaDeployerCommand.DEPLOY_3_OVERRIDE: 0,
AntennaDeployerCommand.DEPLOY_4_OVERRIDE: 0,
AntennaDeployerCommand.GET_TEMP: 2,
AntennaDeployerCommand.GET_STATUS: 2,
AntennaDeployerCommand.GET_COUNT_1: 1,
AntennaDeployerCommand.GET_COUNT_2: 1,
AntennaDeployerCommand.GET_COUNT_3: 1,
AntennaDeployerCommand.GET_COUNT_4: 1,
AntennaDeployerCommand.GET_UPTIME_1: 2,
AntennaDeployerCommand.GET_UPTIME_2: 2,
AntennaDeployerCommand.GET_UPTIME_3: 2,
AntennaDeployerCommand.GET_UPTIME_4: 2,
}
def __init__(self):
super().__init__("AntennaDeployer")
self.bus = SMBus()
def write(self, command: AntennaDeployerCommand, parameter: int) -> bool or None:
"""
Wrapper for SMBus write word data
:param command: (AntennaDeployerCommand) The antenna deployer command to run
:param parameter: (int) The parameter to pass in to the command (usually 0x00)
:return: (bool or None) success
"""
if type(command) != AntennaDeployerCommand:
return
try:
self.bus.open(self.BUS_NUMBER)
self.bus.write_word_data(self.PRIMARY_ADDRESS, command.value, parameter)
self.bus.close()
except:
return False
return True
def read(self, command: AntennaDeployerCommand) -> bytes or None:
"""
Wrapper for SMBus to read from AntennaDeployer
:param command: (AntennaDeployerCommand) The antenna deployer command to run
:return: (ctypes.LP_c_char, bool) buffer, success
"""
if type(command) != AntennaDeployerCommand:
return
success = self.write(command, 0x00)
if not success:
return None, False
time.sleep(0.5)
try:
i2c_obj = i2c_msg.read(self.PRIMARY_ADDRESS, self.EXPECTED_BYTES[command])
self.bus.open(self.BUS_NUMBER)
self.bus.i2c_rdwr(i2c_obj)
self.bus.close()
return i2c_obj.buf, True
except:
return None, False
def functional(self):
"""
:return: (bool) i2c file opened by SMBus
"""
return self.bus.fd is not None
def reset(self):
"""
Resets the Microcontroller on the ISIS Antenna Deployer
:return: (bool) no error
"""
try:
self.bus.open(self.BUS_NUMBER)
self.write(AntennaDeployerCommand.SYSTEM_RESET, 0x00)
self.bus.close()
return True
except:
return False
def disable(self):
"""
Disarms the ISIS Antenna Deployer
"""
try:
self.bus.open(self.BUS_NUMBER)
self.write(AntennaDeployerCommand.DISARM_ANTS, 0x00)
self.bus.close()
return True
except:
return False
def enable(self):
"""
Arms the ISIS Antenna Deployer
"""
try:
self.bus.open(self.BUS_NUMBER)
self.write(AntennaDeployerCommand.ARM_ANTS, 0x00)
self.bus.close()
return True
except:
return False
Signal processing
'''
t = np.arange(0, N / Fbit, 1 / Fs) # time to send all bits
m = np.zeros(0)
for bit in data_in:
if bit == 0:
m = np.hstack((m, np.multiply(np.ones(int(Fs / Fbit)), Fc - Fdev)))
else:
m = np.hstack((m, np.multiply(np.ones(int(Fs / Fbit)), Fc + Fdev)))
y = np.zeros(0)
y = A * np.cos(2 * np.pi * np.multiply(m, t)) + zero_line
'''
Signal sending
'''
port = SMBus(bus=i2c_folder)
port.open(i2c_folder)
time_point = 0
input('Press Enter to start')
GPIO.output('P8_7', GPIO.HIGH) # Trigger line high
for i in y:
i = int(i)
while time.time() - time_point < DAC_T: # Time management control
None
send(i)
time_point = time.time()
GPIO.output('P8_7', GPIO.LOW) # Trigger line low
port.close()
class VL53L1X:
"""VL53L1X ToF."""
def __init__(self,
i2c_bus=1,
i2c_address=0x29,
tca9548a_num=255,
tca9548a_addr=0):
"""Initialize the VL53L1X ToF Sensor from ST"""
self._i2c_bus = i2c_bus
self.i2c_address = i2c_address
self._tca9548a_num = tca9548a_num
self._tca9548a_addr = tca9548a_addr
self._i2c = SMBus(i2c_bus)
try:
if tca9548a_num == 255:
self._i2c.read_byte_data(self.i2c_address, 0x00)
except IOError:
raise RuntimeError("VL53L1X not found on adddress: {:02x}".format(
self.i2c_address))
self._dev = None
# Register Address
self.ADDR_UNIT_ID_HIGH = 0x16 # Serial number high byte
self.ADDR_UNIT_ID_LOW = 0x17 # Serial number low byte
self.ADDR_I2C_ID_HIGH = 0x18 # Write serial number high byte for I2C address unlock
self.ADDR_I2C_ID_LOW = 0x19 # Write serial number low byte for I2C address unlock
self.ADDR_I2C_SEC_ADDR = 0x8a # Write new I2C address after unlock
def open(self, reset=False):
self._i2c.open(bus=self._i2c_bus)
self._configure_i2c_library_functions()
self._dev = _TOF_LIBRARY.initialise(self.i2c_address,
self._tca9548a_num,
self._tca9548a_addr, reset)
def close(self):
self._i2c.close()
self._dev = None
def _configure_i2c_library_functions(self):
# I2C bus read callback for low level library.
def _i2c_read(address, reg, data_p, length):
ret_val = 0
msg_w = i2c_msg.write(address, [reg >> 8, reg & 0xff])
msg_r = i2c_msg.read(address, length)
self._i2c.i2c_rdwr(msg_w, msg_r)
if ret_val == 0:
for index in range(length):
data_p[index] = ord(msg_r.buf[index])
return ret_val
# I2C bus write callback for low level library.
def _i2c_write(address, reg, data_p, length):
ret_val = 0
data = []
for index in range(length):
data.append(data_p[index])
msg_w = i2c_msg.write(address, [reg >> 8, reg & 0xff] + data)
self._i2c.i2c_rdwr(msg_w)
return ret_val
# I2C bus write callback for low level library.
def _i2c_multi(address, reg):
ret_val = 0
# Write to the multiplexer
self._i2c.write_byte(address, reg)
return ret_val
# Pass i2c read/write function pointers to VL53L1X library.
self._i2c_multi_func = _I2C_MULTI_FUNC(_i2c_multi)
self._i2c_read_func = _I2C_READ_FUNC(_i2c_read)
self._i2c_write_func = _I2C_WRITE_FUNC(_i2c_write)
_TOF_LIBRARY.VL53L1_set_i2c(self._i2c_multi_func, self._i2c_read_func,
self._i2c_write_func)
def start_ranging(self, mode=VL53L1xDistanceMode.LONG):
"""Start VL53L1X ToF Sensor Ranging"""
_TOF_LIBRARY.startRanging(self._dev, mode)
def set_distance_mode(self, mode):
"""Set distance mode
:param mode: One of 1 = Short, 2 = Medium or 3 = Long
"""
_TOF_LIBRARY.setDistanceMode(self._dev, mode)
def stop_ranging(self):
"""Stop VL53L1X ToF Sensor Ranging"""
_TOF_LIBRARY.stopRanging(self._dev)
def get_distance(self):
"""Get distance from VL53L1X ToF Sensor"""
return _TOF_LIBRARY.getDistance(self._dev)
def set_timing(self, timing_budget, inter_measurement_period):
"""Set the timing budget and inter measurement period.
A higher timing budget results in greater measurement accuracy,
but also a higher power consumption.
The inter measurement period must be >= the timing budget, otherwise
it will be double the expected value.
:param timing_budget: Timing budget in microseconds
:param inter_measurement_period: Inter Measurement Period in milliseconds
"""
if (inter_measurement_period * 1000) < timing_budget:
raise ValueError(
"The Inter Measurement Period must be >= Timing Budget")
self.set_timing_budget(timing_budget)
self.set_inter_measurement_period(inter_measurement_period)
def set_timing_budget(self, timing_budget):
"""Set the timing budget in microseocnds"""
_TOF_LIBRARY.setMeasurementTimingBudgetMicroSeconds(
self._dev, timing_budget)
def set_inter_measurement_period(self, period):
"""Set the inter-measurement period in milliseconds"""
_TOF_LIBRARY.setInterMeasurementPeriodMilliSeconds(self._dev, period)
# This function included to show how to access the ST library directly
# from python instead of through the simplified interface
def get_timing(self):
budget = c_uint(0)
budget_p = pointer(budget)
status = _TOF_LIBRARY.VL53L1_GetMeasurementTimingBudgetMicroSeconds(
self._dev, budget_p)
if status == 0:
return budget.value + 1000
else:
return 0
def change_address(self, new_address):
status = _TOF_LIBRARY.setDeviceAddress(self._dev, new_address)
if status == 0:
self.i2c_address = new_address
else:
raise RuntimeError(
"change_address failed with code: {}".format(status))
return True
def get_RangingMeasurementData(self):
'''
Returns the full RangingMeasurementData structure.
(it ignores the fields that are not implemented according to en.DM00474730.pdf)
'''
contents = _getRangingMeasurementData(self._dev).contents
return {
'StreamCount': contents.StreamCount,
'SignalRateRtnMegaCps': contents.SignalRateRtnMegaCps / 65536,
'AmbientRateRtnMegaCps': contents.AmbientRateRtnMegaCps / 65536,
'EffectiveSpadRtnCount': contents.EffectiveSpadRtnCount / 256,
'SigmaMilliMeter': contents.SigmaMilliMeter / 65536,
'RangeMilliMeter': contents.RangeMilliMeter,
'RangeStatus': contents.RangeStatus
}
class EPS(Device):
BUS_NAME = '/dev/i2c-1'
ADDRESS = 0x57
def __init__(self):
super().__init__("EPS")
self.bus = SMBus()
def is_open(self) -> bool:
return self.bus.fd is not None
def write_i2c_block_response(self, register: EPSRegister,
data) -> bytes or None:
if type(register) != EPSRegister:
return
self.write_i2c_block_data(register, data)
return self.read_byte()
def write_byte_response(self, register: EPSRegister,
value) -> bytes or None:
if type(register) != EPSRegister:
return
self.write_byte_data(register, value)
return self.read_byte()
def read_byte_data(self, register: EPSRegister) -> bytes or None:
if type(register) != EPSRegister:
return
self.bus.open(self.BUS_NAME)
next_byte = self.bus.read_byte_data(self.ADDRESS, register.value)
self.bus.close()
return next_byte
def read_byte(self) -> bytes or None:
self.bus.open(self.BUS_NAME)
next_byte = self.bus.read_byte(self.ADDRESS)
self.bus.close()
return next_byte
def write_i2c_block_data(self, register: EPSRegister, data):
if type(register) != EPSRegister:
return
self.bus.open(self.BUS_NAME)
self.bus.write_i2c_block_data(self.ADDRESS, register.value, data)
self.bus.close()
def write_byte_data(self, register: EPSRegister, value):
if type(register) != EPSRegister:
return
self.bus.open(self.BUS_NAME)
self.bus.write_byte_data(self.ADDRESS, register.value, value)
self.bus.close()
def functional(self):
raise NotImplementedError
def reset(self):
raise NotImplementedError
def disable(self):
raise NotImplementedError
def enable(self):
raise NotImplementedError
class VL53L1X:
"""VL53L1X ToF."""
def __init__(self,
i2c_bus=1,
i2c_address=0x29,
tca9548a_num=255,
tca9548a_addr=0):
"""Initialize the VL53L1X ToF Sensor from ST"""
self._i2c_bus = i2c_bus
self.i2c_address = i2c_address
self._tca9548a_num = tca9548a_num
self._tca9548a_addr = tca9548a_addr
self._i2c = SMBus(1)
self._dev = None
# Resgiter Address
self.ADDR_UNIT_ID_HIGH = 0x16 # Serial number high byte
self.ADDR_UNIT_ID_LOW = 0x17 # Serial number low byte
self.ADDR_I2C_ID_HIGH = 0x18 # Write serial number high byte for I2C address unlock
self.ADDR_I2C_ID_LOW = 0x19 # Write serial number low byte for I2C address unlock
self.ADDR_I2C_SEC_ADDR = 0x8a # Write new I2C address after unlock
def open(self):
self._i2c.open(bus=self._i2c_bus)
self._configure_i2c_library_functions()
self._dev = _TOF_LIBRARY.initialise(self.i2c_address)
def close(self):
self._i2c.close()
self._dev = None
def _configure_i2c_library_functions(self):
# I2C bus read callback for low level library.
def _i2c_read(address, reg, data_p, length):
ret_val = 0
msg_w = i2c_msg.write(address, [reg >> 8, reg & 0xff])
msg_r = i2c_msg.read(address, length)
self._i2c.i2c_rdwr(msg_w, msg_r)
if ret_val == 0:
for index in range(length):
data_p[index] = ord(msg_r.buf[index])
return ret_val
# I2C bus write callback for low level library.
def _i2c_write(address, reg, data_p, length):
ret_val = 0
data = []
for index in range(length):
data.append(data_p[index])
msg_w = i2c_msg.write(address, [reg >> 8, reg & 0xff] + data)
self._i2c.i2c_rdwr(msg_w)
return ret_val
# Pass i2c read/write function pointers to VL53L1X library.
self._i2c_read_func = _I2C_READ_FUNC(_i2c_read)
self._i2c_write_func = _I2C_WRITE_FUNC(_i2c_write)
_TOF_LIBRARY.VL53L1_set_i2c(self._i2c_read_func, self._i2c_write_func)
def start_ranging(self, mode=VL53L1xDistanceMode.LONG):
"""Start VL53L1X ToF Sensor Ranging"""
_TOF_LIBRARY.startRanging(self._dev, mode)
def stop_ranging(self):
"""Stop VL53L1X ToF Sensor Ranging"""
_TOF_LIBRARY.stopRanging(self._dev)
def get_distance(self):
"""Get distance from VL53L1X ToF Sensor"""
return _TOF_LIBRARY.getDistance(self._dev)
# This function included to show how to access the ST library directly
# from python instead of through the simplified interface
def get_timing(self):
budget = c_uint(0)
budget_p = pointer(budget)
status = _TOF_LIBRARY.VL53L1_GetMeasurementTimingBudgetMicroSeconds(
self._dev, budget_p)
if status == 0:
return budget.value + 1000
else:
return 0
def change_address(self, new_address):
_TOF_LIBRARY.setDeviceAddress(self._dev, new_address)
class VL53L1X:
"""VL53L1X ToF."""
def __init__(self, i2c_bus=1):
"""Initialize the VL53L1X ToF Sensor from ST"""
self._i2c_bus = i2c_bus
self._i2c = SMBus(1)
self._default_dev = None
self._dev_list = None
# Resgiter Address
self.ADDR_UNIT_ID_HIGH = 0x16 # Serial number high byte
self.ADDR_UNIT_ID_LOW = 0x17 # Serial number low byte
self.ADDR_I2C_ID_HIGH = 0x18 # Write serial number high byte for I2C address unlock
self.ADDR_I2C_ID_LOW = 0x19 # Write serial number low byte for I2C address unlock
self.ADDR_I2C_SEC_ADDR = 0x8a # Write new I2C address after unlock
def open(self):
self._i2c.open(bus=self._i2c_bus)
self._configure_i2c_library_functions()
self._default_dev = _TOF_LIBRARY.initialise()
self._dev_list = dict()
def add_sensor(self, sensor_id, address):
self._dev_list[sensor_id] = _TOF_LIBRARY.copy_dev(self._default_dev)
_TOF_LIBRARY.init_dev(self._dev_list[sensor_id], c_uint8(address))
def close(self):
self._i2c.close()
self._default_dev = None
self._dev_list = None
def _configure_i2c_library_functions(self):
# I2C bus read callback for low level library.
def _i2c_read(address, reg, data_p, length):
ret_val = 0
msg_w = i2c_msg.write(address, [reg >> 8, reg & 0xff])
msg_r = i2c_msg.read(address, length)
# print("R: a: %x\tr:%d" % (address,reg))
try:
self._i2c.i2c_rdwr(msg_w, msg_r)
except:
print("Cannot read on 0x%x I2C bus, reg: %d" % (address, reg))
if ret_val == 0:
for index in range(length):
data_p[index] = ord(msg_r.buf[index])
return ret_val
# I2C bus write callback for low level library.
def _i2c_write(address, reg, data_p, length):
ret_val = 0
data = []
for index in range(length):
data.append(data_p[index])
msg_w = i2c_msg.write(address, [reg >> 8, reg & 0xff] + data)
# print("W: a: %x\tr:%d" % (address,reg))
try:
self._i2c.i2c_rdwr(msg_w)
except:
print("Cannot write on 0x%x I2C bus, reg: %d" % (address, reg))
return ret_val
# Pass i2c read/write function pointers to VL53L1X library.
self._i2c_read_func = _I2C_READ_FUNC(_i2c_read)
self._i2c_write_func = _I2C_WRITE_FUNC(_i2c_write)
_TOF_LIBRARY.VL53L1_set_i2c(self._i2c_read_func, self._i2c_write_func)
def start_ranging(self, sensor_id, mode=VL53L1xDistanceMode.LONG):
"""Start VL53L1X ToF Sensor Ranging"""
dev = self._dev_list[sensor_id]
_TOF_LIBRARY.startRanging(dev, mode)
def stop_ranging(self, sensor_id):
"""Stop VL53L1X ToF Sensor Ranging"""
dev = self._dev_list[sensor_id]
_TOF_LIBRARY.stopRanging(dev)
def get_distance(self, sensor_id):
dev = self._dev_list[sensor_id]
return _TOF_LIBRARY.getDistance(dev)
def get_address(self, sensor_id):
dev = self._dev_list[sensor_id]
return _TOF_LIBRARY.get_address(dev)
def change_address(self, sensor_id, new_address):
dev = self._dev_list[sensor_id]
_TOF_LIBRARY.setDeviceAddress(dev, new_address)
class VL53L1X:
"""VL53L1X ToF."""
def __init__(self, i2c_bus=1, i2c_address=0x29, tca9548a_num=255, tca9548a_addr=0):
"""Initialize the VL53L1X ToF Sensor from ST"""
self._i2c_bus = i2c_bus
self.i2c_address = i2c_address
self._tca9548a_num = tca9548a_num
self._tca9548a_addr = tca9548a_addr
self._i2c = SMBus()
if tca9548a_num == 255:
try:
self._i2c.open(bus=self._i2c_bus)
self._i2c.read_byte_data(self.i2c_address, 0x00)
except IOError:
raise RuntimeError("VL53L1X not found on adddress: {:02x}".format(self.i2c_address))
finally:
self._i2c.close()
self._dev = None
# Register Address
self.ADDR_UNIT_ID_HIGH = 0x16 # Serial number high byte
self.ADDR_UNIT_ID_LOW = 0x17 # Serial number low byte
self.ADDR_I2C_ID_HIGH = 0x18 # Write serial number high byte for I2C address unlock
self.ADDR_I2C_ID_LOW = 0x19 # Write serial number low byte for I2C address unlock
self.ADDR_I2C_SEC_ADDR = 0x8a # Write new I2C address after unlock
def open(self, reset=False):
self._i2c.open(bus=self._i2c_bus)
self._configure_i2c_library_functions()
self._dev = _TOF_LIBRARY.initialise(self.i2c_address, self._tca9548a_num, self._tca9548a_addr, reset)
def close(self):
self._i2c.close()
self._dev = None
def _configure_i2c_library_functions(self):
# I2C bus read callback for low level library.
def _i2c_read(address, reg, data_p, length):
ret_val = 0
msg_w = i2c_msg.write(address, [reg >> 8, reg & 0xff])
msg_r = i2c_msg.read(address, length)
self._i2c.i2c_rdwr(msg_w, msg_r)
if ret_val == 0:
for index in range(length):
data_p[index] = ord(msg_r.buf[index])
return ret_val
# I2C bus write callback for low level library.
def _i2c_write(address, reg, data_p, length):
ret_val = 0
data = []
for index in range(length):
data.append(data_p[index])
msg_w = i2c_msg.write(address, [reg >> 8, reg & 0xff] + data)
self._i2c.i2c_rdwr(msg_w)
return ret_val
# I2C bus write callback for low level library.
def _i2c_multi(address, reg):
ret_val = 0
# Write to the multiplexer
self._i2c.write_byte(address, reg)
return ret_val
# Pass i2c read/write function pointers to VL53L1X library.
self._i2c_multi_func = _I2C_MULTI_FUNC(_i2c_multi)
self._i2c_read_func = _I2C_READ_FUNC(_i2c_read)
self._i2c_write_func = _I2C_WRITE_FUNC(_i2c_write)
_TOF_LIBRARY.VL53L1_set_i2c(self._i2c_multi_func, self._i2c_read_func, self._i2c_write_func)
# The ROI is a square or rectangle defined by two corners: top left and bottom right.
# Default ROI is 16x16 (indices 0-15). The minimum ROI size is 4x4.
def set_user_roi(self, user_roi):
"""Set Region Of Interest (ROI)"""
_TOF_LIBRARY.setUserRoi(self._dev,
user_roi.top_left_x,
user_roi.top_left_y,
user_roi.bot_right_x,
user_roi.bot_right_y)
def start_ranging(self, mode=VL53L1xDistanceMode.LONG):
"""Start VL53L1X ToF Sensor Ranging"""
_TOF_LIBRARY.startRanging(self._dev, mode)
def set_distance_mode(self, mode):
"""Set distance mode
:param mode: One of 1 = Short, 2 = Medium or 3 = Long
"""
_TOF_LIBRARY.setDistanceMode(self._dev, mode)
def stop_ranging(self):
"""Stop VL53L1X ToF Sensor Ranging"""
_TOF_LIBRARY.stopRanging(self._dev)
def get_distance(self):
"""Get distance from VL53L1X ToF Sensor"""
return _TOF_LIBRARY.getDistance(self._dev)
def set_timing(self, timing_budget, inter_measurement_period):
"""Set the timing budget and inter measurement period.
A higher timing budget results in greater measurement accuracy,
but also a higher power consumption.
The inter measurement period must be >= the timing budget, otherwise
it will be double the expected value.
:param timing_budget: Timing budget in microseconds
:param inter_measurement_period: Inter Measurement Period in milliseconds
"""
if (inter_measurement_period * 1000) < timing_budget:
raise ValueError("The Inter Measurement Period must be >= Timing Budget")
self.set_timing_budget(timing_budget)
self.set_inter_measurement_period(inter_measurement_period)
def set_timing_budget(self, timing_budget):
"""Set the timing budget in microseocnds"""
_TOF_LIBRARY.setMeasurementTimingBudgetMicroSeconds(self._dev, timing_budget)
def set_inter_measurement_period(self, period):
"""Set the inter-measurement period in milliseconds"""
_TOF_LIBRARY.setInterMeasurementPeriodMilliSeconds(self._dev, period)
# This function included to show how to access the ST library directly
# from python instead of through the simplified interface
def get_timing(self):
budget = c_uint(0)
budget_p = pointer(budget)
status = _TOF_LIBRARY.VL53L1_GetMeasurementTimingBudgetMicroSeconds(self._dev, budget_p)
if status == 0:
return budget.value + 1000
else:
return 0
def change_address(self, new_address):
status = _TOF_LIBRARY.setDeviceAddress(self._dev, new_address)
if status == 0:
self.i2c_address = new_address
else:
raise RuntimeError("change_address failed with code: {}".format(status))
return True
