def __init__(self, dev):
''' Para contrui-lá é necessário passar como parâmetro o timeout desejado e o objeto
contendo as informações da serial para ser utilizado Ex.:
serial.Serial('/dev/pts/5', 9600, timeout=5)
Funcionalidade de algumas variáveis.
buffer: Onde será armazenado os quadros transmitods
bit: Onde é armazenado o que é lido da serial
quadro: Apenas informa quando ocorre o recebimento de um quadro completo
fcs: Recebe objeto do tipo CRC16 para efetuar o cálculo.
temp: Utilizado para fazer o estufamento dos bytes recebidos
'''
self.dev = dev
self.enable()
poller.Callback.__init__(self, dev, timeout=5)
self.fd = dev
self.state = self.ocioso # definindo estado inicial da fsm
self.buffer = [] # Buffer para armazenar os bytes lidos
self.n = 0 # Contador de byte válido recebido#
self.base_timeout = self.timeout
self.disable_timeout()
self.bit = self.fd
self.fcs = crc.CRC16(" ")
self.temp = None
self.quadro = False # Usado para informa que recebeu um quadro completo.
def recebe(self):
import crc
while (True):
byte = self.serial.read()
#se for vazio é porque deu timeout, retorna
if (byte == bytearray()):
#print('timeout serial')
return 0, bytearray()
#print('Recebeu byte: {}'.format(byte))
if (self._handle(byte) == True): # terminou de receber
dado_recebido = self.buf #[0:-4]
dado_sem_crc = self.buf[0:-2]
fcs = crc.CRC16('')
fcs.clear()
fcs.update(dado_recebido)
crc_valido = fcs.check_crc()
#print('{}'.format(dado_sem_crc))
if (crc_valido == True):
return len(dado_sem_crc), dado_sem_crc
else:
#print('Pacote corrompido e descartado.')
dado_recebido = bytearray()
return 0, dado_recebido
def read(self, byte):
if (byte[0] == FLAG):
self.current_state = IDLE
self.disable_timeout()
fcs = crc.CRC16(self.buffer)
if fcs.check_crc():
self.buffer = self.buffer[:-2]
return True
else:
self.buffer.clear()
print(RED + 'DETECÇÃO DE ERRO!' + RST)
elif (byte[0] == ESC):
self.current_state = ESCAPE
elif (len(self.buffer) < MAX_BYTES):
self.buffer.append(byte[0])
self.current_state = READ
else:
print(BLUE + '2 OVERFLOW!' + RST + ' A mensagem tem mais que',
len(self.buffer), 'bytes.')
self.buffer.clear()
self.current_state = IDLE
self.disable_timeout()
self.reload_timeout()
def _rx(self, byte):
'''
Estado da FSM que lê todos os dados do quadro e trata possíveis erros
:param byte: byte recebido
'''
if (byte == 0x7e and self.n_bytes > 0):
self.fcs = crc.CRC16('')
self.fcs.clear()
self.fcs.update(self.recebido)
if (self.fcs.check_crc()):
self.upper.notifica(self.recebido)
self.disable_timeout()
self.estado = self.idle
elif (self.n_bytes > self.bytes_max): # ADICIONAR TIMEOUT
self.recebido.clear()
self.disable_timeout()
self.estado = self.idle
elif (byte == 0x7e and self.n_bytes == 0):
self.recarrega_timeout(self.tout)
self.estado = self.rx
elif (byte == 0x7d):
self.estado = self.esc
else:
self.n_bytes = self.n_bytes + 1
self.recebido.append(byte)
self.recarrega_timeout(self.tout)
self.estado = self.rx
def __init__(self, serial, bytes_max, timeout):
'''
Construtor da classe Enquadramento
:param serial: Interface serial por qual os dados serão lidos ou escritos
:param bytes_max: Número máximo de bytes por quadro
:param timeout: Tempo de timeout em segundos
'''
self.serial = serial # Interface serial
self.bytes_max = bytes_max # Número máximo de bytes por quadro
self.n_bytes = 0 # Número de bytes recebidos
#self.timeout = timeout
self.recebido = bytearray() # Vetor de bytes com os dados recebidos
self.fcs = crc.CRC16('') # Objeto do CRC
self.estado = self.idle # Estado inicial da FSM
self.upper = None
self.lower = None
self.tout = timeout
layer.Layer.__init__(self, serial, timeout)
self.enable() # Ativa o monitoramento do objeto
self.disable_timeout() # Desativa o Timeout
def recebe(self):
while (True):
if (self.estado == 'ocioso'):
(r, w, e) = select.select([self.ser], [], [], self.timeout)
else:
(r, w, e) = select.select([self.ser], [], [], 0.05)
if (not (r)):
self.handle(None)
byte = None
if (self.n_bytes > 0):
return (-3, [None, None])
else:
byte = r[0].read()
if (byte == b''):
self.estado = 'ocioso'
return (-1, [None, None])
key = self.handle(byte)
if (key):
if (crc.CRC16(self.buff[0:]).check_crc()):
#print(self.buff)
break
else:
return (-2, [None, None])
elif (key < 0):
return (key, [None, None])
else:
pass
return (1, self.buff[0:len(self.buff) - 2])
def recebe(self):
self.continuarRecebendo = True
while self.continuarRecebendo:
byte = self._serial.read()
if (self.get_timeout()):
print("timeout")
self.continuarRecebendo = False
else:
self.continuarRecebendo = self.desenquadra(byte)
payload = self.frame
fcs = payload
vet = bytearray()
for i in range(len(fcs)):
vet = vet + fcs[i]
self.objeto_crc = crc.CRC16(vet)
check = self.objeto_crc.check_crc()
if check == True:
print("Dados confiaveis!")
self.payload_corrompido = False
self.finalizaRecepcao()
return payload
else:
erro_crc = "ERRO: Payload corrompido!"
print(erro_crc)
self.payload_corrompido = True
return
def recebe(self):
continuarRecebendo = True
#self._serial.timeout = 1 # segundos
while continuarRecebendo:
byte = self._serial.read()
if (byte == b''):
print("Ocorreu timeout, retornando ao estado ocioso")
self.finalizaRecepcao()
continuarRecebendo = False
return []
continuarRecebendo = self.desenquadra(byte)
payload = self.frame
self.finalizaRecepcao()
fcs = payload
vet = bytearray()
for i in range(len(fcs)):
vet = vet + fcs[i]
self.objeto_crc = crc.CRC16(vet)
checksum = self.objeto_crc.check_crc()
if checksum == True:
print("Dados confiaveis")
return payload
else:
erro_crc = "PAYLOAD CORROMPIDO"
raise RuntimeError(erro_crc)
def __init__(self, portaSerial, baud):
self.objeto_crc = crc.CRC16(b'')
self.estado = "ocioso"
self._serial = serial.Serial(port=portaSerial, baudrate=baud)
self.n = None
self.max_bytes = 256
self.frame = []
self.estado_anterior = None
def transmite(self, info):
# para fazer p crc antes
payload_crc = bytearray(info)
crc16 = crc.CRC16(payload_crc)
info = crc16.gen_crc()
self.quadro.append(toInt(b'\x7E'))
for byte in info:
self.enquadra(byte)
self.quadro.append(toInt(b'\x7E'))
self._serial.write(bytearray(self.quadro))
self.quadro = []
def __init__(self, portaSerial, baud):
self.objeto_crc = crc.CRC16(b'')
self.estado = "ocioso"
self._serial = serial.Serial(port=portaSerial, baudrate=baud)
self.n = None
self.max_bytes = 256
self.frame = []
self.estado_anterior = None
self.continuarRecebendo = None
self.timeout = False
self.payload_corrompido = False
def transmite(self, info):
# para fazer p crc antes
payload_crc = bytearray(info)
crc16 = crc.CRC16(payload_crc)
info = crc16.gen_crc()
self.quadro.append(toInt(b'\x7E'))
for byte in info:
self.enquadra(byte)
#forçando o envio de um quadro incompleto para ocasionar timeout de byte
#self.quadro.append(toInt(b'\x7E'))
self._serial.write(bytearray(self.quadro))
self.quadro = []
def recebe(self):
recv_data = self.ser.read()
if(recv_data == bytearray()):
return False
if(self.handle_dado(recv_data, self.estado) == True):
fcs = crc.CRC16('')
fcs.clear()
fcs.update(self.buffer)
if(fcs.check_crc() == True):
self.buffer = self.buffer[0:-2]
return True
if(fcs.check_crc() == False):
print("Erro no CRC!")
return False
def envia(self, data):
final_data = bytearray()
fcs = crc.CRC16(data)
data_crc = fcs.gen_crc()
for i in range(0, len(data_crc)):
if((data_crc[i] == 0x7E) or (data_crc[i] == 0x7D)):
trans_byte = bytes([data_crc[i] ^ 0x20])
final_data = final_data + b'\x7D' + trans_byte
else:
final_data = final_data + bytes([data_crc[i]])
final_data = b'\x7E' + final_data + b'\x7E'
self.ser.write(final_data)
print('Enviando: ', final_data)
def envia(self, byt):
pacote = b'\x7E'
msg = crc.CRC16(byt).gen_crc()
for x in range(0, len(msg)):
if((msg[x]== int.from_bytes(b'\x7E', byteorder='big')) or (msg[x] == int.from_bytes(b'\x7D', byteorder='big'))):
pacote += b'\x7D'
pacote += (msg[x] ^ int.from_bytes(b'\x20', byteorder='big')).to_bytes(1, byteorder='big')
else:
pacote += msg[x].to_bytes(1,byteorder='big')
pacote += b'\x7E'
self.ser.write(pacote)
print('mensagem enviada\n', pacote)
def recebe(self):
while (True):
bt_recebido = self.ser.read()
if (self.n > self.max_bytes or bt_recebido == b''):
self.n = 0
return 0
self.n = self.n + 1
if (self.handle(bt_recebido) == True):
fcs = crc.CRC16(self.bufer)
if (fcs.check_crc() == True):
return self.bufer[0:-2]
else:
self.bufer = bytearray()
pass
def envia(self, bufer, bytes):
self.bufer = bytearray()
fcs = crc.CRC16(bufer)
msg = fcs.gen_crc()
self.bufer.append(0x7E)
for n in range(len(msg)):
if (chr(msg[n]) == '~'): #7E
self.bufer.append(0x7D)
self.bufer.append(msg[n] ^ 0x20)
elif (chr(msg[n]) == '}'): #7D
self.bufer.append(0x7D)
self.bufer.append(msg[n] ^ 0x20)
else:
self.bufer.append(msg[n])
self.bufer.append(0x7E)
return self.ser.write(self.bufer)
def __init__(self,dev):
#self.port = port # Pega porta fornecida pelo usuario
# Passando argumentos para o fileobj e o timeout para o construtor do CallBack do poller.py
# INSERIR TAMANHO MAXIMO DE 1024
self.dev = dev
poller.Callback.__init__(self, dev, timeout=5)
self.fd = dev
self.state = self.ocioso # definindo estado inicial da fsm
self.buffer = [] # Buffer para armazenar os bytes lidos
self.n = 0 # Contador de byte válido recebido
self.base_timeout = self.timeout
self.disable_timeout()
self.bit = self.fd
self.fcs = crc.CRC16(" ")
self.temp = None
self.quadro = False # Usado para informa que recebeu um quadro completo.
def handle_data(self):
status = self.handle(self.ser.read(1))
if(status == 1):
if(crc.CRC16(self.buff[0:]).check_crc()):
#print("HERE")
status,frame, proto = self.arq.handle_data((status, self.buff[0:len(self.buff)-2]))
#print("Enq", proto)
if(status == 1):
#print('Passei Aqui')
return (1, frame, proto)
else:
return (-2, None, None)
else:
#print("Should not be HERE")
self.arq.handle_data((-2, [None, None]))
return (-2, None, None)
return(0,None, None)
def recebe(self):
print('\n---------------------------\n')
print('Aguardando Quadro...')
print('\n---------------------------\n')
while (True):
buffer = self.serial.read()
if (self.handle(buffer) == True
): # Apos finalizar recebimento retorna True
if (crc.CRC16(self.buffer).check_crc()): # verifica crc
print('Dado Recebido: ',
self.buffer[0:len(self.buffer) - 2])
print('CRC Recebido: ', self.buffer[-2:])
return self.buffer[0:len(self.buffer) - 2]
if (len(buffer) == 0):
return b''
def __init__(self, dev, bytes_min, bytes_max, timeout):
''' dev: interface serial para receber/enviar dados.
bytes_min: número mínimo de bytes do quadro.
bytes_max: número máximo de bytes do quadro.
timeout: intervalo de tempo para interrupção interna
'''
self._bytes_min = bytes_min
self._bytes_max = bytes_max
self._state = self.idle
self._dev = dev
self._datasize = 0
self._received = bytearray()
self.fd = dev
self.timeout = timeout
self.base_timeout = timeout
self.disable_timeout()
self._crc = crc.CRC16(" ")
self._top = None
self.enable()
def recebe(self):
#print('\n---------------------------\n')
#print('Recebendo byte...')
##print('\n---------------------------\n')
#while(True):
buffer = self.serial.read()
#print(buffer)
if (self.handle(buffer) == True
): # Apos finalizar recebimento retorna True
if (crc.CRC16(self.buffer).check_crc()): # verifica crc
print('Dado Recebido: ', self.buffer[0:len(self.buffer) - 2])
print('CRC Recebido: ', self.buffer[-2:])
return self.buffer[0:len(self.buffer) - 2]
else:
print('CRC incorreto')
#if(len(buffer) == 0):
#ainda não recebeu quadro completo
return b''
def envia(self, dado):
import crc
dado_transformado = bytearray()
fcs = crc.CRC16(dado)
dado_com_crc = fcs.gen_crc()
for i in range(0, len(dado_com_crc)):
if ((dado_com_crc[i] == 0x7E) or (dado_com_crc[i] == 0x7D)):
dado_transformado = dado_transformado + b'\x7D' + bytes(
[self._xor20(dado_com_crc[i])])
#print('teste')
else:
dado_transformado = dado_transformado + bytes([
dado_com_crc[i]
]) #dado entre colchetes para transformar para bytes
buf = bytearray()
buf = buf + b'\x7E' + dado_transformado + b'\x7E'
self.serial.write(buf)
def send(self, fr):
'''Recebe octetos da camada superior, anexa dados de verificação de erro,
realiza o preenchimento de byte e envia pela porta serial'''
fcs = crc.CRC16(fr.header)
fr.header = fcs.gen_crc()
frame = bytearray()
frame.append(FLAG)
for byte in fr.header:
if (byte == FLAG or byte == ESC):
xor = byte ^ 0x20
frame.append(ESC)
frame.append(xor)
else:
frame.append(byte)
frame.append(FLAG)
self.fd.write(bytes(frame)) # Envia mensagem pela porta serial
def trata_byte(self, byte_recebido):
import crc
#print('Trata byte: {}'.format(byte_recebido))
if (self._handle(byte_recebido) == True): # terminou de receber
dado_recebido = self.buf #[0:-4]
dado_sem_crc = self.buf[0:-2]
fcs = crc.CRC16('')
fcs.clear()
fcs.update(dado_recebido)
crc_valido = fcs.check_crc()
#print('Trata byte - quadro completo: {}'.format(dado_sem_crc))
if (crc_valido == True):
#return len(dado_sem_crc), dado_sem_crc
self.buf_poller = dado_sem_crc
return True
else:
#print('Pacote corrompido e descartado.')
dado_recebido = bytearray()
#return 0, dado_recebido
self.buf_poller = dado_recebido
return False
def envia(self, buffer): # o buffer sao inteiros
self.buffer = b''
self.buffer += bytes(b'\x7e') # insere 7e no inicio do pacote
buffer = crc.CRC16(
buffer).gen_crc() # gera crc e coloca no final do buffer
for i in range(0, len(buffer)):
#print(hex(buffer[i]))
if ((buffer[i].to_bytes(1, 'big') == b'\x7e')
or (buffer[i].to_bytes(1, 'big') == b'\x7d')):
self.buffer += b'\x7d'
#print(self.buffer)
self.buffer += (buffer[i] ^ 32).to_bytes(1, 'big')
#print(self.buffer)
else:
self.buffer += buffer[i].to_bytes(1, 'big')
self.buffer += b'\x7e'
self.serial.write(self.buffer)
print('\n---------------------------\n')
print('Enviando Quadro...')
print('\n---------------------------\n')
print('Quadro: ' + str(self.buffer))
def envia(self, data):
'''
Realiza a montagem do quadro e o escreve na serial
:param data: quadro a ser tratado
:return: quadro já tratado
'''
self.fcs = crc.CRC16(data) # Calcula o FCS
data_fcs = self.fcs.gen_crc(
) # Retorna um objeto bytes com os dados seguidos do valor de FCS
msg = bytearray()
msg.append(0x7E) # Adiciona delimitador de quadro de início
for octeto in data_fcs:
if (octeto == 0x7E or octeto == 0x7D):
i = octeto ^ 0x20 # Realiza a operação XOR 20 com os bytes especiais
msg.append(0x7D) # Adiciona byte de escape
msg.append(i)
else:
msg.append(octeto)
msg.append(0x7E) # Adiciona delimitador de quadro de fim
print('tx:', msg)
self.serial.write(msg) # Envia a mensagem pela serial
##quadro = sys.argv[2]
print('----------------------------------------')
quadro = input("Insira o quadro a ser enviado: ")
except:
print('Uso: %s porta_serial quadro' % sys.argv[0])
sys.exit(0)
try:
p = Serial(porta)
except Exception as e:
print(e)
sys.exit(0)
# pld = quadro.encode('ascii')
fcs = crc.CRC16(quadro)
msg = fcs.gen_crc()
msg = add_escape(msg)
msg_send = bytearray()
msg_send.append(0x7E)
# msg_send.append(get_controle('data', seq_counter))
msg_send.append(0x00)
msg_send.extend(msg)
msg_send.append(0x7E)
# print('Mensagem com FCS:', msg_send)
try:
n = p.write(msg_send)
msg_send_bytes = ":".join(hex(b)[2:] for b in msg_send)
print('Enviou %d bytes: %s' % (n, msg_send_bytes))
resp = p.readline()
def verificaCRC(self, quadro):
'''Verifica se o quadro está corrompido'''
fcs = crc.CRC16()
fcs.clear()
fcs.update(quadro)
return fcs.check_crc()
def gerarCRC(self, quadro):
'''Gera CRC: insere dois bytes'''
fcs = crc.CRC16(quadro)
msg_CRC = fcs.gen_crc()
fcs.clear()
return msg_CRC
