def testPayloadBuilderWithRawPayload(self): """ Test basic bit message encoding/decoding """ _coils1 = [ False, False, True, True, False, True, False, False, False, False, False, True, False, False, True, False, False, True, True, True, True, False, False, False, False, True, False, True, False, True, True, False ] _coils2 = [ False, False, False, True, False, False, True, False, False, False, True, True, False, True, False, False, False, True, False, True, False, True, True, False, False, True, True, True, True, False, False, False ] builder = BinaryPayloadBuilder([b'\x12', b'\x34', b'\x56', b'\x78'], repack=True) self.assertEqual(b'\x12\x34\x56\x78', builder.to_string()) self.assertEqual([13330, 30806], builder.to_registers()) c = builder.to_coils() self.assertEqual(_coils1, c) builder = BinaryPayloadBuilder([b'\x12', b'\x34', b'\x56', b'\x78'], byteorder=Endian.Big) self.assertEqual(b'\x12\x34\x56\x78', builder.to_string()) self.assertEqual([4660, 22136], builder.to_registers()) self.assertEqual('\x12\x34\x56\x78', str(builder)) c = builder.to_coils() self.assertEqual(_coils2, c)
def data_update(config, a): context = a[0] while True: for sensor in config['sensors']: # Sensor should be set to Adafruit_DHT.DHT11, # Adafruit_DHT.DHT22, or Adafruit_DHT.AM2302. if sensor['type'] == 'DHT22': sensor_type = Adafruit_DHT.DHT22 elif sensor['type'] == 'DHT11': sensor_type = Adafruit_DHT.DHT11 elif sensor['type'] == 'AM2302': sensor_type = Adafruit_DHT.AM2302 else: raise Exception("Unknown sensor type: " + sensor['type']) pin = int(sensor['pin']) humidity, temperature = Adafruit_DHT.read_retry(sensor_type, pin) if humidity is not None and temperature is not None: builder_t = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Big) builder_h = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Big) builder_t.add_32bit_float(temperature) builder_h.add_32bit_float(humidity) context.setValues(4, int(sensor['address_t']), builder_t.to_registers()) context.setValues(4, int(sensor['address_h']), builder_h.to_registers()) log.info('Temp={0:0.1f}*C Humidity={1:0.1f}%'.format(temperature, humidity)) else: log.warn('Failed to get reading. Try again!')
def testPayloadBuilderWithRawPayload(self): """ Test basic bit message encoding/decoding """ builder = BinaryPayloadBuilder([b'\x12', b'\x34', b'\x56', b'\x78']) self.assertEqual(b'\x12\x34\x56\x78', builder.to_string()) self.assertEqual([13330, 30806], builder.to_registers()) builder = BinaryPayloadBuilder([b'\x12', b'\x34', b'\x56', b'\x78'], byteorder=Endian.Big) self.assertEqual(b'\x12\x34\x56\x78', builder.to_string()) self.assertEqual([4660, 22136], builder.to_registers()) self.assertEqual('\x12\x34\x56\x78', str(builder))
def updateData(self): if self.mode == self.MODE_ANGLE: builder = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Little) builder.add_16bit_int(self.angle) payload = builder.to_registers() self.client.write_register(4, payload[0], unit=self.id) elif self.mode == self.MODE_SPEED: builder = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Little) builder.add_16bit_int(self.speed) payload = builder.to_registers()[0] self.client.write_register(3, payload, unit=self.id)
def prefil_registers(a): context=a[0] # Values to be filled: # 4000 SERIAL NUMBER, length 2, 13070001 HEX # 4002 MeterCode, length 1, 0102 HEX # 4003 Meter ID, Length 1, 0001 # 4004 Baud, Length 1, 9600 # 4005 Protocol Version, Lenth 2, 3.2 # 4007 Software Version, Length 2, 1.18 # 4009 Hardware Version, Length 2, 1.03 # 400B Meter Amps, Length 1, 45 # 400D S0 Rate, Length 2, 1000 # 400F Combination Code, Length 1, 10 (Forward - Reverse) # 4010 LCD LifeCycle, Lenght 1, 01 HEX # 4011 Parity Setting, Length 1, 01 # 4012 Current Direction, Lenght 1, FW ASCII builder = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Big) builder.add_32bit_float(0x13070001) builder.add_16bit_int(0x0102) builder.add_16bit_int(1) builder.add_16bit_int(9600) builder.add_32bit_float(3.2) builder.add_32bit_float(1.18) builder.add_32bit_float(1.03) builder.add_16bit_int(45) # builder.add_16bit_int(0) payload = builder.to_registers() context[0x01].setValues(0x10, 0x4000, payload) # Skip Address builder2 = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Big) builder2.add_32bit_float(1000) builder2.add_16bit_int(10) builder2.add_16bit_int(0x10) builder2.add_16bit_int(01) builder2.add_string('FW') payload2 = builder2.to_registers() context[0x01].setValues(0x10, 0x400D, payload2) # 5000 builder3 = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Big) builder3.add_32bit_float(230) builder3.add_32bit_float(230) builder3.add_32bit_float(230) builder3.add_32bit_float(230) builder3.add_32bit_float(50) payload3 = builder3.to_registers() context[0x01].setValues(0x10, 0x5000, payload3)
def update_register(context, param): values = [] fn_code = HOLDING_REGISTER_FN_CODE if (param == "temperature"): address = TEMPERATURE_REGISTER newvalue = random.randint(TEMP_LO, TEMP_HI) log.debug("new temperatue value: " + str(newvalue)) elif (param == "humidity"): address = HUMIDITY_REGISTER newvalue = random.randint(HUMID_LO, HUMID_HI) log.debug("new humidity value: " + str(newvalue)) elif (param == "pressure"): address = PRESSURE_REGISTER newvalue = random.randint(PRESSURE_LO, PRESSURE_HI) log.debug("new pressure value: " + str(newvalue)) elif (param == "geolati"): address = GEO_LATI_REGISTER newvalue = random.uniform(LATI_LO, LATI_HI) log.debug("new latitude value = " + str(newvalue)) builder = BinaryPayloadBuilder(endian=Endian.Big) builder.add_32bit_float(newvalue) payload = builder.to_registers() context.setValues(fn_code, address, payload) return elif (param == "geolongi"): address = GEO_LONGI_REGISTER newvalue = random.uniform(LONGI_LO, LONGI_HI) log.debug("new longitude value = " + str(newvalue)) builder = BinaryPayloadBuilder(endian=Endian.Big) builder.add_32bit_float(newvalue) payload = builder.to_registers() context.setValues(fn_code, address, payload) return elif (param == "keyop"): address = KEY_OP_REGISTER context.setValues(fn_code, address, [0] * 8) newvalue = random.choice(operations) newvalue = newvalue log.debug("new key operation = " + newvalue) builder = BinaryPayloadBuilder(endian=Endian.Big) builder.add_string(newvalue) payload = builder.to_registers() context.setValues(fn_code, address, payload) return else: return values.append(newvalue) context.setValues(fn_code, address, values)
def set_builder(self): if self.encoding in ['BB', 'ABCD']: self.bpb = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Big) elif self.encoding in ['BL', 'CDAB']: self.bpb = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Little) elif self.encoding in ['LL', 'DCBA']: self.bpb = BinaryPayloadBuilder(byteorder=Endian.Little, wordorder=Endian.Little) elif self.encoding in ['LB', 'BADC']: self.bpb = BinaryPayloadBuilder(byteorder=Endian.Little, wordorder=Endian.Big) else: raise KeyError
def read_holding_registers(self, addr, num, unit): builder = BinaryPayloadBuilder(byteorder=cinergiaByteOrder, wordorder=cinergiaWordOrder) builder.add_32bit_uint(self._mockRegisters[addr]) ret = ReadHoldingRegistersResponse() ret.registers = builder.to_registers() return ret
def write(self, displayName, address, value, dtype=None, bits=None): if dtype: builder = BinaryPayloadBuilder(wordorder=Endian.Big) # This code trick generates and calls methods of PayloadBuilder, # like `builder.add_16bit_int(r['value']) # where 16 = r[bits], int = r['typename'] if dtype == 'string': method_name = "add_string" else: method_name = "add_{0}bit_{1}".format(bits, dtype) getattr(builder, method_name)(value) payload = builder.build() logging.debug("Packed value '{0}' with method {1} into {2}".format( value, method_name, payload)) registers = builder.to_registers() self.mb_client.write_registers(address, registers, unit=1) # self.mb_client.write_registers(address, payload, skip_encode=True, unit=UNIT) else: logging.debug("Wrote value '{0}' to 16bit register as {1}".format(value, int(value))) self.mb_client.write_register(address, int(value), unit=UNIT)
def encode_field(self, value, mb_type='unit16'): builder = BinaryPayloadBuilder(endian=self.endian) if mb_type == 'bit' or mb_type == 'bits': builder.add_bits(value) elif mb_type == 'uint8': builder.add_8bit_uint(value) elif mb_type == 'uint16': builder.add_16bit_uint(value) elif mb_type == 'uint32': builder.add_32bit_uint(value) elif mb_type == 'uint64': builder.add_64bit_uint(value) elif mb_type == 'int8': builder.add_8bit_int(value) elif mb_type == 'int16': builder.add_16bit_int(value) elif mb_type == 'int32': builder.add_32bit_int(value) elif mb_type == 'int64': builder.add_64bit_int(value) elif mb_type == 'float32': builder.add_32bit_float(value) elif mb_type == 'float64': builder.add_64bit_float(value) elif mb_type == 'string' or mb_type == 'str': builder.add_string(value) else: log.warn('Not supported DataType: "%s"' % mb_type) return builder.build()
def __init__(self, env, store): self.byte_order = env["byte_order"] self.word_order = env["word_order"] self.d_s_factor = env["default_scaling_factor"] self.battery_store = store self.builder = BinaryPayloadBuilder(byteorder=self.byte_order, wordorder=self.word_order)
def __init__(self): self.__logging() self.cfg = yamlImport.importYAML("./cfg/modbusSettings.yaml") self.builder = BinaryPayloadBuilder(endian=Endian.Little) self.__setupContext() self.__serverInfo() self.__configureServer()
def encode(self, slave_id, block_name, offset, value, formatter): builder = BinaryPayloadBuilder(byteorder=self.byte_order, wordorder=self.word_order) add_method = ENCODERS.get(formatter) getattr(builder, add_method)(value) payload = builder.to_registers() return self.set_values(slave_id, block_name, offset, payload)
def write_registers(self, key): point = self.point_dict.get(key[2:]) if point: value = conpot_core.get_databus().get_value(key) if not point.encoding == 'none': endian = Endian.Auto if point.endian == 'Little': endian = Endian.Little elif point.endian == 'Big': endian = Endian.Big builder = BinaryPayloadBuilder(endian=endian) builder_map = { 'bits': builder.add_bits, '8unit': builder.add_8bit_uint, '16unit': builder.add_16bit_uint, '32unit': builder.add_32bit_uint, '64unit': builder.add_64bit_uint, '8int': builder.add_8bit_int, '16int': builder.add_16bit_int, '32int': builder.add_32bit_int, '64int': builder.add_64bit_int, '32float': builder.add_32bit_float, '64float': builder.add_64bit_float, 'string': builder.add_string } builder_map[point.encoding](value) payload = [unpack(endian + 'H', x)[0] for x in builder.build()] with lock: return self.modbus_client.write_registers( point.address, payload, unit=point.slave_id) else: with lock: return self.modbus_client.write_registers( point.address, [value], unit=point.slave_id)
async def _write_register_value( self, key: str, value: Union[str, float, int]) -> WriteMultipleRegistersResponse: """Write a single value to the holding registers. Currently registers are written one at a time to avoid issues with discontinuous modbus addresses. """ start_address = self.tags[key]['address']['start'] - 400001 builder = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Little) data_type = self.tags[key]['type'] if data_type == 'float': builder.add_32bit_float(value) elif data_type == 'str': chars = self.tags[key]['length'] if len(value) > chars: raise ValueError(f'{value} is too long for {key}. ' f'Max: {chars} chars') builder.add_string(value.ljust(chars)) elif data_type == 'int16': builder.add_16bit_int(value) elif data_type == 'int32': builder.add_32bit_int(value) else: raise ValueError("Missing data type.") resp = await self.write_registers(start_address, builder.build(), skip_encode=True) return resp[0]
def set_target(self, target): builder = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Big) builder.add_32bit_int(target) request = self.sync_client.write_registers(SET_MOTOR_TARGET, builder.to_registers(), unit=self.address) return not request.isError()
def set_datastore(self): FUNCTION_CODE = 0x04 ADDRESS = 0x00 builder = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Big) builder.add_32bit_float(3.14) self.store.setValues(FUNCTION_CODE, ADDRESS, builder.to_registers())
def setSpeed(self, speed): # Set up aim to speed and set up speed if self.mode != self.MODE_SPEED: self.mode = self.MODE_SPEED builder = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Little) builder.add_16bit_int(int(speed)) payload = builder.to_registers()[0] self.client.write_register(3, payload, unit=self.id)
def setAngle(self, angle): # Set up aim to angle and set up angle if self.mode != self.MODE_ANGLE: self.mode = self.MODE_ANGLE builder = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Little) builder.add_32bit_int(int(angle)) payload = builder.build() self.client.write_registers(4, payload, skip_encode=True, unit=self.id)
def getBinaryPayloadBuilder(byteorderLittle=True,wordorderLittle=False): import pymodbus.version as pymodbus_version from pymodbus.constants import Endian from pymodbus.payload import BinaryPayloadBuilder if byteorderLittle: byteorder = Endian.Little else: byteorder = Endian.Big if wordorderLittle: wordorder = Endian.Little else: wordorder = Endian.Big if pymodbus_version.version.major > 1 or (pymodbus_version.version.major == 1 and pymodbus_version.version.minor > 3): # pymodbus v1.4 and newer return BinaryPayloadBuilder(byteorder=byteorder, wordorder=wordorder) else: # pymodbus v1.3 and older return BinaryPayloadBuilder(endian=byteorder)
def setPWM(self, pwm): # Set up aim to pwm and set up pwm if self.mode != self.MODE_PWM: self.mode = self.MODE_NONE self.mode = self.MODE_PWM builder = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Little) builder.add_16bit_int(int(pwm)) payload = builder.to_registers()[0] self.client.write_register(2, payload, unit=self.id)
def sendFloat(self, value, address): """Send a 32 bit value to the first modbus unit. Parameters: value and address where the value will be stored in. Return: Result if it was successful or not.""" builder = BinaryPayloadBuilder(byteorder=Endian.Big) builder.add_32bit_float(value) payload = builder.build() result = self.modbusClient.write_single_register(address, payload) return result
def change(): #Current address 01 is changed to 09 #01 10 00 00 00 01 02 00 09 66 56 builder = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Little) #builder.add_8bit_uint(0x00) #builder.add_8bit_uint(0x10) #builder.add_8bit_uint(0x00) #builder.add_8bit_uint(0x00) #builder.add_8bit_uint(0x00) #builder.add_8bit_uint(0x01) #builder.add_8bit_uint(0x02) #builder.add_8bit_uint(0x00) #builder.add_8bit_uint(0x09) #builder.add_8bit_uint(0x01) # Unit ID #builder.add_8bit_uint(0x10) # function ID #builder.add_8bit_uint(0x00) #builder.add_8bit_uint(0x00) # coil ID #builder.add_8bit_uint(0x00) # data, here: on #builder.add_8bit_uint(0x01) #builder.add_8bit_uint(0x02) #builder.add_8bit_uint(0x00) #builder.add_8bit_uint(0x09) builder.add_8bit_uint(0x01) # Unit ID builder.add_8bit_uint(0x10) # function ID builder.add_8bit_uint(0x00) builder.add_8bit_uint(0x00) # coil ID builder.add_8bit_uint(0x00) # data builder.add_8bit_uint(0x01) builder.add_8bit_uint(0x02) builder.add_8bit_uint(0x00) builder.add_8bit_uint(0x09) builder.build() utils.appendCrc(builder) print('TMP:', builder) #print(computeCRC(str(builder).encode())) #crc = computeCRC(ut.make_byte_string(builder.to_string())) #print(crc) #hexStr = '%04x' % crc #hex1 = int(hexStr[0] + hexStr[1], 16) #hex2 = int(hexStr[2] + hexStr[3], 16) ##print(hex(hex2)) ##builder.add_8bit_uint(0x66) ##builder.add_8bit_uint(0x56) #builder.add_8bit_uint(hex1) #builder.add_8bit_uint(hex2) return builder.build()
def set_datastore(self): FUNCTION_CODE = 0x04 ADDRESS = 0x00 random_value = random.uniform(0, 10) builder = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Big) builder.add_32bit_float(random_value) self.store.setValues(FUNCTION_CODE, ADDRESS, builder.to_registers()) print('Datastore updated - {0}'.format(random_value))
def modbusWrite(self, address, value): toChange = self._IEEE754reverse(value) toSend = self._changingTheOrder(toChange) builder = BinaryPayloadBuilder(endian=Endian.Little) # That is because of difficulies with the PLC builder.add_32bit_uint((toSend)) payload = builder.build() #result = client.write_registers(address, payload, skip_encode=True) result = self.client.write_registers(address, payload, skip_encode=True)
def write_uint32(self, addr, value): ''' Writes 32 bits unsigned integer value into the cinergia registers :param addr: register address :param value: register value ''' builder = BinaryPayloadBuilder( byteorder=cinergiaByteOrder, wordorder=cinergiaWordOrder) builder.add_32bit_uint(value) registers = builder.to_registers() return self._modbusClient.write_registers(addr, registers, unit=255)
def testPayloadBuilderReset(self): """ Test basic bit message encoding/decoding """ builder = BinaryPayloadBuilder() builder.add_8bit_uint(0x12) builder.add_8bit_uint(0x34) builder.add_8bit_uint(0x56) builder.add_8bit_uint(0x78) self.assertEqual(b'\x12\x34\x56\x78', builder.to_string()) self.assertEqual([b'\x12\x34', b'\x56\x78'], builder.build()) builder.reset() self.assertEqual(b'', builder.to_string()) self.assertEqual([], builder.build())
def Mbus(dop, register): import re from pymodbus.constants import Endian from pymodbus.payload import BinaryPayloadBuilder modDatatemp = re.sub('u' '', '', dop) modDataFloat = float(modDatatemp) #Convert floating point dop to Modbus 32-bit builder = BinaryPayloadBuilder(endian=Endian.Little) builder.add_32bit_float(modDataFloat) payload = builder.to_registers() #Write to Modbus register 40001 context[0x00].setValues(3, register, payload)
def loadsensorconfig(self, filename): d = np.load(filename) builder = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Little) for i in d: builder.add_16bit_int(i) p = builder.build() for i, j in zip(p, range(len(d))): self.client.write_register(30 + j, i, skip_encode=True, unit=self.id)
def _encode_value(self, data, dtype): builder = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Big) try: if dtype == registerDataType.FLOAT32: builder.add_32bit_float(data) else: raise NotImplementedError(dtype) except NotImplementedError: raise return builder.to_registers()