def open(self):
import pygatt
kx_protocol_bus.open(self)
mac_addr = evkit_config.get(self.config_section, 'mac_address')
logger.info('Connecting to MAC address %s' % mac_addr)
self._kx_port = proto.pygatt_com(
mac_addr) ####kx_com_port(comport,baudrate, timeout = 1)
self._kx_connection = proto.ProtocolEngine(self._kx_port)
# run version request
# FIXME improve
try:
self.send_message(proto.version_req())
response_data = self.receive_message(proto.EVKIT_MSG_VERSION_RESP)
message_type, major_version, minor_version = proto.unpack_response_data(
response_data)
except Exception, e:
# retry if error
logger.debug('Version REQ failed. Flushing data and retry.')
sleep(0.1)
self._kx_port.flush()
sleep(0.1)
self.send_message(proto.version_req())
response_data = self.receive_message(proto.EVKIT_MSG_VERSION_RESP)
message_type, major_version, minor_version = proto.unpack_response_data(
response_data)
def open(self):
kx_protocol_bus.open(self)
if evkit_config.has_option(self.socket_config_block[self.index],'host'):
host = evkit_config.get(self.socket_config_block[self.index],'host')
else:
host = 'localhost'
if evkit_config.has_option(self.socket_config_block[self.index],'port'):
port = evkit_config.getint(self.socket_config_block[self.index],'port')
else:
port = 8100
self._kx_port = self.socket_module_index[self.index](host=host, port=port, timeout = 3)
self._kx_connection = proto.ProtocolEngine(self._kx_port)
# run version request
# FIXME improve
try:
self.send_message(proto.version_req())
reponse_data = self.receive_message(proto.EVKIT_MSG_VERSION_RESP, cache_messages = False)
except proto.ProtocolException:
raise proto.ProtocolException('No response from socket')
try:
message_type, major_version, minor_version = proto.unpack_response_data(reponse_data)
except Exception,e:
# retry if error
logger.warning('Version REQ failed. Flushing data and retry.')
sleep(0.1)
self._kx_port.flush()
sleep(0.1)
self.send_message(proto.version_req())
reponse_data = self.receive_message(proto.EVKIT_MSG_VERSION_RESP, cache_messages = False)
message_type, major_version, minor_version = proto.unpack_response_data(reponse_data)
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 wait_indication(self):
# TODO consider sending list of accepted messages
try:
reponse_data = self.receive_message()
except proto.ProtocolTimeoutException:
# timeout is acceptable when waiting indcation message
return None
msg_id, payload = proto.unpack_response_data(reponse_data)
return self._format_resp(payload)
def open(self):
kx_protocol_bus.open(self)
config_section = evkit_config.get('__com__','config')
if evkit_config.get(config_section, 'com_port').lower() == 'auto':
if os.name == 'posix': #Linux etc...
if _platform == "darwin": # Apple
comport = self.get_dev_darwin()
else: # Linux
comport = self.get_dev()
else:
comport = self.get_com_port() # windows OS
else:
comport = evkit_config.get(config_section, 'com_port')
baudrate = evkit_config.getint(config_section, 'baudrate')
delay_s = evkit_config.getint(config_section, 'start_delay_s')
self._kx_port = kx_com_port(comport,baudrate, timeout = 2)
self._reset_protocol_engine()
if delay_s>0:
logger.info('Waiting %d seconds', delay_s)
sleep(delay_s)
# run version request
self._kx_port.flush() # Flush com port in case there is already some unwanted data
self.send_message(proto.version_req())
# TODO if getting error message instead of EVKIT_MSG_VERSION_RESP, then resend version_req
# TODO congfigure port latency if possible
# Ref
# windows user guide 4.1.4. FTDI USB Serial driver and
# linux /sys/bus/usb-serial/devices/ttyUSB0/latency_timer
# https://github.com/pyserial/pyserial/issues/287
try:
reponse_data = self.receive_message(proto.EVKIT_MSG_VERSION_RESP, cache_messages = False)
except ProtocolTimeoutException:
logger.warning('Version REQ failed. Flushing data and retry.')
self._kx_port.flush() # Flush com port in case there is already some unwanted data
reponse_data = self.receive_message(proto.EVKIT_MSG_VERSION_RESP, cache_messages = False)
message_type, major_version, minor_version = proto.unpack_response_data(reponse_data)
self.verify_protocol_version(major_version, minor_version)
def gpio_read(self, gpio):
"Reads physical GPIO pin"
self.send_message(proto.gpio_state_req(gpio))
resp = self.receive_message(proto.EVKIT_MSG_GPIO_STATE_RESP)
return proto.unpack_response_data(resp)[1]