def write_MEASURE_CYCLE( ser, address,time): #check if the serial port is open if ser.is_open==False: print("write_MEASURE_CYCLE: serial port not open.") return 0 #reset the output buffer before send new data ser.reset_output_buffer out=[address, MODBUS_WRITE_SINGLE_REGISTER, 0x0, MODBUS_STATE_REGISTER_MEASURE_CYCLE, 0, time] #calculate and add the CRC out=out + list(struct.pack("<H", libscrc.modbus(bytes(out)))) #send data and read the answer. If any error send the message again before give up. j=0; while j<MAX_ITERATION: write_message(ser,out,address) #read the return message read_data=read_message(address, MODBUS_WRITE_SINGLE_REGISTER,ser) if not(read_data[0]==0 and len(read_data)==1): #force loop exit j=MAX_ITERATION+1 else: j=j+1 if read_data[0]==0: print("write_MEASURE_CYCLE: error in reading data") return read_data #if no error return ok if (error_in_message_check(read_data)[0]!=0): return bytes ([1]) return bytes ([0])
def mainRun(): server=socket.socket(socket.AF_INET, socket.SOCK_DGRAM) #server.bind(("192.168.22.167", 9534)) # POWER={"on": 0x55,"off": 0xAA} # MODE={"cold": 0x11,"hot": 0x22,"auto" 0x33,"fan": 0x44,"dry": 0x55} # FAN={"fan1": 0x01,"fan2": 0x02,"fan3": 0x03,"autofan": 0x00} # TEMP={16: 0x00A0, 17: 0x00AA, 18: 0x00B4, 19: 0x00BE, 20: 0x00C8, 21: 0x00D2, 22: 0x00DC, 23: 0x00E6, 24: 0x00F0, 25: 0x00FA, 26: 0x0104, 27: 0x010E, 28: 0x0118, 29: 0x0122, 30: 0x012C, 31: 0x0136, 32: 0x0140} POWER_CODE="on" MODE_CODE ="cold" FAN_CODE ="fan3" TEMP_CODE =16 POWER = {"on": "55", "off": "AA"} MODE = {"cold": "11", "hot": "22", "auto" "33", "fan": "44", "dry": "55"} FAN = {"fan1": "01", "fan2": "02", "fan3": "03", "autofan": "00"} TEMP = {16: "00A0", 17: "00AA", 18: "00B4", 19: "00BE", 20: "00C8", 21: "00D2", 22: "00DC", 23: "00E6", 24: "00F0", 25: "00FA", 26: "0104", 27: "010E", 28: "0118", 29: "0122", 30: "012C", 31: "0136", 32: "0140"} command="01109C4000081000"+POWER[POWER_CODE]+"000000"+MODE[MODE_CODE]+"00"+FAN[FAN_CODE]+"00000000"+TEMP[TEMP_CODE]+"0B01" print(command) crc16 = libscrc.modbus(bytes.fromhex('01109C4000081000550000001100010000000000A00B01')) addr = ("192.168.1.105", 20740) a = bytes.fromhex('01109C4000081000550000001100010000000000A00B0158d6') # # while data!='q': server.sendto(a,addr)
def read_SERIAL_NUMBER( ser, address): #check if the serial port is open if ser.is_open==False: print("read_SERIAL_NUMBER: serial port not open.") return bytes ([0]) #reset the output buffer before send new data ser.reset_output_buffer #build the modbus message to send out=[address, MODBUS_READ_SINGLE_REGISTER, 0x0, MODBUS_STATE_REGISTER_SERIAL_NUMBER, 0x0, 0x0] #calculate and add the CRC out=out + list(struct.pack("<H", libscrc.modbus(bytes(out)))) #send data and read the answer. If any error send the message again before give up. j=0; while j<MAX_ITERATION: write_message(ser,out,address) #read the return message read_data=read_message(address, MODBUS_READ_SINGLE_REGISTER,ser) #if read data byte 1 is zero that means error if not(read_data[0]==0 and len(read_data)==1): #information is contained in the following bytes of the valid answer data_in_result=read_data[4:8] return data_in_result else: j=j+1 print("read_SERIAL_NUMBER: error in reading data") return read_data
def GetCRC16Modbus(inputHex): myBytes = bytes.fromhex(inputHex) crc16 = libscrc.modbus(myBytes) crc16Hex = HexToGroup(IntToHex(crc16)) crc16Hex.reverse() outputHex = ' '.join(crc16Hex) return outputHex
def crcCheck(serialMessage): """Check if the serial message have a valid CRC. Parameters ----------- serialMessage: bytearray which contents the serial message send by the FT300. [0x20,0x4e,LSBdata1,MSBdata2,...,LSBdata6,MSBdata6,crc1,crc2] Check FT300 manual for details. Return ------ checkResult: bool, return True if the message have a valid CRC and False if not. """ checkResult = False #CRC from serial message crc = int.from_bytes(serialMessage[14:16], byteorder='little', signed=False) #calculated CRC crcCalc = libscrc.modbus(serialMessage[0:14]) if crc == crcCalc: checkResult = True return checkResult
def read_READY(ser, address): #check if the serial port is open if ser.is_open==False: print("read_READY: serial port not open.") return bytes ([0]) #reset the output buffer before send new data ser.reset_output_buffer #build the modbus message to send out=[address, MODBUS_READ_SINGLE_REGISTER, 0x0, MODBUS_STATE_REGISTER_READY, 0, 0] #calculate and add the CRC out=out + list(struct.pack("<H", libscrc.modbus(bytes(out)))) #send data and read the answer. If any error send the message again before give up. j=0; while j<MAX_ITERATION: write_message(ser,out,address) #read the return message read_data=read_message(address, MODBUS_READ_SINGLE_REGISTER,ser) if not(read_data[0]==0 and len(read_data)==1): #force loop exit j=MAX_ITERATION+1 else: j=j+1 if (read_data[0]==0): print("read_READY: error in reading data") return read_data #the string is valid, check the result. if the data bytes are 0x1 0x0 ready is ok if (read_data[4]==1 and read_data[5]==0): return bytes ([1]) return bytes ([0])
def mbytes(self, cmd, pars, reserved_bytes=0): bss = cmd.encode('ascii') + b''.join( [int(p[1]).to_bytes(p[0], 'little', signed=True) for p in pars]) if reserved_bytes: bss += reserved_bytes * b'\xcc' bss += modbus(bss[4:]).to_bytes(2, 'little') return bss
def crc16(byte): byte = bytes(byte) crc16 = libscrc.modbus( byte ) #b'\x07\x05\x00\x00\xFF\x00') # Estrutura para calculo do CRC bin2str = (hex(crc16)) bin2str = str(bin2str) p = "0x" a1 = bin2str[-2] a2 = bin2str[-1] if a1 == "x": a1 = "0" a = p + a1 + a2 b1 = bin2str[-4] b2 = bin2str[-3] if b1 == "x": b1 = "0" b = p + b1 + b2 return (a, b)
def mainRun(): server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) #server.bind(("192.168.22.167", 9534)) addr = ("192.168.43.78", 20740) POWER_CODE = "off" MODE_CODE = "cold" FAN_CODE = "fan3" TEMP_CODE = 27 POWER = {"on": "55", "off": "AA"} MODE = {"cold": "11", "hot": "22", "auto": "33", "fan": "44", "dry": "55"} FAN = {"fan1": "01", "fan2": "02", "fan3": "03", "autofan": "00"} TEMP = { 16: "00A0", 17: "00AA", 18: "00B4", 19: "00BE", 20: "00C8", 21: "00D2", 22: "00DC", 23: "00E6", 24: "00F0", 25: "00FA", 26: "0104", 27: "010E", 28: "0118", 29: "0122", 30: "012C", 31: "0136", 32: "0140" } if POWER_CODE == "off": command = "01069C4000AA2631" print(command) elif POWER_CODE == "on": command = "01069C4000556671" print(command) else: command = "01109C4000081000" + POWER["on"] + "000000" + MODE[MODE_CODE] + "00" + FAN[FAN_CODE] + "00000000" + \ TEMP[TEMP_CODE] + "0B01" print(command) crc16 = str(hex(libscrc.modbus(bytes.fromhex(command)))) crc16 = crc16[4:] + crc16[2:4] command = command + crc16 print(command) print(len(command)) a = bytes.fromhex( command ) # a = bytes.fromhex('01109C4000081000550000001100010000000000A00B0158d6') # # while data!='q': print(a) server.sendto(a, addr)
def gen_packet(packet): checksum = libscrc.modbus( bytearray(packet)) #[0x01, 0x03, 0xD0, 0x00, 0x00, 0x26,])) # print("Checksum:{:02x}".format((checksum % 0xFFFF),2)) packet.append(int(checksum & 0xFF)) packet.append(int(checksum >> 8)) #res = "" #for x in packet: # res += "0x{:02x}, ".format(x,2) #print("Packet:"+res) return packet
def emuart_unframe(self, bytes): datas = re.findall(b"\xa5\x06([\s\S]*)\xb6\x07", bytes) for data in datas: re_crc = struct.unpack(">H", bytes[-4:-2]) data = data[2:-2] # print(data) # print("crc", re_crc) if re_crc[0] != libscrc.modbus(data): return 0 return data pass
def processRequest(self, req_msg, logged_user): msgs = req_msg.split(';') print("processRequest: ", msgs) if msgs[0] == ">000L": # print("------------ check_login ----------") user_id, err_msg = self.db_custom_user.check_login( msgs[1], msgs[2]) if user_id: print('user_id = ', user_id) reply = "000L;OK;0" crc16 = format(libscrc.modbus(reply.encode()), '04x') return user_id, "<" + reply + ";" + crc16 + '\n', err_msg else: # print('------ bad login or password --------') reply = "000L;Err;2" crc16 = format(libscrc.modbus(reply.encode()), '04x') return None, "<" + reply + ";" + crc16 + '\n', err_msg elif msgs[0] == ">00SD": # print("----------->>> transport_data ----> logged_user = "******"00SD;OK;0" crc16 = format(libscrc.modbus(reply.encode()), '04x') return logged_user, "<" + reply + '\n', err_msg else: # print('---- data nit saved - error ----') reply = "00SD;Err;1" crc16 = format(libscrc.modbus(reply.encode()), '04x') return logged_user, "<" + reply + '\n', err_msg else: # print('--- user not logged ----') reply = "00SD;Err;3" crc16 = format(libscrc.modbus(reply.encode()), '04x') global_vars.main_logger.error("Error: not logged.") return logged_user, "<" + reply + '\n', None else: reply = "00SD;Err;4" crc16 = format(libscrc.modbus(reply.encode()), '04x') return logged_user, "<" + reply + '\n', None
def onRelay(slaveID,chanel,delay): list_of_values = [slaveID, 0x06, 0x00, chanel, 0x06, delay] bytes_of_values = bytes(list_of_values) crc16 = libscrc.modbus(bytes_of_values) crc_lo = crc16 & 0x00ff crc_hi = (crc16 & 0xff00) >> 8 ser = serial.Serial() ser.port = config.comport ser.baudrate = 9600 ser.bytesize = serial.EIGHTBITS ser.parity = serial.PARITY_NONE ser.stopbits = serial.STOPBITS_ONE ser.open() ser.write(serial.to_bytes([slaveID, 0x06, 0x00, chanel, 0x06, delay, crc_lo, crc_hi])) ser.close()
def calc_crc16(inputcommand): """ Calculates the CRC16 error check for the command provided as an argument :param inputcommand: Motor controller command string without any error checking bytes :type inputcommand: string :returns: The CRC16 bytes to append to the end of the command string :rtype: str """ # Uses the libscrc.modbus function to calculate the CRC16 string for input command crc16_modbus = hex(int(crc.modbus(codecs.decode(inputcommand, 'hex'))))[2:].zfill(4) # Strips the hex string of the 0x and reverses the pair order converted_crc16_modbus = ''.join([crc16_modbus[2:4], crc16_modbus[0:2]]) return converted_crc16_modbus
def CalculateCRC(Packet): ModbusData = bytearray([0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) #Read Received Modbus Packet ModbusData[0] = Packet[2] ModbusData[1] = Packet[3] ModbusData[2] = Packet[4] ModbusData[3] = Packet[5] ModbusData[4] = Packet[6] ModbusData[5] = Packet[7] #Read Received Modbus Packet crc16 = libscrc.modbus(ModbusData) CRC1 = (crc16 >> 8) & 0x00FF CRC2 = (crc16) & 0x00FF if Packet[8] == CRC1 and Packet[9] == CRC2: return True else: return False
def writeAndVerify(serialPort, cmd, sleeptime, debugMode=True): # Write command serialPort.write(cmd) # Wait time.sleep(sleeptime) # Read back same # bytes readback = serialPort.read(len(cmd)) if debugMode: print("\twrote %s / read %s" % (binascii.hexlify(cmd), binascii.hexlify(readback))) # Confirm checksum ok data = readback[:-2] crc1 = readback[-2:] crc2 = struct.pack('H', libscrc.modbus(data)) #if debugMode: print("\t\tCRC = %s / %s" % (binascii.hexlify(crc1),binascii.hexlify(crc2))) return crc1 == crc2
def read_command(motor_serial_port, slave_id, function_code, register_address, no_of_registers): """ Read multiple registers e.g. read temperature of driver and motor = read_command(1, 3, 248, 4) """ id = hex(slave_id)[2:].zfill(2) fun_code = hex(function_code)[2:].zfill(2) reg_address = hex(register_address)[2:].zfill(4) n_regs = hex(no_of_registers)[2:].zfill(4) initial_command = "".join([id, fun_code, reg_address, n_regs]) # update crc16 crc16_modbus = hex(int(crc.modbus(codecs.decode(initial_command, 'hex'))))[2:].zfill(4) crc16_check = ''.join([crc16_modbus[2:4], crc16_modbus[0:2]]) command = "".join([id, fun_code, reg_address, n_regs, crc16_check]) # Send the command to the controller motor_serial_port.flushInput() motor_serial_port.flushOutput() motor_serial_port.write(codecs.decode(command, 'hex')) # Read the response time.sleep(0.2) a = motor_serial_port.in_waiting # read response of location response = motor_serial_port.read(size=a) # convert the response into step num #motor_pos = codecs.encode(motor_pos, 'hex') #motor_pos = motor_pos[6:14] #if motor_pos[0:4] == b'ffff': # motor_pos = -1 * (65535 - int(motor_pos[4:], 16)) #else: # try: # motor_pos = int(motor_pos, 16) # except ValueError: # log.info("No response from motor") # motor_pos = None return response
def GetDataFromInverter(txt, len_return): # StartTime=datetime.datetime.now() # local_msg=bytearray() count = 0 while 1: Tx_Enable.on() # time.sleep(0.06) ser.write(txt) ser.flush() Tx_Enable.off() # time.sleep(0.01) local_msg = ( b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' ) local_msg = ser.read(80) # print('Checksum: ',libscrc.modbus(local_msg,0xFFFF),' - ',end='') # print(local_msg) # print(len(local_msg)) """ Here we should check for valid checksum Modbus function expect an array of bytes and not a bytearry My function needs to be adjusted to use array of bytes before the check can be implemented """ if libscrc.modbus(local_msg, 0xFFFF) == 0: # Validate checksum return local_msg count = count + 1 if count > 5: return (b'\x00') ser.close() time.sleep(0.1) ser.open() ser.reset_input_buffer() ser.reset_output_buffer() time.sleep(0.08) # EndTime=datetime.datetime.now() # TimeUsed=EndTime-StartTime # print("Time Used ", TimeUsed.microseconds/1000, " ms") return (b'\x00')
def create_poll_request(self, cmd): logging.debug("{} {}".format("create_poll_request", cmd)) data = None function = self.function_READ device_id = self.PowerDevice.device_id self.poll_register = cmd if cmd == 'SolarPanelAndBatteryState': regAddr = self.SolarPanelAndBatteryState.REG_ADDR readWrd = self.SolarPanelAndBatteryState.READ_WORD elif cmd == 'BatteryParamInfo': regAddr = self.BatteryParamInfo.REG_ADDR readWrd = self.BatteryParamInfo.READ_WORD elif cmd == 'SolarPanelInfo': regAddr = self.SolarPanelInfo.REG_ADDR readWrd = self.SolarPanelInfo.READ_WORD elif cmd == 'ParamSettingData': regAddr = self.ParamSettingData.REG_ADDR readWrd = self.ParamSettingData.READ_WORD elif cmd == 'RegulatorPowerOn': regAddr = self.RegulatorPower.REG_ADDR readWrd = self.RegulatorPower.on function = self.function_WRITE elif cmd == 'RegulatorPowerOff': regAddr = self.RegulatorPower.REG_ADDR readWrd = self.RegulatorPower.off function = self.function_WRITE if regAddr: data = [] data.append(self.PowerDevice.device_id) data.append(function) data.append(self.Int2Bytes(regAddr, 0)) data.append(self.Int2Bytes(regAddr, 1)) data.append(self.Int2Bytes(readWrd, 0)) data.append(self.Int2Bytes(readWrd, 1)) crc = libscrc.modbus(bytearray(data)) data.append(self.Int2Bytes(crc, 1)) data.append(self.Int2Bytes(crc, 0)) logging.debug("{} {} => {}".format("create_poll_request", cmd, data)) return data
def read_REBOOT(ser, address): #check if the serial port is open if ser.is_open==False: return 0 #reset the output buffer before send new data ser.reset_output_buffer out=[address, MODBUS_READ_SINGLE_REGISTER, 0x0, MODBUS_STATE_REGISTER_REBOOT, 0, 0] #calculate and add the CRC out=out + list(struct.pack("<H", libscrc.modbus(bytes(out)))) write_message(system,ser,out,address) time.sleep(5) #close the serial port to be sure it can be used again after sending the reboot command ser.close() #add a delay to be sure the port has been closed time.sleep(2) #re-open serial port ser.open() #add a delay to be sure the port has been opened time.sleep(2) return
def mainRun(): POWER_CODE = "on" MODE_CODE = "cold" FAN_CODE = "fan3" TEMP_CODE = 20 POWER = {"on": "55", "off": "AA"} MODE = {"cold": "11", "hot": "22", "auto": "33", "fan": "44", "dry": "55"} FAN = {"fan1": "01", "fan2": "02", "fan3": "03", "autofan": "00"} TEMP = { 16: "00A0", 17: "00AA", 18: "00B4", 19: "00BE", 20: "00C8", 21: "00D2", 22: "00DC", 23: "00E6", 24: "00F0", 25: "00FA", 26: "0104", 27: "010E", 28: "0118", 29: "0122", 30: "012C", 31: "0136", 32: "0140" } commandTX = "01109C4000081000" + POWER[POWER_CODE] + "000000" + MODE[ MODE_CODE] + "00" + FAN[FAN_CODE] + "00000000" + TEMP[ TEMP_CODE] + "0B01" print(commandTX) crc16 = str( hex( libscrc.modbus( bytes.fromhex( '01109C4000081000550000001100010000000000A00B01')))) crc16 = crc16[4:] + crc16[2:4] commandTX = commandTX + crc16 print(commandTX) k = bytes.fromhex(commandTX) print(k.decode('utf-8'))
def basic_check(data_in, address, modbus_function): data_len=len(data_in) #basic check on data lenght: if the read_data is zero lenght it is an error. Return 0 if data_len==0: #return 0 as error flag return bytes([0]) #consider the last two bytes as the incoming CRC information (calculated by the uC) crc_in=bytes([data_in[data_len-2],data_in[data_len-1]]) #format into an unsigned integer number [crc_in]=struct.unpack('>H', crc_in) #calculate the CRC of the received data crc_calc=libscrc.modbus(data_in[0:data_len-2]) #if the CRC is not correct generate an error if (crc_in!=crc_calc): #return 0 as error flag return bytes([0]) #now check that the multisensor address and function echoed by the mulstisensor match the reqeusted one if data_in[0]!=address or data_in[1]!=modbus_function: return bytes([0]) #the basic check was ok. Return data return data_in
def Validate(self, bs): header = 3 checksum = 2 if bs == None or len(bs) < header + checksum: logging.warning("Invalid BS {}".format(bs)) return False function = bs[1] if function == 6: # Response to write-function. Ignore return True length = bs[2] if len(bs) - (header + checksum) != int(length): logging.warning("Invalid BS (wrong length) {}".format(bs)) return False crc = libscrc.modbus(bytearray(bs[:-2])) check = self.Bytes2Int(bs, offset=len(bs) - 1, length=-2) if crc == check: return True logging.warning("CRC Failed: {} - Check: {}".format(crc, check)) return False
def read_MEASUREMENTS_NAME(ser, address,measure_number): #check if the serial port is open if ser.is_open==False: print("read_MEASUREMENTS_NAME: serial port not open.") return bytes ([0]) #reset the output buffer before send new data ser.reset_output_buffer out=[address, MODBUS_READ_SINGLE_REGISTER, 0x0, MODBUS_DATA_MEASURE_NAMES, 0, measure_number] #calculate and add the CRC out=out + list(struct.pack("<H", libscrc.modbus(bytes(out)))) #send data and read the answer. If any error send the message again before give up. j=0; while j<MAX_ITERATION: write_message(ser,out,address) #read the return message read_data=read_message(address, MODBUS_READ_SINGLE_REGISTER,ser) if not(read_data[0]==0 and len(read_data)==1): return read_data[4:15] else: j=j+1 print("read_MEASUREMENTS_NAME: error in reading data") return read_data
def query(comanda, ser): ''' estructura: [SOH=0x01][COMANDA][CR=0x0d][LF=0x0a][CRC16][EOT=0x04] ''' #trama start trama = bytearray() trama.append(0x01) #SOH byte for ch in comanda: trama.append(ord(ch)) trama.append(0x0d) #CR byte trama.append(0x0a) #LF byte crc = hex(libscrc.modbus(comanda.encode()))[2:] #remove '0x' string for ch in crc: trama.append(ord(ch.upper())) trama.append(0x04) #EOT byte trama.append(0x0a) #LF #trama end print('query =>', trama) #write ser.flush() ser.write(trama) print('resposta =>', ser.readlines())
def read_NUMBER_OF_MEASUREMENTS(ser, address): #check if the serial port is open if ser.is_open==False: print("read_NUMBER_OF_MEASUREMENTS: serial port not open.") return bytes ([0]) #reset the output buffer before send new data ser.reset_output_buffer out=[address, MODBUS_READ_SINGLE_REGISTER, 0x0, MODBUS_DATA_NUMBER_OF_MEASURE, 0, 0] #calculate and add the CRC out=out + list(struct.pack("<H", libscrc.modbus(bytes(out)))) #send data and read the answer. If any error send the message again before give up. j=0; while j<MAX_ITERATION: write_message(ser,out,address) #read the return message read_data=read_message(address, MODBUS_READ_SINGLE_REGISTER,ser) if not(read_data[0]==0 and len(read_data)==1): #the string is valid, check the result. if the data bytes are 0x1 0x0 ready is ok return bytes([read_data[4], read_data[5]]) else: j=j+1 print("read_NUMBER_OF_MEASUREMENTS: error in reading data") return read_data
def emuart_frame(self, bytes): crc_res = libscrc.modbus(bytes) frame = hexStringB2Hex(self.frame_head) + struct.pack('>H', len(bytes)) + bytes + \ struct.pack('>H', crc_res) + hexStringB2Hex(self.frame_tail) return frame
def processBinary(self, bstring): # Process the device reply self._bs = bstring if self._debug: print("hw bb > %s" % self._bs) if len(self.commands): if self._debug: print("last command which expects reply was:", self.commands[0]['cmd']) print("received reply:", self._bs) if (b'errc' or b'errd' or b'errv') in self._bs: print('command', self.commands[0]['cmd'], 'produced error', self._bs) self._buffer = b'' # empty buffer after error r_str = None while True: # check buffer empty and checksum if self._buffer != b'': print( 'warning buffer not empty after expected number of bytes' ) self._buffer = b'' # empty buffer if len(self._bs) > 4 and self.commands[0][ 'status'] == 'sent' and modbus(self._bs[4:]) != 0: r_str = 'checksum failed' self._buffer = b'' break if self.commands[0]['status'] == 'sync': # sync after failed comand r_str = 'sync' if len(self.commands ) > 1 and self.commands[1]['status'] == 'sent': # remove failed command self.commands.pop(0) break r_str = b'' if self.iscom('gsti'): r_str = self.strb(16) + ' ' r_str += self.strb(24) break if self.iscom('gmov'): self.object['speed'] = self.sintb(4) self.object['uspeed'] = self.sintb(1) self.object['accel'] = self.sintb(2) self.object['decel'] = self.sintb(2) self.object['anti_play_speed'] = self.sintb(4) self.object['uanti_play_speed'] = self.sintb(1) if self.commands[0]['status'] != 'sent_status': r_str = 'speed:' + self.object['speed'] + ' ' r_str += 'uspeed:' + self.object['uspeed'] + ' ' r_str += 'accel:' + self.object['accel'] + ' ' r_str += 'decel:' + self.object['decel'] + ' ' r_str += 'anti_play_speed:' + self.object[ 'anti_play_speed'] + ' ' r_str += 'uanti_play_speed:' + self.object[ 'uanti_play_speed'] break if self.iscom('gpos'): self.object['position'] = self.sintb(4) self.object['uposition'] = int(self.sintb(2)) self.object['encposition'] = int(self.sintb(8)) if self.commands[0]['status'] != 'sent_status': r_str = 'pos:' + self.object['position'] + ' ' r_str += 'upos:' + self.object['uposition'] + ' ' r_str += 'encpos:' + self.object['encposition'] break # not recognized command, just pass the output r_str = self._bs break if type(r_str) == str: daemon.messageAll(r_str, self.commands[0]['source']) elif r_str != b'': daemon.messageAll(r_str, self.commands[0]['source']) self.commands.pop(0)
cc = s.readline() if len(cc) > 0: print("<-", cc.hex()) if cc.hex().startswith("ff70"): # received id from battery bat_id = cc[12:15] bat_id_hex = bat_id.hex() if bat_id_hex in bat_dupes: # skip duplicates print("skipping duplicate id ", bat_id_hex) continue bat_dupes.append(bat_id_hex) req = req_bat_active + bat_id + bytes([current_bat_id]) bat_ids.append(current_bat_id) current_bat_id += 1 req = req + libscrc.modbus(req).to_bytes(2, 'little') s.write(req) print("-> ", req.hex(), s.readline().hex(), "# received battery id", bat_id_hex, "assigning bus id", current_bat_id - 1) print(s.readline().hex(), "# response of set active bat id") if len(cc) >= 58 and cc.hex().startswith("0203"): evaluate_battery_status() for reqid in bat_ids: req = bytes([reqid]) + req_data req = req + libscrc.modbus(req).to_bytes(2, 'little') print("->", req.hex(), "# request data from bus id", reqid) s.write(req) cc = s.readline()
def calculate_checksum(*args): # Filter None and empty lists new_args = list(filter(lambda x: x and type(x) is not list, args)) string = b"".join(new_args) return modbus(string) # 16-bit CRC