def scan():
parser = argparse.ArgumentParser(description = "Read all holding registries from a TCP MODBUS Slave")
parser.add_argument("ip", help="IP address of the slave")
parser.add_argument("-p", "--port", dest="port", help="Modbus Port. Defaults to 502", type=int, metavar="PORT", default=502)
parser.add_argument("-u", "--uid", dest="uid", help="Modbus Unit ID. Defaults to 1", type=int, metavar="UID", default=1)
parser.add_argument("-sa", "--start-address", dest="start_address", help="Starting Address for the scanner. Defaults to 1", type=int, metavar="START", default=1)
parser.add_argument("-ea", "--end-address", dest="end_address", help="Ending Address for the scanner. Defaults to 65535", type=int, metavar="END", default=65535)
args = parser.parse_args()
try:
ip = args.ip
except IndexError:
print "ERROR: No target to scan\n\n"
parser.print_help()
exit()
# ip address format verification
if not validate_ipv4(ip):
print "ERROR: IP address is invalid\n\n"
parser.print_help()
exit()
print 'Connecting to %s...' % ip,
# connect to modbus slave
client = ModbusTcpClient(ip, args.port)
client.connect()
if client.socket == None:
print "ERROR: Could not connect to %s." %ip
exit()
print ' Connected.'
# TODO add ETA mechanism
results = {}
addr = 1
registers_tested = args.end_address - args.start_address + 1
if registers_tested == 1:
hr = client.read_holding_registers(args.start_address, 1, unit=args.uid) # unit value is device id of the slave (UID)
if hr.function_code == 3: # if we succeed reading stuff
results[addr] = hr.registers[0]
# if it fails, hr.function = 131 (0x83), cf modbus doc
else:
for addr in range(args.start_address, args.end_address):
hr = client.read_holding_registers(addr, 1, unit=args.uid) # unit value is device id of the slave (UID)
if hr.function_code == 3: # if we succeed reading stuff
results[addr] = hr.registers[0]
# if it fails, hr.function = 131 (0x83), cf modbus doc
client.close()
print 'Register scanning is finished (%d registers were tried)' % (registers_tested)
# sorting dict for printing
ordered_results = collections.OrderedDict(sorted(results.items()))
for addr, value in ordered_results.iteritems():
print 'Addr {0} \t{1}'.format(addr,value)
def wren_gw_modbus_read(config):
''' read a value from the peer.
@param config the configuration in the key/value type.
'''
try:
m = ModbusTcpClient(host=config['node'], port=config['port'])
m.connect()
unit = 0xff
if config.has_key('unit_id'):
unit = config['unit_id']
# sed data
value = None
if config['table'] == 'InputRegister':
result = m.read_input_registers(config['address'], 1, unit=unit)
if result:
value = result.registers[config['address']]
if config['table'] == 'HoldingRegister':
result = m.read_holding_registers(config['address'], 1, unit=unit)
if result:
value = result.registers[config['address']]
# close it.
m.close()
return {"status":True, "value":str(value)};
except Exception as e:
return {"status":False, "value":str(e)};
class ModbusModule():
def __init__(self, io_module_name, ip):
logger.debug('Creating new controller with name {} and address {}.'.format(io_module_name, ip))
self.io_module_name = io_module_name
self.ip_address = ip
self.controller_type = CONTROLLER_TYPE.Modbus
# build connection object
self.client = ModbusClient(ip, port=config.DEFAULT_MODBUS_PORT)
self.client.connect()
def __del__(self):
self.client.close()
def __str__(self):
return 'Controller "{}" at address {}'.format(self.io_module_name, self.ip_address)
def get_bit(self, address):
try:
result = self.client.read_coils(address)
bit_value = result.bits[0]
except ConnectionException:
logger.error('Could not connect to Modbus module "{}"!'
.format(self.io_module_name))
bit_value = False
return bit_value
def set_bit(self, address, value):
try:
self.client.write_coil(address, value)
except ConnectionException:
logger.error('Could not connect to Modbus module "{}"!'
.format(self.io_module_name))
def runModBus(IOVariables):
#---------------------------------------------------------------------------#
# choose the client you want
#---------------------------------------------------------------------------#
# make sure to start an implementation to hit against. For this
# you can use an existing device, the reference implementation in the tools
# directory, or start a pymodbus server.
#---------------------------------------------------------------------------#
client = ModbusTcpClient('192.168.1.9')
#rq = client.write_registers(2048, [0])
#rr = client.read_input_registers(000, 1)
#print (rr.registers)
#---------------------------------------------------------------------------#
# configure io card
#---------------------------------------------------------------------------#
#Digital_In_1 = ModbusDigitalInputIOCard(0, client)
#print('IOVariables in modbus.py: {IOVariables} '.format(IOVariables=IOVariables))
Digital_Out_1 = ModbusDigitalOutputIOCard(2048, client, IOVariables)
#---------------------------------------------------------------------------#
# Run io card
#---------------------------------------------------------------------------#
#Digital_In_1.ReadStatus()
#---------------------------------------------------------------------------#
# Run io card
#---------------------------------------------------------------------------#
Digital_Out_1.WriteStatus()
#---------------------------------------------------------------------------#
# close the client
#---------------------------------------------------------------------------#
client.close()
def main():
### setup the client ###
ipaddr = '192.168.201.21'
port = 502
print 'Connecting to', (ipaddr, port)
client = ModbusTcpClient(ipaddr, port=port)
### fetch data ###
try:
reg = client.read_input_registers(0, 8) # data request
vlt = raw2volt(reg.registers) # convert bit to voltage (-10 -- 10[V])
except:
print 'Data fetch error. Finishing...'
client.close()
return
### convert voltage to engineering values ###
meas = vlt # TODO: CHANGE THIS
### show data ###
print 'Raw measurement:', vlt
print 'Engineering value:', meas
### finalizing ###
client.close()
def wren_gw_modbus_write(config, value):
''' write a value to the peer.
@param value a number in the string type.
'''
try:
m = ModbusTcpClient(host=config['node'], port=config['port'])
# XXX
# ModbusTcpClient.connect() does not look to do connect(2) actually.
m.connect()
unit = 0xff
if config.has_key('unit_id'):
unit = config['unit_id']
# send data
result = False
if config['table'] == 'HoldingRegister':
result = m.write_register(config['address'], int(value), unit=unit)
if result.value == int(value):
result = True
# close it.
m.close()
return {"status":True, "value":str(value)};
except Exception as e:
return {"status":False, "value":str(e)};
class TestMbTcpClass1(unittest.TestCase): read_values = range(0xAA50, 0xAA60) write_values = range(0xBB50, 0xBB60) def setUp(self): self.client = ModbusTcpClient(SERVER_HOST) self.client.connect() def tearDown(self): self.client.close() def test_write_single_holding_register(self): rq = self.client.write_register(8, 0xCC) self.assertEqual(rq.function_code, 0x06) rr = self.client.read_holding_registers(8, 1) self.assertEqual(rr.registers[0], 0xCC) rq = self.client.write_register(16, 0x00) self.assertEqual(rq.function_code, 0x86) rq = self.client.write_register(8, 0xAA58) def test_write_coil(self): rq = self.client.write_coil(0, True) self.assertEqual(rq.function_code, 0x05) rq = self.client.write_coil(0, False) self.assertEqual(rq.function_code, 0x05) rq = self.client.write_coil(256, False) self.assertEqual(rq.function_code, 0x85) def test_read_coil(self): coil_read_values = [True, False, True, False, False, True, False, False]
class TestMbTcpClass0(unittest.TestCase): read_values = range(0xAA50, 0xAA60) write_values = range(0xBB50, 0xBB60) def setUp(self): self.client = ModbusTcpClient(SERVER_HOST) self.client.connect() def tearDown(self): self.client.close() def test_read_holding_registers(self): rv = self.client.read_holding_registers(0, 16) self.assertEqual(rv.function_code, 0x03) self.assertEqual(rv.registers, self.read_values) def test_read_holding_registers_exception(self): rv = self.client.read_holding_registers(16, 1) self.assertEqual(rv.function_code, 0x83) self.assertEqual(rv.exception_code, 0x02) def test_write_holding_registers(self): rq = self.client.write_registers(0, self.write_values) self.assertEqual(rq.function_code, 0x10) rr = self.client.read_holding_registers(0, 16) self.assertEqual(rr.registers, self.write_values) rq = self.client.write_registers(0, self.read_values) self.assertEqual(rq.function_code, 0x10) def test_write_holding_registers_exception(self): rq = self.client.write_registers(16, [0x00]) self.assertEqual(rq.function_code, 0x90) self.assertEqual(rq.exception_code, 0x02)
def setDeviceStatus(self, postmsg):
setDeviceStatusResult = True
try:
client = ModbusTcpClient(self.get_variable('address'),port=502)
client.connect()
if (self.get_variable('model')=='VC1000'):
if 'heat_setpoint' in postmsg.keys():
client.write_register(6,int(self.far2cel(float(postmsg.get('heat_setpoint')))*100.0),unit=self.get_variable('slave_id'))
if 'cool_setpoint' in postmsg.keys():
client.write_register(6,int(self.far2cel(float(postmsg.get('cool_setpoint')))*100.0),unit=self.get_variable('slave_id'))
if 'flap_override' in postmsg.keys():
if postmsg.get('flap_override') == 'ON' or postmsg.get('flap_override') == True:
client.write_register(159,1,unit=self.get_variable('slave_id'))
elif postmsg.get('flap_override') == 'OFF' or postmsg.get('flap_override') == False:
client.write_register(159,0,unit=self.get_variable('slave_id'))
if 'flap_position' in postmsg.keys():
client.write_register(160,int(postmsg.get('flap_position')),unit=self.get_variable('slave_id'))
elif (self.get_variable('model')=='M1000'):
if 'heat_setpoint' in postmsg.keys():
client.write_register(187,int(self.far2cel(float(postmsg.get('heat_setpoint')))*100.0),unit=self.get_variable('slave_id'))
if 'cool_setpoint' in postmsg.keys():
client.write_register(188,int(self.far2cel(float(postmsg.get('cool_setpoint')))*100.0),unit=self.get_variable('slave_id'))
if 'outside_damper_position' in postmsg.keys():
client.write_register(274,int(postmsg.get('outside_damper_position')),unit=self.get_variable('slave_id'))
if 'bypass_damper_position' in postmsg.keys():
client.write_register(275,int(postmsg.get('bypass_damper_position')),unit=self.get_variable('slave_id'))
if 'fan_status' in postmsg.keys():
if postmsg.get('fan_status') == 'ON' or postmsg.get('fan_status') == True:
client.write_register(130,2,unit=self.get_variable('slave_id'))
elif postmsg.get('fan_status') == 'OFF' or postmsg.get('fan_status') == False:
client.write_register(130,1,unit=self.get_variable('slave_id'))
if 'cooling_status' in postmsg.keys():
if postmsg.get('cooling_status') == 'ON':
client.write_registers(124,[1,2,2,2],unit=self.get_variable('slave_id'))
elif postmsg.get('cooling_status') == 'OFF':
client.write_registers(124,[0,1,1,1],unit=self.get_variable('slave_id'))
if 'cooling_mode' in postmsg.keys():
if postmsg.get('cooling_mode') == 'None':
client.write_register(10,0,unit=self.get_variable('slave_id'))
elif postmsg.get('cooling_mode') == 'STG1':
client.write_register(10,1,unit=self.get_variable('slave_id'))
elif postmsg.get('cooling_mode') == 'STG2':
client.write_register(10,2,unit=self.get_variable('slave_id'))
elif postmsg.get('cooling_mode') == 'STG3':
client.write_register(10,3,unit=self.get_variable('slave_id'))
elif postmsg.get('cooling_mode') == 'STG4':
client.write_register(10,4,unit=self.get_variable('slave_id'))
if 'heating' in postmsg.keys():
client.write_register(129,int(postmsg.get('heating')),unit=self.get_variable('slave_id'))
client.close()
except:
try:
client.close()
except:
print('Modbus TCP client was not built successfully at the beginning')
setDeviceStatusResult=False
return setDeviceStatusResult
class ModbusConnection(object):
_max_retries_read = 10
_max_retries_write = 3
@property
def max_retries_read(self):
return self._max_retries_read
@property
def max_retries_write(self):
return self._max_retries_write
@property
def client_address(self):
return self.client.host
@property
def client_port(self):
return str(self.client.port)
def __init__(self, client_address, client_port):
self.client = ModbusClient(host = client_address, port = int(client_port))
self.connect_to_client()
def __del__(self):
self.disconnect_from_client()
def connect_to_client(self):
self.client.connect()
def disconnect_from_client(self):
self.client.close()
def read_input_registers(self, address, count, unit):
k = 0
while k < self.max_retries_read:
try:
return self.client.read_input_registers(address = address, count = count, unit = unit).registers
except:
k += 1
sleep(1.5)
def read_holding_registers(self, address, count, unit):
k = 0
while k < self.max_retries_read:
try:
return self.client.read_holding_registers(address = address, count = count, unit = unit).registers
except:
k += 1
sleep(1.5)
def write_register(self, address, unit, value):
k = 0
while k < self.max_retries_write:
try:
return self.client.write_register(address = address, unit = unit, value = value)
except:
k += 1
sleep(1.5)
def get_point_sync(self, point_name):
register = self.point_map[point_name]
client = SyncModbusClient(self.ip_address, port=self.port)
try:
result = register.get_state_sync(client)
except (ConnectionException, ModbusIOException, ModbusInterfaceException):
result = None
finally:
client.close()
return result
def set_point(self, point_name, value):
register = self.get_register_by_name(point_name)
client = SyncModbusClient(self.ip_address, port=self.port)
result = None
try:
result = register.set_state(client, value)
except (ConnectionException, ModbusIOException, ModbusInterfaceException):
result = None
finally:
client.close()
return result
def run(self):
comm=server_addr[random.randint(0,len(serverlist)-1)]
client = ModbusTcpClient(comm, self.port, source_address=(self.ipaddr,0), retries=1, retry_on_empty=True)
while(not self.clientstop.is_set()):
client.write_coil(1, True)
print "coil write from:" + self.ipaddr + " --->" + comm
time.sleep(random.randint(0,3))
print "stopping"
client.socket.shutdown(1)
client.close()
return
def main(argv):
syntax = os.path.basename(__file__) + " -p <first port> -n <number of servers> -i <ip:first port of pump server>"
tcp_port = 502
inj_tcp = "localhost:502"
no_server = 1
try:
opts = getopt.getopt(argv, "hp:n:i:", ["port=", "noserver=","injport="])[0]
except getopt.GetoptError:
print syntax
sys.exit(1)
if len(opts) < 1:
print syntax
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print syntax
sys.exit()
elif opt in ("-i", "--injport"):
inj_tcp = arg
elif opt in ("-p", "--port"):
tcp_port = int(arg)
elif opt in ("-n", "--noserver"):
no_server = int(arg)
port = tcp_port
context_list = []
identity_list = []
address_list = []
splitted = inj_tcp.split(":")
ip_pump = splitted[0]
port_pump = int(splitted[1])
p_prev_client = None
for srv in range(no_server):
p_client = ModbusClient(ip_pump, port=port_pump)
ret = p_client.connect()
if ret:
log.info("connection ok on {0}:{1}".format(ip_pump,port_pump))
p_client.close()
else:
p_client = p_prev_client
log.info("Keep the previous pump on {0}:{1}".format(ip_pump,port_pump-1))
port_pump += 1
address_list.append(("127.0.0.1", port))
port += 1
context = context_factory()
context_list.append(context)
identity_list.append(identity_factory())
time = 1 # 1 seconds delay
loop = LoopingCall(f=updating_writer, a=(context,srv,p_client))
p_prev_client = p_client
loop.start(time, now=False) # initially delay by time
StartMultipleTcpServers(context_list, identity_list, address_list)
class communication:
def __init__(self):
self.client = None
self.lock = threading.Lock()
def connectToDevice(self, address):
"""Connection to the client - the method takes the IP address (as a string, e.g. '192.168.1.11') as an argument."""
self.client = ModbusTcpClient(address)
def disconnectFromDevice(self):
"""Close connection"""
self.client.close()
def sendCommand(self, data):
"""Send a command to the Gripper - the method takes a list of uint8 as an argument. The meaning of each variable depends on the Gripper model (see support.robotiq.com for more details)"""
# make sure data has an even number of elements
if len(data) % 2 == 1:
data.append(0)
# Initiate message as an empty list
message = []
# Fill message by combining two bytes in one register
for i in range(0, len(data) / 2):
message.append((data[2 * i] << 8) + data[2 * i + 1])
# To do!: Implement try/except
with self.lock:
self.client.write_registers(0, message)
def getStatus(self, numBytes):
"""Sends a request to read, wait for the response and returns the Gripper status. The method gets the number of bytes to read as an argument"""
numRegs = int(ceil(numBytes / 2.0))
# To do!: Implement try/except
# Get status from the device
with self.lock:
response = self.client.read_input_registers(0, numRegs)
# Instantiate output as an empty list
output = []
# Fill the output with the bytes in the appropriate order
for i in range(0, numRegs):
output.append((response.getRegister(i) & 0xFF00) >> 8)
output.append(response.getRegister(i) & 0x00FF)
# Output the result
return output
class SynchronousTcpClient(Runner, unittest.TestCase):
'''
These are the integration tests for the synchronous
tcp client.
'''
def setUp(self):
''' Initializes the test environment '''
self.initialize(["../tools/reference/diagslave", "-m", "tcp", "-p", "12345"])
self.client = ModbusClient(port=12345)
def tearDown(self):
''' Cleans up the test environment '''
self.client.close()
self.shutdown()
def search():
client = ModbusClient(HOST,port=PORT,framer=ModbusFramer)
if not client.connect():
logger.error("cannot connect to [%s:%d]." %(HOST,PORT))
n=0
while n<247:
rr=client.read_holding_registers(address=0x015e,count=2,unit=n)
assert(rr.function_code < 0x80)
if rr:
print n
else:
print 'fail',n
n=n+1
client.close()
#search()
def LEDUpdateThread(pin, update_interval, e): print 'LEDUpdateThread' client = ModbusTcpClient(args.ip) GPIO.setup(pin, GPIO.OUT) while True: if not e.isSet(): result = client.read_coils(0, 1) if result is not None: pin_status = result.bits[0] GPIO.output(pin, pin_status) print pin_status time.sleep(update_interval) else: break client.close() print 'LED thread stoped'
def testConnection1(self, button):
lblTest1 = builder.get_object("lblTest1")
manifold_host_1 = builder.get_object("txtIP1").get_text()
manifold_port_1 = int(builder.get_object("txtPort1").get_text())
client_1 = ModbusClient(manifold_host_1, port=manifold_port_1)
self.ret_m1=client_1.connect()
lblTest1.set_text(str(self.ret_m1))
if not smtConfig.has_section('Manifold_1'):
smtConfig.add_section('Manifold_1')
if self.ret_m1:
builder.get_object("switchMain").set_sensitive(True)
smtConfig.set('Manifold_1', 'host', manifold_host_1)
smtConfig.set('Manifold_1', 'port', manifold_port_1)
with open(sCFGName, 'wb') as configfile:
smtConfig.write(configfile)
client_1.close()
def scan():
parser = argparse.ArgumentParser(description = "Write all holding registries on a TCP MODBUS Slave")
parser.add_argument("ip", help="IP address of the slave")
parser.add_argument("-p", "--port", dest="port", help="Modbus Port. Defaults to 502", type=int, metavar="PORT", default=502)
parser.add_argument("-u", "--uid", dest="uid", help="Modbus Unit ID. Defaults to 1", type=int, metavar="UID", default=1)
parser.add_argument("-sa", "--start-address", dest="start_address", help="Starting Address for the writer. Defaults to 1", type=int, metavar="START", default=1)
parser.add_argument("-ea", "--end-address", dest="end_address", help="Ending Address for the writer. Defaults to 65535", type=int, metavar="END", default=65535)
parser.add_argument("-v", "--value", dest="value", help="Value that will be written. Defaults to 7777", type=int, metavar="VALUE", default=7777)
args = parser.parse_args()
try:
ip = args.ip
except IndexError:
print "ERROR: No target given\n\n"
parser.print_help()
exit()
# ip address format verification
if not validate_ipv4(ip):
print "ERROR: IP address is invalid\n\n"
parser.print_help()
exit()
print 'Connecting to %s...' % ip,
# connect to modbus slave
client = ModbusTcpClient(ip, args.port)
client.connect()
if client.socket == None:
print "ERROR: Could not connect to %s." %ip
exit()
print ' Connected.'
# TODO add ETA mechanism
results = []
addr = 1
for addr in range(args.start_address, args.end_address):
hr = client.write_registers(addr, args.value, unit=args.uid) # unit value is device id of the slave (UID)
if hr.function_code == 16: # if we succeeded writing stuff. code = 0x10
results.append(addr)
# if it fails, hr.function = 144 (0x90), cf modbus doc
client.close()
print 'Register writing is finished (%d addresses were tried)' % (args.end_address-args.start_address+1)
print 'Writing was successful on these %d addresses:' % len(results)
print results
def ButtonUpdateThread(pin, update_interval, e): print 'ButtomUpdateThread' client = ModbusTcpClient(ip) # Setup pin mode GPIO.setup(pin, GPIO.IN) while True: if not e.isSet(): pin_status = GPIO.input(pin) print status client.write_coil(20, pin_status) time.sleep(update_interval) else: break client.close() print 'Button Stopped'
class RemoteSlaveContextTest(ContextRunner, unittest.TestCase):
"""
These are the integration tests for using the redis
slave context.
"""
def setUp(self):
""" Initializes the test environment """
self.context = RemoteSlaveContext(client=None) # for the log statment
self.initialize(["../tools/reference/diagslave", "-m", "tcp", "-p", "12345"])
self.client = ModbusTcpClient(port=12345)
self.context = RemoteSlaveContext(client=self.client)
def tearDown(self):
""" Cleans up the test environment """
self.client.close()
self.shutdown()
def get_modbus(properties):
try:
print "Performing an action which may throw an exception."
client = ModbusClient(properties['ip'], port=502)
client.connect()
log.debug(properties['registers'])
log.debug(properties['coils'])
modbus_values = {}
# Get holding registers values
modbus_registers = {}
for i in properties['registers']:
register_start_nb = i.split('-')[0]
register_end_nb = i.split('-')[1]
log.debug('Register start number : %s' % register_start_nb)
log.debug('Register end number : %s' % register_end_nb)
register_count = int(register_end_nb) - int(register_start_nb)
log.debug('Number of registers to read : %s' % register_count)
rr = client.read_holding_registers(int(register_start_nb),register_count, unit=0x01)
modbus_registers[register_start_nb] = rr.registers
log.debug('Registers values : %s' % rr.registers)
# Get coils values
modbus_coils = {}
for i in properties['coils']:
coil_start_nb = i.split('-')[0]
coil_end_nb = i.split('-')[1]
log.debug('Coil start number : ' + register_start_nb)
log.debug('Coil end number : ' + register_end_nb)
coil_count = int(coil_end_nb) - int(coil_start_nb)
log.debug('Number of coils to read : ' + str(coil_count))
rr = client.read_coils(int(coil_start_nb),coil_count, unit=0x01)
modbus_coils[coil_start_nb] = rr.bits
log.debug('Coils values : ' + str(rr.bits))
log.debug('Modbus coils values : ' + str(modbus_coils))
client.close()
modbus_values['registers'] = modbus_registers
modbus_values['coils'] = modbus_coils
log.debug(str(modbus_values))
return modbus_values
except Exception, error:
log.debug('Error connecting to %s' % properties['ip'])
log.debug(str(error))
def TemperatureUpdateThread(update_interval, e):
print 'TemperatureUpdateThread'
client = ModbusTcpClient(ip)
while True:
if not e.isSet():
tfile = open("/sys/bus/w1/devices/28-00000625a0cd/w1_slave")
text = tfile.read()
tfile.close()
secondline = text.split("\n")[1]
temperaturedata = secondline.split(" ")[9]
temperature = float(temperaturedata[2:])
client.write_register(0, temperature)
print (temperature/1000)
time.sleep(update_interval)
else:
break
client.close()
print 'Temperature sensor thread stoped'
def scrape_all(self):
result_dict={}
try:
client = SyncModbusClient(self.ip_address, port=self.port)
result_dict.update(self.scrape_byte_registers(client, True))
result_dict.update(self.scrape_byte_registers(client, False))
result_dict.update(self.scrape_bit_registers(client, True))
result_dict.update(self.scrape_bit_registers(client, False))
except (ConnectionException, ModbusIOException, ModbusInterfaceException) as e:
print ("ERROR: Failed to scrape device at " +
self.ip_address + ":" + str(self.port) + " " +
"ID: " + str(self.slave_id) + str(e))
return None
finally:
client.close()
return result_dict
def RGBLEDUpdateThread(pins, update_interval, e): print 'RGBLEDUpdateThread' client = ModbusTcpClient(ip) # Setup pins mode for i in range(0, 3): GPIO.setup(pins[i], GPIO.OUT) while True: if not e.isSet(): result = client.read_coils(10, 3) print 'RGB LED. R:', result.bits[0], 'G:', result.bits[1], 'B:', result.bits[2] for i in range(0, 3): GPIO.output(pins[i], result.bits[i]) time.sleep(update_interval) else: break client.close() print 'RGB LED Stopped'
def write_register(slave_addr, slave_port, reg_addr, reg_val):
# Call modbustcp client to write register value
client = ModbusTcpClient(host=slave_addr, port=slave_port)
if client.connect() == False:
print "Connection to Modbus slave %s:%d failed" %(slave_addr, slave_port)
return
reply = client.write_register(address=reg_addr, value=reg_val, unit=1)
client.close()
if reply == None:
print "No reply while writing Modbus register"
return
if reply.function_code != 6:
print "Writing Modbus register returned wrong function code"
return
def testBasicSyncTcpClient(self):
''' Test the basic methods for the tcp sync client'''
# receive/send
client = ModbusTcpClient()
client.socket = mockSocket()
self.assertEqual(0, client._send(None))
self.assertEqual(1, client._send('\x00'))
self.assertEqual('\x00', client._recv(1))
# connect/disconnect
self.assertTrue(client.connect())
client.close()
# already closed socket
client.socket = False
client.close()
self.assertEqual("127.0.0.1:502", str(client))
def writeMBholdingregisters(clientIP, register, valuelist):
from pymodbus.client.sync import ModbusTcpClient, ConnectionException
client = ModbusTcpClient(clientIP)
try:
rawresult = client.write_registers(register, valuelist)
except ConnectionException:
statuscode = 7
else:
if 'exception_code' in rawresult.__dict__:
statuscode = rawresult.exception_code
values = []
else:
statuscode = 0
values = valuelist
# result = client.read_holding_registers(register, len(valuelist))
client.close()
result = {'message': messagefrommbstatuscode(statuscode), 'statuscode': statuscode, 'values': values}
return result
def modbus_poller(id, stop_event, config):
log = logging.getLogger("worker-" + str(id))
log.setLevel(logging.DEBUG)
client = ModbusClient(host=config["address"], port=config["port"])
client.connect()
log.info("Worker started")
t_max = -1
while not stop_event.is_set():
log.info("Poller turn")
t0 = time()
address = 0
for i in poll_range(config["num_controls"], config["chunk_size"]):
result = client.read_input_registers(address=address, count=i, unit=1)
address += i
if result is not None:
if result.function_code >= 0x80 and result.function_code != 132:
log.warn("Server returned error!")
print result
stop_event.set()
break
elif result.function_code == 132:
print "Server fault: " + str(result)
sleep(1)
break
t = time() - t0
log.info("Request took " + str(t) + " s")
if t > t_max:
t_max = t
sleep(config["thread"]["interval"])
log.info("Worker shutting down")
log.info("Max worker process time: " + str(t_max))
client.close()
def chart(response):
global building, state
client = ModbusClient(host=IP_MODBUS, port=PORT_MODBUS)
if response.method == "POST":
client.connect()
if response.POST.get("failure"):
# button clicked, send info about failure via MODBUS TCP/IP
client.write_register(19, 5)
elif response.POST.get("repair"):
# button clicked, send info about failure's end via MODBUS TCP/IP
client.write_register(19, 0)
elif response.POST.get("B1"):
building = "B1"
elif response.POST.get("B2"):
building = "B2"
elif response.POST.get("B3"):
building = "B3"
client.close()
if building == "B1":
state = SystemState.objects.all()
elif building == "B2":
state = SystemState_2.objects.all()
elif building == "B3":
state = SystemState_3.objects.all()
temps = list(state.values_list('temperature', flat=True))
recent_temp = 0
if temps:
recent_temp = temps[-1]
client.connect()
write_32b_float(client, 2000, recent_temp)
client.close()
time = state.values_list('date', flat=True)
time_str = [t.strftime("%d-%m %H:%M") for t in time]
return render(response, "main/chart.html", {
'temps': temps,
'time': time_str,
'building': building
})
def data_on_message(client, userdata, message):
global device_in_use
diu1 = device_in_use.decode(
"utf-8") #to convert from binary array to string
topic = message.topic
value = int(message.payload) #Converting the bytearray to integer value.
print('Data received.')
print('Value :', value)
reg = int(reg_config[locals()['diu1']])
UNIT = int(slave_config[locals()['diu1']])
print("Register to write into :\n")
print(reg)
print("Slave unit to write into :\n")
print(UNIT)
mclient = ModbusClient(
host="localhost", port=502,
framer=ModbusRtuFramer) #Initialise the ModbusTcpClient
mclient.connect()
rw = mclient.write_register(reg, value, unit=UNIT)
mclient.close()
def scrape_all(self):
result_dict = {}
try:
client = SyncModbusClient(self.ip_address, port=self.port)
result_dict.update(self.scrape_byte_registers(client, True))
result_dict.update(self.scrape_byte_registers(client, False))
result_dict.update(self.scrape_bit_registers(client, True))
result_dict.update(self.scrape_bit_registers(client, False))
except (ConnectionException, ModbusIOException,
ModbusInterfaceException) as e:
print("ERROR: Failed to scrape device at " + self.ip_address +
":" + str(self.port) + " " + "ID: " + str(self.slave_id) +
str(e))
return None
finally:
client.close()
return result_dict
def testBasicSyncTcpClient(self, mock_select):
''' Test the basic methods for the tcp sync client'''
# receive/send
mock_select.select.return_value = [True]
client = ModbusTcpClient()
client.socket = mockSocket()
self.assertEqual(0, client._send(None))
self.assertEqual(1, client._send(b'\x00'))
self.assertEqual(b'\x00', client._recv(1))
# connect/disconnect
self.assertTrue(client.connect())
client.close()
# already closed socket
client.socket = False
client.close()
self.assertEqual("ModbusTcpClient(127.0.0.1:502)", str(client))
class EthModbusCmd:
def __init__(self, sensorID, IPaddr):
self.sensorID=sensorID
self.slaveAddr=IPaddr
self.client = ModbusTcpClient(host=self.slaveAddr)
def getClient(self):
self.client.close() # kinda a POS
if not self.client.connect(): # make sure it can be re-opened
# TODO: throw exception
pass
return self.client
def execute(self):
# doesn't do anything
pass
def to_JSON_WWW_data(self,readingTime):
# TODO: not supposed to be here, throw an exception
return []
def __del__(self):
self.client.close()
def ModbusTCP(URL, Reg, Value):
#Modbus simple query
#Example strings
#client = ModbusTcpClient('127.0.0.1')
#client.write_coil(1, True)
#print result.bits[0]
#client.close()
#these are with a plus, since the my_data needs to be concatenated with the url
try:
client = ModbusTcpClient(URL)
client.write_register(Reg, Value)
client.close()
#ActionData = 'reg: ' + Reg + ' val: ' + Value
#if (debuging): xbmc.log('Modbus Commander: ModbusTCP: ' + URL + ActionData)
ReturnValue = "success"
#except:
#ActionData = 'reg: ' + Reg + ' val: ' + Value
#if (debuging): xbmc.log('Modbus Commander: ModbusTCP: ' + URL + ActionData + ' Event Failed')
ReturnValue = "fail"
def sim_start_pause_stop(sim_length_min):
IP = '131.243.41.14'
PORT = 503
id = 2
# Connect to client
client = ModbusClient(IP, port=PORT)
try:
# Read simulaiton time
sim_start = client.read_input_registers(1, count=1,
unit=id).registers[0]
print('simulation start time:', sim_start)
# start recording data (sim flag on)
client.write_registers(int(1), int(1), unit=id)
client.write_registers(int(1), int(3),
unit=id) #sets simulation flag to 1 (ON)
w = 1
while w > 0:
sim_cur = client.read_input_registers(1, count=1,
unit=id).registers[0]
if sim_cur - sim_start >= sim_length_min * 60:
break
print('simulation end time', sim_cur)
client.write_registers(int(1), int(0), unit=id)
print('All Done.',
client.read_input_registers(1, count=1, unit=id).registers[0])
except Exception as e:
print(e)
finally:
client.close()
print('client closed')
return
def main():
config_file = 'config.ini'
config = configparser.ConfigParser()
config.read(config_file)
host = config['modbus_host']['host']
port = config['modbus_host']['port']
reg_address = config['register']['address']
reg_count = config['register']['count']
slaves_id_collection = config['slave_id'].items()
client = ModbusTcpClient(host=host, port=port)
for name, slave_id in slaves_id_collection:
try:
sensor_readings = get_sensor_readings(client, reg_address,
reg_count, slave_id)
except pymodbus.exceptions.ConnectionException:
print('Check [modbus_host] config section in config.ini')
sys.exit(1)
else:
print(sensor_readings)
finally:
client.close()
def write(host, dataList, unit):
starterAddress = 14
# print("HERE", host)
try:
client = ModbusTcpClient(host)
except:
print("[X](write)connection failed.")
return False
for registerIndex in range(0, len(dataList)):
try:
print("[-]Write regsiter register:%s (value: %s) to unit: %s." %
(starterAddress + registerIndex, dataList[registerIndex],
unit))
client.write_register(starterAddress + registerIndex,
dataList[registerIndex],
unit=unit)
except:
print("[X]unable to write data to unit:%d" % (unit))
return False
client.close()
return True
def rotate_vertical_stop(self):
register = RegisterMapping(3004, 1)
client = ModbusClient(host='192.168.1.101',
port=3004,
timeout=1,
stopbits=1,
bytesize=8,
parity='N',
baudrate=9600,
framer=ModbusRtuFramer)
# Set motor OFF
coil_stop = register.get_coil_by_name('0001')
stop_address = coil_stop.get_integer_address()
integer_value = int('0')
try:
client.connect()
client.write_register(stop_address, integer_value, unit=1)
client.close()
except pymodbus.exceptions.ConnectionException:
return "No device connected"
def getModbusData(modeAwake, classicHost, classicPort):
global isConnected, modbusClient
try:
if not isConnected:
log.debug("Opening the modbus Connection")
if modbusClient is None:
modbusClient = ModbusClient(host=classicHost, port=classicPort)
#Test for succesful connect, if not, log error and mark modbusConnected = False
modbusClient.connect()
result = modbusClient.read_holding_registers(4163, 2, unit=10)
if result.isError():
# close the client
log.error("MODBUS isError H:{} P:{}".format(classicHost, classicPort))
modbusClient.close()
isConnected = False
return {}
isConnected = True
theData = {}
#Read in all the registers at one time
theData[4100] = getRegisters(theClient=modbusClient,addr=4100,count=44)
theData[4360] = getRegisters(theClient=modbusClient,addr=4360,count=22)
theData[4163] = getRegisters(theClient=modbusClient,addr=4163,count=2)
theData[4209] = getRegisters(theClient=modbusClient,addr=4209,count=4)
theData[4243] = getRegisters(theClient=modbusClient,addr=4243,count=32)
theData[16386]= getRegisters(theClient=modbusClient,addr=16386,count=4)
#If we are snoozing, then give up the connection
#log.debug("modeAwake:{}".format(modeAwake))
if not modeAwake :
log.debug("Closing the modbus Connection, we are in Snooze mode")
modbusClient.close()
isConnected = False
except: # Catch all modbus excpetions
e = sys.exc_info()[0]
log.error("MODBUS Error H:{} P:{} e:{}".format(classicHost, classicPort, e))
try:
modbusClient.close()
isConnected = False
except:
log.error("MODBUS Error on close H:{} P:{}".format(classicHost, classicPort))
return {}
log.debug("Got data from Classic at {}:{}".format(classicHost,classicPort))
#Iterate over them and get the decoded data all into one dict
decoded = {}
for index in theData:
decoded = {**dict(decoded), **dict(doDecode(index, getDataDecoder(theData[index])))}
return decoded
def sim_stop():
IP = '131.243.41.14'
PORT = 503
id = 2
client = ModbusClient(IP, port=PORT)
try:
client.write_registers(int(1), int(0), unit=id)
print('simulation stop time:',client.read_input_registers(1, count=1, unit=id).registers[0])
print('epoch:',time.time())
print(dt.datetime.fromtimestamp(time.time()))
print('All Done.',client.read_input_registers(1, count=1, unit=id).registers[0])
except Exception as e:
print(e)
finally:
client.close()
print('client closed [stop]')
return
def run_sync_client():
client = ModbusClient('localhost', port=5020)
client.connect()
for i in range(5):
log.debug("Reading Coils")
client.read_coils(1, 1 + i, unit=UNIT)
# first param - address: The starting address to read from
# second param - count: The number of coils to read
time.sleep(0.1)
# 100ms przerwy między Reading Coils
log.debug("Reading Coils")
client.read_coils(2, 3 + i, unit=UNIT)
time.sleep(0.1)
log.debug("Write to a Coil")
client.write_coils(1, 4, unit=UNIT)
time.sleep(5)
# 5s przerwy między write coils
log.debug("Write to a Coil")
client.write_coil(4, 3, unit=UNIT)
time.sleep(5)
# log.debug("Read discrete inputs")
# client.read_discrete_inputs(0, 8, unit=UNIT)
# # first param - The starting address to read from
# # second param - The number of discretes to read
#
# log.debug("Write to a holding register and read back")
# client.write_register(1, 10, unit=UNIT)
# # first param - The starting address to write to
# # second param - The value to write to the specified address
#
# log.debug("Read back")
# client.read_holding_registers(1, 1, unit=UNIT)
# # first param - The starting address to read from
# # second param - The number of registers to read
client.close()
class Get_Modbus_Data(object):
def __init__(self):
Config = configparser.ConfigParser()
Config.read("config.ini")
try:
modbus_config = Config["modbus"]
self.IP_ADDRESS = modbus_config.get("ip")
self.START_REGISTER = modbus_config.getint("BASE_ADDRESS")
self.NUM_REGISTERS = modbus_config.getint("NUM_REGISTERS")
self.UNIT_ID = modbus_config.getint("UNIT_ID")
self.names = modbus_config.get("names").split(',')
self.start_offsets = modbus_config.get("start_offsets").split(',')
self.lengths = modbus_config.get("lengths").split(',')
# if
except Exception as e:
# self.logger.error("unexpected error while setting configuration from config_file=%s, error=%s"%(self.config_file, str(e)))
raise e
def initialize_modbus(self):
self.client = ModbusClient(self.IP_ADDRESS)
def get_data(self):
output = {}
for i in range(len(self.names)):
rr = self.client.read_holding_registers(
self.START_REGISTER+int(self.start_offsets[i])-1,
int(self.lengths[i]),
unit=self.UNIT_ID)
dec = BinaryPayloadDecoder.fromRegisters(
rr.registers,
byteorder=Endian.Big,
wordorder=Endian.Little)
output[self.names[i]] = dec.decode_32bit_float()
# print(output)
return output
def kill_modbus(self):
self.client.close()
def writeMBholdingregisters(clientIP, register, valuelist):
from pymodbus.client.sync import ModbusTcpClient, ConnectionException
client = ModbusTcpClient(clientIP)
try:
rawresult = client.write_registers(register, valuelist)
except ConnectionException:
statuscode = 7
else:
if 'exception_code' in rawresult.__dict__:
statuscode = rawresult.exception_code
values = []
else:
statuscode = 0
values = valuelist
# result = client.read_holding_registers(register, len(valuelist))
client.close()
result = {
'message': messagefrommbstatuscode(statuscode),
'statuscode': statuscode,
'values': values
}
return result
def getModbus(config):
rawValue = []
try:
client = ModbusTcpClient(config['modbus_ip'])
# address is -> {in_max: 1, in_min: 2, out_max: 1, out_min: 3}
for address in config['Channels']:
result = client.read_input_registers(address['channel'], 2)
if result:
raw = struct.pack('>HH', result.registers[1],
result.registers[0])
value = struct.unpack('>f', raw)[0]
rawValue.append(calculate(value, address))
client.close()
except ConnectionException:
GPIO.output(ledGreen, GPIO.HIGH)
logger.critical('Error connect to modbus ip: {}'.format(
config['modbus_ip']))
return 'Error'
else:
GPIO.output(ledGreen, GPIO.LOW)
return rawValue
def save_model(self, request, obj, form, change):
print('save_model(): ')
slave = obj.sensor.slave
try:
client = ModbusTcpClient(slave.ip, slave.port)
if obj.sensor.multiplication_factor != 1:
obj.threshold = int(obj.threshold / obj.sensor.multiplication_factor)
print('obj.threshold:', obj.threshold)
value = client.write_register(address=obj.address,
value=obj.threshold,
unit=slave.sid)
if value.isError():
raise Exception(value)
else:
super().save_model(request, obj, form, change)
except Exception as err:
print(err)
raise err # XXX: print error on admin template
finally:
client.close()
def plc_status_check(target):
client = ModbusTcpClient(target, timeout=time_out)
try:
status = client.read_coils(0x00, count=3)
if status.bits == [1, 0, 0, 0, 0, 0, 0, 0]:
status = "Running"
elif status.bits == [0, 1, 0, 0, 0, 0, 0, 0]:
status = "Idle"
elif status.bits == [0, 0, 1, 0, 0, 0, 0, 0]:
status = "Stopped"
else:
status = "Broken"
pass
except ConnectionException:
status = "No connection"
pass
except (ModbusIOException, ParameterException, ModbusException,
InvalidMessageReceivedException, MessageRegisterException,
NoSuchSlaveException, NotImplementedException):
status = "Connection was forcibly closed by the remote host"
pass
client.close()
return status
class ReaderThread(Thread):
def __init__(self, ip_address='localhost', port='5021'):
Thread.__init__(self)
self.alive = Event()
self.alive.set()
self.client = ModbusTcpClient(ip_address, port=port)
def read_device(self):
client = self.client
read = False
data = 0
data_read = client.read_holding_registers(0x00, 1)
data = data_read.registers[0]
read = True
return (read, data)
def run(self):
try:
self.client.connect()
except:
print('not connected')
while self.alive.isSet():
time.sleep(1)
read = False
try:
read, data = self.read_device()
except:
print('lost connection')
if read:
socketio.emit('newvalue', {'number': data})
if self.client:
self.client.close()
def join(self):
self.alive.clear()
Thread.join(self)
def main():
try:
# read values from WAGO PLC
start = timer()
client = ModbusClient(wago_ip, port=502)
try:
client.connect()
values = {}
for name, addr in MODBUS_ADDR.items():
v = read_modbus_float(client, addr)
#print("%s: %.2f" % (name, v))
values.update({name: v})
finally:
client.close()
end = timer()
#pprint.pprint(values)
# add values to the RRD
st = rrdstorage.RrdStorage(rrd_file)
st.add(values)
# create log entry
with open(log_file, 'a') as file:
s = ["%s: %.3f" % (key, values[key]) for key in sorted(values)]
file.write("[%s] OK : query took %.3f sec [ %s ]\n" %
(datetime.now().isoformat(),
(end - start), ", ".join(s)))
print("query took %.3f sec [ %s ]" % ((end - start), ", ".join(s)))
# create the graphs
rd = rrdrender.RrdRender(rrd_file)
rd.render(render_path)
except Exception as e:
with open(log_file, 'a') as file:
file.write("[%s] ERR: %s\n" % (datetime.now().isoformat(), str(e)))
print("error: %s\n" % str(e))
def writeMBcoils(clientIP, coil, valuelist):
from pymodbus.client.sync import ModbusTcpClient, ConnectionException
client = ModbusTcpClient(clientIP)
try:
rawresult = client.write_coils(coil, valuelist)
except ConnectionException:
# print('we were unable to connect to the host')
statuscode = 7
else:
if 'exception_code' in rawresult.__dict__:
statuscode = rawresult.exception_code
values = []
else:
statuscode = 0
values = valuelist
client.close()
result = {
'message': messagefrommbstatuscode(statuscode),
'statuscode': statuscode,
'values': values
}
return result
def activate(self):
rospy.init_node('niryo_node', anonymous=False)
while not rospy.is_shutdown():
if (self.activate_plc == "Activated"):
rospy.loginfo(
"Niryo will do other action, PLC will be deactivated")
self.pub.publish("plc_deactivate")
else:
rospy.loginfo(
"PLC hasn't been activated, Niryo will activate PLC")
self.pub.publish("Activate_plc")
client = ModbusClient("192.168.1.7", port=502)
client.connect()
UNIT = 0x1
print("Escritura de salidas")
rq = client.write_coil(0, [True] * 8, unit=UNIT)
rr = client.read_coils(0, 8, unit=UNIT)
print("Las salidas Q0.0-Q0.7 ", rr.bits)
print("Leer entradas")
rr = client.read_discrete_inputs(0, 8, unit=UNIT)
print("Las entradas I0.0-I0.7 son ", rr.bits)
print("Escritura de un HR")
rq = client.write_register(0, 15, unit=UNIT)
rr = client.read_holding_registers(0, 1, unit=UNIT)
print("HR0 = ", rr.registers)
print("Escritura de varios HR")
rq = client.write_registers(1, [35] * 10, unit=UNIT)
rr = client.read_holding_registers(1, 10, unit=UNIT)
print("HR0 = ", rr.registers)
print("Escritura de varios HR")
rq = client.write_registers(11, [43] * 5, unit=UNIT)
rr = client.read_holding_registers(0, 15, unit=UNIT)
print("HR0 = ", rr.registers)
client.close()
rospy.sleep(1)
def battery_data():
values = {}
# Datentypen der Register "float32","uint64","uint16"
# 'string': decoder.decode_string(8),
# 'float': decoder.decode_32bit_float(),
# '16uint': decoder.decode_16bit_uint(),
# '8int': decoder.decode_8bit_int(),
# 'bits': decoder.decode_bits(),
client = ModbusClient(MODBUS_HOST, port=502)
client.connect()
r = client.read_holding_registers(40327 - 1, 2, unit=1)
inWRte = BinaryPayloadDecoder.fromRegisters(
r.registers, byteorder=Endian.Big) # noqa E501
values['chg_pct'] = inWRte.decode_16bit_uint() / 100
logging.debug("From modbus chg_pct {}%".format(values['chg_pct']))
client.close()
return values
def run_sync_client():
client = ModbusClient('localhost', port=5020)
client.connect()
# ------------------------------------------------------------------------#
# specify slave to query
# ------------------------------------------------------------------------#
# The slave to query is specified in an optional parameter for each
# individual request. This can be done by specifying the `unit` parameter
# which defaults to `0x00`
# ----------------------------------------------------------------------- #
data = getChargeControllerData(client, modbusUnit=0x01)
data2 = getRelayBoxData(client, modbusUnit=0x09)
print( "\nCC: ", data)
print( "\nRB: ", data2)
# ----------------------------------------------------------------------- #
# close the client
# ----------------------------------------------------------------------- #
client.close()
class CovertActuator():
def __init__(self, BIT_NUMBER=0, RESOLUTION=3):
self.BIT_NUMBER = BIT_NUMBER
self.client = ModbusTcpClient('127.0.0.1')
self.encoded_message = []
self.last_value = ''
self.last_time = ''
self.RESOLUTION = RESOLUTION
def meausre_time(self):
return self.last_time
def set_value(self, value=True):
self.last_time = int(str(
time.time()).split('.')[1][:self.RESOLUTION]) % 2
self.client.write_coil(self.BIT_NUMBER, value)
if self.last_value != '' and self.last_value != value and self.last_value == True:
# print ("Covert Actuator: \t", str(time.time()).split('.')[1][:3])
self.encoded_message.append(
str(time.time()).split('.')[1][:self.RESOLUTION])
self.last_value = value
def __del__(self):
self.client.close()
class ModbusClient:
def __init__(self, IP, port):
self.client = ModbusTcpClient(host=IP, port=port)
if (not self.Connect()):
rospy.logerr("Could not connect to the modbus server...")
else:
rospy.loginfo("Connected to host[%s] via port[%s]", IP, port)
def Connect(self):
return self.client.connect()
def Close(self):
self.client.close()
def readRegister(self, address):
response = self.client.read_holding_registers(address, 1, unit=1)
if (response.function_code == 3):
return response.registers[0]
else:
return False
def writeRegister(self, address, data):
response = self.client.write_register(address, data) ## maximum 16 bit
print(response)
class ModbusClient():
''' Connects to modbus slaves '''
def __init__(self, server_addr='localhost', server_port=502):
self.server_ip = server_addr
self.server_port = server_port
self.client = ModbusTcpClient(server_addr, port=server_port)
def open_connection(self):
self.client.connect()
def close_connection(self):
self.client.close()
def read_single_coil(self):
pass
# Assumes 32-bit IEEE floating point number as used by ModbusPal:
# 1 bit sign + 8 bits exponent + 23 bits fraction
def read_holdingregister_float32(self, device_address, register_addr):
translated_addr = register_addr - 1
# read two consecutive registers
result = self.client.read_holding_registers(address=translated_addr,
count=2,
unit=1)
assert (result.function_code < 0x80) # test that we are not an error
msw = result.registers[0]
lsw = result.registers[1]
float32 = (msw << 16) + lsw
value = struct.unpack('f', struct.pack('I', float32))[0]
print "read float32 value:", value
return value
def get_current_energy_production(self) -> float:
for _ in range(10):
client = ModbusTcpClient(self.config['gatewayIP'],
port=self.config['gatewayPort'])
client.connect()
address = self.config['address']
unit = self.config['unit']
factor = self.config.get('factor', 1)
result = client.read_holding_registers(address=address,
count=2,
unit=unit)
client.close()
if not result.isError():
registers = result.registers
decoder = BinaryPayloadDecoder.fromRegisters(
registers, Endian.Big, wordorder=Endian.Big)
raw_value = decoder.decode_32bit_int()
real_value = raw_value * factor
return real_value
else:
self.logger.debug('Cannot read values from modbus, retry...')
self.logger.error('All retries failed to read values for producer %s' %
str(self.config))
return 0
class MB():
def __init__(self, ip, port=502):
self.ip = ip
self.port = port
self.connect()
def connect(self):
self.client = ModbusTcpClient(self.ip, port=self.port, timeout=10)
def read_reg(self):
val = self.client.read_holding_registers(6, 2)
return val.registers
def write_reg(self, value):
self.client.write_register(6, scada_value)
return 0
def deviceinfo(self):
rq = mei_message.ReadDeviceInformationRequest()
val = self.client.execute(rq)
return (val.information)
def close(self):
self.client.close()
def get_device_class(host, port, modbusid):
client = ModbusClient(host=host, port=port)
# connects even within if clause
if client.connect() == False:
print('Modbus Connection Error: Could not connect to', host)
return None
try:
received = client.read_input_registers(address=30051, count=2, unit=3)
except:
thisdate = str(datetime.datetime.now()).partition('.')[0]
thiserrormessage = thisdate + ': Connection not possible. Check settings or connection.'
print(thiserrormessage)
return None
message = BinaryPayloadDecoder.fromRegisters(received.registers,
byteorder=Endian.Big,
wordorder=Endian.Big)
interpreted = message.decode_32bit_uint()
dclass = pvenums["DeviceClass"].get(interpreted)
client.close()
return dclass
