def testSerialServerClose(self):
''' test that the synchronous serial server closes correctly '''
with patch.object(serial, 'Serial') as mock_serial:
instance = mock_serial.return_value
server = ModbusSerialServer(None)
server.server_close()
instance.close.assert_any_call()
def testSerialServerClose(self):
''' test that the synchronous serial server closes correctly '''
with patch.object(serial, 'Serial') as mock_serial:
instance = mock_serial.return_value
server = ModbusSerialServer(None)
server.server_close()
instance.close.assert_any_call()
class MBSerialServer(QThread):
def __init__(self, port, unit, data, baud, par, sec, parent):
super(MBSerialServer, self).__init__(parent)
self.slave = MBSlave(ModbusSequentialDataBlock(1, data[0]),
ModbusSequentialDataBlock(1, data[1]),
ModbusSequentialDataBlock(1, data[2]),
ModbusSequentialDataBlock(1, data[3]))
self.ctx = ModbusServerContext(slaves={unit: self.slave}, single=False)
sb = par == 'N' and 2 or 1
self.server = ModbusSerialServer(self.ctx,
framer=MRF,
port=port,
stopbits=sb,
bytesize=8,
parity=par,
baudrate=baud,
timeout=sec)
print(self.server)
def run(self):
self.server.serve_forever()
def quit(self):
self.server.server_close()
super(MBSerialServer, self).quit()
class MockTracerBN(threading.Thread):
def __init__(self,
serial_port='/dev/pts/4',
json_device_desc_path=DEVICE_JSON_DESC_PATH):
threading.Thread.__init__(self, name='MockTracerBN2')
self._serial_port = serial_port
# Build data backing store from json file.
mappings = json_mapping_parser(json_device_desc_path)
store = ModbusSlaveContext(di=ModbusSparseDataBlock(mappings['di']),
co=ModbusSparseDataBlock(mappings['co']),
ir=ModbusSparseDataBlock(mappings['ir']),
hr=ModbusSparseDataBlock(mappings['hr']))
identity = initialise_device_identity(mappings)
context = ModbusServerContext(slaves=store, single=True)
# RTU:
self.server = ModbusSerialServer(context,
framer=ModbusRtuFramer,
identity=identity,
port=self._serial_port,
timeout=0.001,
baudrate=115200)
def run(self):
self.server.serve_forever()
def stop(self):
if self.server.is_running:
self.server.server_close()
del self.server
class modbusServer():
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 __logging(self):
import logging
logging.basicConfig()
log = logging.getLogger()
log.setLevel(logging.INFO)
def __setupContext(self):
#Setup Coils
co = ModbusSequentialDataBlock(1, [0]*1)
di = ModbusSequentialDataBlock(1, [0]*6)
#Setup Registers (Inc floats)
for i in range(0,3):
self.builder.add_32bit_float(0.0)
ir = ModbusSequentialDataBlock(1, self.builder.to_registers())
for i in range(0,3):
self.builder.add_32bit_float(0.0)
hr = ModbusSequentialDataBlock(1, self.builder.to_registers())
#Setup datastore
store = ModbusSlaveContext(co=co,di=di,hr=hr,ir=ir)
self.context = ModbusServerContext(slaves=store, single=True)
def __serverInfo(self):
self.identity = ModbusDeviceIdentification()
self.identity.VendorName = self.cfg["VendorName"]
self.identity.VendorUrl = self.cfg["VendorUrl"]
self.identity.ProductName = self.cfg["ProductName"]
self.identity.ModelName = self.cfg["ModelName"]
self.identity.MajorMinorRevision = self.cfg["Revision"]
def __getIPAddress(self):
if self.cfg["manualIP"] == "N":
return socket.gethostbyname(socket.gethostname())
return self.cfg["ip"]
def __configureServer(self):
if self.cfg["method"] == "tcp":
self.servTCP = ModbusTcpServer(self.context,
identity=self.identity,
address=(self.__getIPAddress(),
self.cfg["tcpPort"]))
elif self.cfg["method"] == "rtu":
self.servRTU = ModbusSerialServer(self.context,
framer=ModbusRtuFramer,
identity=self.identity,
port=self.cfg["rtuPort"],
stopbits=self.cfg["stopbits"],
bytesize=self.cfg["bytesize"],
parity=self.cfg["parity"],
baudrate=self.cfg["baudrate"],
timeout=self.cfg["timeout"])
else:
raise ReferenceError("Invalid server type")
def runServer(self):
if self.cfg["method"] == "tcp":
self.servTCP.serve_forever()
elif self.cfg["method"] == "rtu":
self.servRTU.serve_forever()
else:
raise ReferenceError("Invalid server type")
def stopServer(self):
if self.cfg["method"] == "tcp":
self.servTCP.server_close()
self.servTCP.shutdown()
elif self.cfg["method"] == "rtu":
self.servRTU.server_close()
else:
raise ReferenceError("Invalid server type")
def encodeData(self,data):
self.builder.reset()
try:
for i in range(0,len(data)):
self.builder.add_32bit_float(data[i])
except TypeError:
self.builder.add_32bit_float(data)
return self.builder.to_registers()
def decodeData(self,data):
returnData = [0]*(len(data)/2)
decoder = BinaryPayloadDecoder.fromRegisters(data, endian=Endian.Little)
for i in range(0,len(data)/2):
returnData[i] = round(decoder.decode_32bit_float(),2)
return returnData
class modbusServer():
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 __logging(self):
import logging
logging.basicConfig()
log = logging.getLogger()
log.setLevel(logging.INFO)
def __setupContext(self):
#Setup Coils
co = ModbusSequentialDataBlock(1, [0] * 1)
di = ModbusSequentialDataBlock(1, [0] * 6)
#Setup Registers (Inc floats)
for i in range(0, 3):
self.builder.add_32bit_float(0.0)
ir = ModbusSequentialDataBlock(1, self.builder.to_registers())
for i in range(0, 3):
self.builder.add_32bit_float(0.0)
hr = ModbusSequentialDataBlock(1, self.builder.to_registers())
#Setup datastore
store = ModbusSlaveContext(co=co, di=di, hr=hr, ir=ir)
self.context = ModbusServerContext(slaves=store, single=True)
def __serverInfo(self):
self.identity = ModbusDeviceIdentification()
self.identity.VendorName = self.cfg["VendorName"]
self.identity.VendorUrl = self.cfg["VendorUrl"]
self.identity.ProductName = self.cfg["ProductName"]
self.identity.ModelName = self.cfg["ModelName"]
self.identity.MajorMinorRevision = self.cfg["Revision"]
def __getIPAddress(self):
if self.cfg["manualIP"] == "N":
return socket.gethostbyname(socket.gethostname())
return self.cfg["ip"]
def __configureServer(self):
if self.cfg["method"] == "tcp":
self.servTCP = ModbusTcpServer(self.context,
identity=self.identity,
address=(self.__getIPAddress(),
self.cfg["tcpPort"]))
elif self.cfg["method"] == "rtu":
self.servRTU = ModbusSerialServer(self.context,
framer=ModbusRtuFramer,
identity=self.identity,
port=self.cfg["rtuPort"],
stopbits=self.cfg["stopbits"],
bytesize=self.cfg["bytesize"],
parity=self.cfg["parity"],
baudrate=self.cfg["baudrate"],
timeout=self.cfg["timeout"])
else:
raise ReferenceError("Invalid server type")
def runServer(self):
if self.cfg["method"] == "tcp":
self.servTCP.serve_forever()
elif self.cfg["method"] == "rtu":
self.servRTU.serve_forever()
else:
raise ReferenceError("Invalid server type")
def stopServer(self):
if self.cfg["method"] == "tcp":
self.servTCP.server_close()
self.servTCP.shutdown()
elif self.cfg["method"] == "rtu":
self.servRTU.server_close()
else:
raise ReferenceError("Invalid server type")
def encodeData(self, data):
self.builder.reset()
try:
for i in range(0, len(data)):
self.builder.add_32bit_float(data[i])
except TypeError:
self.builder.add_32bit_float(data)
return self.builder.to_registers()
def decodeData(self, data):
returnData = [0] * (len(data) / 2)
decoder = BinaryPayloadDecoder.fromRegisters(data,
endian=Endian.Little)
for i in range(0, len(data) / 2):
returnData[i] = round(decoder.decode_32bit_float(), 2)
return returnData
