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