def __init__(self, serial_port, baud_rate, protocol, repiater_port = None, repiater_rate = None):
# protocol: RF / AUTO / PGH
#self._Serial = SP.COM(serial_port, baud_rate)
Reader.__init__(self)
# Writer.__init__(self)
self._port_name = serial_port
self._Serial = serial.Serial(serial_port, baud_rate, timeout=0.1)
self._Serial.setRTS(False)
self._Serial.setDTR(False)
self._Serial.flushInput()
self._Protocol = Protocol(protocol.upper())
if repiater_port != None:
self._Serial_repeater = serial.Serial(repiater_port, repiater_rate, timeout=0.1)
self._ProtoParser = ProtoParser(self._message_pool, self._Serial, log.write, self._Serial_repeater)
# Writer.start(self)
if self._Protocol.NAME == "AUTO":
self._ProtoParser.add_proto_handler(self.get_F2_packet)
self._ProtoParser.add_proto_handler(self.get_F0_packet)
if self._Protocol.NAME == "RF":
self._ProtoParser.set_stm(0)
self._ProtoParser.add_proto_handler(self.get_host_packet)
self._ProtoParser.start()
class Communicator(Reader):
SET_PARAMS = None #Dictionary of parameters to be set for different functions ("ack", "timeout", e.t.c)
_Serial = None
_Serial_repeater = None
_port_name = None
_Protocol = None
_ProtoParser = None
def __init__(self, serial_port, baud_rate, protocol, repiater_port = None, repiater_rate = None):
# protocol: RF / AUTO / PGH
#self._Serial = SP.COM(serial_port, baud_rate)
Reader.__init__(self)
# Writer.__init__(self)
self._port_name = serial_port
self._Serial = serial.Serial(serial_port, baud_rate, timeout=0.1)
self._Serial.setRTS(False)
self._Serial.setDTR(False)
self._Serial.flushInput()
self._Protocol = Protocol(protocol.upper())
if repiater_port != None:
self._Serial_repeater = serial.Serial(repiater_port, repiater_rate, timeout=0.1)
self._ProtoParser = ProtoParser(self._message_pool, self._Serial, log.write, self._Serial_repeater)
# Writer.start(self)
if self._Protocol.NAME == "AUTO":
self._ProtoParser.add_proto_handler(self.get_F2_packet)
self._ProtoParser.add_proto_handler(self.get_F0_packet)
if self._Protocol.NAME == "RF":
self._ProtoParser.set_stm(0)
self._ProtoParser.add_proto_handler(self.get_host_packet)
self._ProtoParser.start()
#TODO: Decide if auto start is needed
#Reader.start(self)
def stop(self):
Writer.stop(self)
self._ProtoParser.stop()
self._ProtoParser.join()
def get_F2_packet(self, bufer):
packet = None
if (len(bufer) >= 9):
data_len = ord(bufer[5])
if (data_len + 8) < (len(bufer)):
#print("len = %d:%02X ,%02X, %02X" % (data_len, ord(bufer[0]), (ord(bufer[1]) ), (ord(bufer[data_len + 8]))))
if (ord(bufer[0]) == 0x0D) and (ord(bufer[1]) == 0xF2) and (ord(bufer[data_len + 8]) == 0x0A):
packet = bufer[:data_len + 8 + 1]
#log.write("{0} proto=F2 [RX]: {1}".format(self._port_name, hexdump(packet)))
return packet
return None
def get_F0_packet(self, bufer) :
ack = "\x0D\xF0\x01\x43\x00\x00\x80\x40\x0A"
# "\x0D\xF0\x02\x00\x00\x02\x36\xFF\x95\xA5\x0A"
packet = None
if (len(bufer) >= 9):
if(ord(bufer[1]) == 0xF0):
if(ord(bufer[2]) == 1):
#ack
end_byte = bufer.find('\x0A') + 1
if(end_byte):
packet = bufer[:end_byte]
else:
return None
else:
#other than ack
data_len = ord(bufer[5])
if(ord(bufer[data_len + 5 + 3]) == 0x0A):
packet = bufer[:data_len + 5 + 3 + 1]
self.send(ack)
#log.write("{0} proto=F0 [RX]: {1}".format(self._port_name, hexdump(packet)), "debug")
return packet
return None
#23 26 00 06 01 0C 0D 04 00 FF 00 00 00 04 05 3E 03 00 84 03 01 0C 0B A4 00 AD 00 00 00 04 03 F1 01 05 A4 0A
def get_host_packet(self, bufer):
packet_end = bufer.find("\x0A")
#log.write("pgh_handler |msg:%s" % hexdump(bufer))
if (packet_end != -1):
#log.write("pgh_handler |EOM found")
#packet_end += 2 # set on x90 byte
last_byte = ord(bufer[0])
#log.write("pgh_handler |last byte: %02X" % ord(bufer[last_byte]))
if (len(bufer) > last_byte) and (bufer[last_byte] == '\x0A'):
packet = bufer[:last_byte + 1]
# log.write("{0} proto=HPR [RX]: {1}".format(self._port_name, hexdump(packet)), "debug")
return packet
return None
def wait(self, commands, default_timeout = 2, not_occurences = True):
# not_occurences - defines which result will be sent back:answer packet or command occurence counter
if type(commands) is not list:
#support for multiple commands to wait
commands = [commands]
# if cmd_byte == 0:
cmd_byte = self._Protocol.CMD_BYTE
timeout = default_timeout
#Setting parameters that were passed with the function call
if (self.SET_PARAMS != None):
if (self.SET_PARAMS["ack"] != None):
not_occurences = self.SET_PARAMS["ack"]
self._EventReader._ack_needed = 0
elif not_occurences == False:
# we want to count packet occurences only,
# so disable acknowledge mechanism
self.SET_PARAMS["ack"] = False
if(self.SET_PARAMS["timeout"] != None):
timeout = self.SET_PARAMS["timeout"]
if (timeout <= 0):
return False
log.write("Waiting for command " + ', '.join([hexdump(x) for x in commands]) +". Timeout = " + str(timeout) + " seconds")
start_time = time.time()
index = 0
packet_occurences = 0
while(time.time() - start_time < timeout):
while (index < self.pool_size()):
#Checking message - optional, depend on protocol
current_message = self.get_message(index)
#Checking if correct command found
if (ord(current_message[cmd_byte - 1]) in commands):
log.write("Correct packet found: " + hexdump(current_message))
#_describe_command(current_message, self._Protocol.NAME, None)
#Removing current packet from pool
packet = self.pop_message(index)
packet_occurences += 1
if (not_occurences):
return packet
#else:
index += 1
#Waiting for next message
time.sleep(0.1)
if (not_occurences):
log.write("Failed to receive command [" + ', '.join([hexdump(x) for x in commands]) + "]")
return False
else:
log.write("Packet [" + ', '.join([hexdump(x) for x in commands]) + "] was received: " + str(packet_occurences) + " times")
return packet_occurences
def send(self, packet, priority = 0, delay_after=0.2):
# Writer.send(self, packet, priority, delay_after)
self._ProtoParser.send_message(packet)
