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()
