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 on_switchMain_activate(self, switch,gparam):
if switch.get_active():
self.client_1 = ModbusClient(manifold_host_1, port=manifold_port_1)
self.client_p = ModbusClient(pump_host, port=pump_port)
self.client_1.connect()
self.client_p.connect()
self.readDataSetupConfig()
time.sleep(2)
print "start connection"
time_delay = 1 # 1 seconds delay
self.loop = LoopingCall(f=self.logging_data, a=(self.client_1, builder.get_object("txtAIN1"),builder.get_object("txtAIN2"),builder.get_object("txtAIN1ENG"),builder.get_object("txtAIN2ENG"),builder.get_object("txtAIN12"),builder.get_object("txtAIN22"),builder.get_object("txtAIN1ENG2"),self.client_p,builder.get_object("txtPout"),builder.get_object("txtQout")))
self.loop.start(time_delay, now=False) # initially delay by time
builder.get_object("btnOpenFile").set_sensitive(False)
builder.get_object("btnOff").set_sensitive(False)
self.btnAnalyze.set_sensitive(False)
# self.ani = animation.FuncAnimation(self.figure, self.update_plot, interval = 1000)
else:
self.loop.stop()
time.sleep(1)
self.client_1.close()
self.client_p.close()
print "stop connection"
time.sleep(2)
builder.get_object("txtFilePath").set_text(export_csv_path)
builder.get_object("btnOpenFile").set_sensitive(True)
builder.get_object("btnOff").set_sensitive(True)
if self.oneLogged:
self.btnAnalyze.set_sensitive(True)
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 testTcpClientRegister(self):
class CustomeRequest:
function_code = 79
client = ModbusTcpClient()
client.framer = Mock()
client.register(CustomeRequest)
assert client.framer.decoder.register.called_once_with(CustomeRequest)
def _run_single_client(client_id, host, port, units, results, N, delay, warmup, table):
_log.info('Client %d connecting to %s (%s)', client_id, host, port)
client = ModbusClient(host, port=port)
client.connect()
_log.info('Client %d connected to %s (%s)', client_id, host, port)
measurements = []
errors = []
for i in xrange(N):
if N >= 1000 and i % (N/10) == 0 and i > 0:
_log.info('Client %d %.0f%% complete', client_id, 100.0*i/N)
try:
m = _make_random_request(client, units, table)
if i >= warmup or N <= warmup:
if i == warmup:
_log.info('Client %d warmup complete.', client_id)
measurements.append(m)
except jem_exceptions.JemException, e:
errors.append(e)
_log.warn('Client %d received error response: %s', client_id, e)
except Exception, e:
from pymodbus import exceptions as es
_log.error("Caught other exception: %s" % str(e))
_log.error("Is instance: %s", isinstance(e, es.ModbusException))
def testTcpClientSend(self):
''' Test the tcp client send method'''
client = ModbusTcpClient()
self.assertRaises(ConnectionException, lambda: client._send(None))
client.socket = mockSocket()
self.assertEqual(0, client._send(None))
self.assertEqual(4, client._send('1234'))
def testTcpClientRecv(self):
''' Test the tcp client receive method'''
client = ModbusTcpClient()
self.assertRaises(ConnectionException, lambda: client._recv(1024))
client.socket = mockSocket()
self.assertEqual('', client._recv(0))
self.assertEqual('\x00'*4, client._recv(4))
def connect_modbus(modbus_ip, modbus_port):
try:
client = ModbusClient(modbus_ip, port=modbus_port)
except:
return None
if client.connect():
return client
return None
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 __init__(self, *args, **kwargs):
''' Constructor
default modbus port is 502'''
#ip address
self.addr = args[0]
ModbusTcpClient.__init__(self, self.addr)
self.connect()
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 testTcpClientConnect(self):
''' Test the tcp client connection method'''
with patch.object(socket, 'create_connection') as mock_method:
mock_method.return_value = object()
client = ModbusTcpClient()
self.assertTrue(client.connect())
with patch.object(socket, 'create_connection') as mock_method:
mock_method.side_effect = socket.error()
client = ModbusTcpClient()
self.assertFalse(client.connect())
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 get_temp(self, addr):
# connect to modbus slave
try:
client = ModbusClient(addr, port=502)
client.connect()
rr = client.read_holding_registers(0x00,1,unit=1)
temp = rr.registers[0]
return temp
except:
# if unable to connect, return None
log_stuff("Unable to connect to " + self.addr)
return None
def create_sunspec_sync_client(host):
""" A quick helper method to create a sunspec
client.
:param host: The host to connect to
:returns: an initialized SunspecClient
"""
modbus = ModbusTcpClient(host)
modbus.connect()
client = SunspecClient(modbus)
client.initialize()
return client
def main(host, port, delay, unit, table_num):
client = ModbusClient(host, port=port)
client.connect()
min_response_time = 100
max_response_time = 0
sum_response_time = 0
N = 0
register_widths = diris_registers.TABLES[table_num-1].copy()
register_labels = DEMO_REGISTERS.copy()
registers = dict((addr, register_widths[addr]) \
for addr in DEMO_REGISTERS.keys() \
if addr in register_widths)
label_width = max([len(label) for label in DEMO_REGISTERS.values()]) + 1
while True:
start = time.time()
try:
response = modbus.read_registers(client,
registers=registers,
unit=unit)
except exceptions.ModbusExceptionResponse, e:
response=None
response_time = time.time() - start
os.system('clear')
print "Request Times:"
min_response_time = min(min_response_time, response_time)
max_response_time = max(max_response_time, response_time)
sum_response_time += response_time
N += 1
print "Min".rjust(label_width) + ": " + str(min_response_time)
print "Max".rjust(label_width) + ": " + str(max_response_time)
print "Avg".rjust(label_width) + ": " + str(sum_response_time/N)
print "Response Values:"
for addr in sorted(registers.keys()):
if response is None:
break
print (u"{label:>" + str(label_width) + u"s}: {value:f}").format(
label=register_labels[addr],
value=response.read_register(addr))
print
time.sleep(delay)
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)
def __init__(self, indicator_list, coil_on_list, coil_off_list, command_list, coil_list, port,
method="rtu", timeout=0.1, unit=0x01):
self.unit = unit
self.indicator_list = indicator_list
self.coil_on_list = coil_on_list
self.coil_off_list = coil_off_list
self.coil_list = coil_list
self.command_list = command_list
self.lock = threading.Lock()
if method == "rtu":
self.client = ModbusSerialClient(method=method, port=port, baudrate=19200, stopbits=1, bytesize=8,
timeout=timeout)
elif method == "tcp":
self.client = ModbusTcpClient(host=port)
class TcpRtuChannel(BaseChannel):
def __init__(self, network, channel_name, channel_protocol, channel_params, manager, channel_type):
self.server = channel_params.get("server", "")
self.port = channel_params.get("port", "")
self.modbus_client = None
BaseChannel.__init__(self, network, channel_name, channel_protocol, channel_params, manager, channel_type)
def run(self):
self.modbus_client = ModbusTcpClient(host=self.server, port=self.port)
try:
self.modbus_client.connect()
logger.debug("连接服务器成功.")
except Exception, e:
logger.error("连接服务器失败，错误信息：%r." % e)
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 run(self):
self.modbus_client = ModbusTcpClient(host=self.server, port=self.port)
try:
self.modbus_client.connect()
logger.debug("连接服务器成功.")
except Exception, e:
logger.error("连接服务器失败，错误信息：%r." % e)
def __init__(self, config=None):
ApplicationSession.__init__(self, config)
self.pfcIp = '192.168.1.52'
self.modbusTcpPort = '502'
self.client = ModbusClient(self.pfcIp, self.modbusTcpPort)
self.oldState = {}
self.elapsedTime = 0
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 __init__(self, i, p): self.ip = i self.port = p self.framer = ModbusFramer self.timeout = 1 self.rKeys = [] self.rValues = [] self.rAddress = [] self.rIndex = [] self.errors = [] self.errFlag = False # False = no errors, True = we had errors # Create the client try: if(LOG_LEVEL >= LOG_DEBUG): print "modbus client" self.client = ModbusClient(self.ip, self.port) #self.client = ModbusClient(self.ip, self.port, self.framer, self.timeout) #self.client = ModbusClient(self.ip, self.port, timeout=10) if(LOG_LEVEL >= LOG_DEBUG): print "modbus client connect" rc = self.client.connect() if(rc == False): self.errFlag = True self.errors.append(str()) print "modbus connect returned ", rc else: if(LOG_LEVEL >= LOG_DEBUG): print "modbus connect finished" except Exception, e: print "modbus device initialization exception ", e self.errors.append(str(e)) self.errFlag = True
def start(self):
# Connect the client
self.client = ModbusTcpClient(self.modbus_ip)
logger=logging.getLogger("service")
logger.info("Starting Service: " + self.componentId + " (ModbusIO: " + self.xmlname + ").")
while (GlobalObjects.running):
if(self.client.connect()):
# Check if the output variables changed, if needed send the new state
if (self.state_write_changed):
self.state_write_changed = False
try:
self.client.write_registers(self.modbus_write_adres,self.state_write)
except (AttributeError, ConnectionException):
state_read_new=self.state_read_old
pass
# sleep a while
time.sleep(self.modbus_period)
# try to read new state of the inputs, if connection fails, continue
try:
state_read_new = self.client.read_holding_registers(self.modbus_read_adres,
self.modbus_read_size).registers
except (AttributeError, ConnectionException):
state_read_new=self.state_read_old
pass
# Read check every register for changes
for i in range( len(state_read_new)):
if (state_read_new[i]!=self.state_read_old[i]):
# When the change is in a DI
if (self.modbus_read_type[i]=='D'):
# Mark changed positions
changed=state_read_new[i]^self.state_read_old[i]
for j in range(16):
if((changed >> j) & 1):
# Generate event
eventName=self.configuration["input"]["adres_definition"]["adres"][i]["event_" + str(j)]
self.generateEvent(eventName,{'value':((state_read_new[i]>>j) & 1)})
#print str(time.time()) + " " + str(i) + "." + str(j) + ": " + str((state_read_new[i]>>j) & 1)
## Save the new state
self.state_read_old[i]=state_read_new[i]
# When the change is in a AI
elif (self.modbus_read_type[i]=='A'):
diff = (state_read_new[i]-self.state_read_old[i])
if ((diff>self.modbus_read_analog_threshold[i]) or (diff < -self.modbus_read_analog_threshold[i])):
# Generate event
eventName=self.configuration["input"]["adres_definition"]["adres"][i]["event"]
value = float(state_read_new[i]) / self.modbus_read_analog_scale[i]
self.generateEvent(eventName,{'value':value})
#print str(i) + ": " + str(value)
## Save new state
self.state_read_old[i]=state_read_new[i]
else:
logger.warning("Lost connection to modbus module.")
self.state_write_changed=True
time.sleep(1)
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 main():
# connect to modbus slave
client = ModbusClient(args.slave_addr, port=502)
client.connect()
try:
while True:
# get value of holding registers (first has the temperature value)
rr = client.read_holding_registers(0x00,1,unit=1)
temp = rr.registers[0]
enable_light(temp)
time.sleep(3)
except KeyboardInterrupt:
subprocess.call(['gpio', 'write', '0', '0'])
subprocess.call(['gpio', 'write', '1', '0'])
print "Exiting..."
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 connect(self):
"""Open Modbus connection
"""
if not self.connected:
self.client = ModbusTcpClient("192.168.50.238", port=502)
self.client.connect()
self.connected = True
def __init__(self, ip='192.168.2.17'):
self.ip = ip
self.client = ModbusTcpClient(self.ip)
self.connection = self.client.connect()
import struct
import binascii
import imp
util_path = os.path.abspath(
os.path.join(__file__, '..', '..', 'util', 'solaredge_util.py'))
util = imp.load_source('solaredge_util', util_path)
ipaddress = str(sys.argv[1])
slave1id = int(sys.argv[2])
batwrsame = int(sys.argv[3])
extprodakt = int(sys.argv[4])
from pymodbus.client.sync import ModbusTcpClient
port = util.getPortNo('wr', ipaddress)
client = ModbusTcpClient(ipaddress, port=port)
#batterie auslesen und pv leistung korrigieren
storagepower = 0
if batwrsame == 1:
rr = client.read_holding_registers(62836, 2, unit=1)
raw = struct.pack('>HH', rr.getRegister(1), rr.getRegister(0))
storagepower = int(struct.unpack('>f', raw)[0])
resp = client.read_holding_registers(40084, 2, unit=slave1id)
multipli = resp.registers[0]
multiplint = format(multipli, '04x')
fmultiplint = int(struct.unpack('>h', multiplint.decode('hex'))[0])
respw = client.read_holding_registers(40083, 2, unit=slave1id)
value1w = respw.registers[0]
from pymodbus.client.sync import ModbusTcpClient
client = ModbusTcpClient('10.0.0.57', port=9093)
client.connect()
print(client)
rr = client.read_holding_registers(0, 92, unit=1)
if rr is None:
client.close()
print("Failed to connect")
exit(1)
print("Connected")
voltageScalingFactor = (float(rr.registers[0]) + (float(rr.registers[1]) / 100))
amperageScalingFactor = (float(rr.registers[2]) + (float(rr.registers[3]) / 100))
# Voltage Related Statistics
batteryVoltage = float(rr.registers[24]) * voltageScalingFactor * 2**(-15)
print("Battery Voltage: %.2f" % batteryVoltage)
batterySenseVoltage = float(rr.registers[26]) * voltageScalingFactor * 2**(-15)
print("Battery Sense Voltage: %.2f" % batterySenseVoltage)
batteryVoltageSlow = float(rr.registers[38]) * voltageScalingFactor * 2**(-15)
print("Battery Voltage (Slow): %.2f" % batteryVoltageSlow)
batteryDailyMinimumVoltage = float(rr.registers[64]) * voltageScalingFactor * 2**(-15)
print("Battery Daily Minimum Voltage: %.2f" % batteryDailyMinimumVoltage)
batteryDailyMaximumVoltage = float(rr.registers[65]) * voltageScalingFactor * 2**(-15)
print("Battery Daily Maximum Voltage: %.2f" % batteryDailyMaximumVoltage)
targetRegulationVoltage = float(rr.registers[51]) * voltageScalingFactor * 2**(-15)
print("Target Regulation Voltage: %.2f" % targetRegulationVoltage)
arrayVoltage = float(rr.registers[27]) * voltageScalingFactor * 2**(-15)
print("Array Voltage: %.2f" % arrayVoltage)
# LOGGING
SAVE_TO_FILE = False
LOG_LEVEL = logging.INFO
LOG_FILE_NAME = "modbus.log"
# PROGRAM
if SAVE_TO_FILE:
logging.basicConfig(filename=LOG_FILE_NAME, level=logging.DEBUG)
else:
logging.basicConfig(level=LOG_LEVEL)
if CONNECT_MQTT:
client = mqtt.Client(MQTT_CLIENT_NAME)
client.connect(MQTT_BROKER_NAME)
mbclient = ModbusTcpClient(MODBUS_IP, port=MODBUS_PORT)
mbclient.connect()
while True:
for i in range(3):
rectemp = -999
try:
rec = None
#logging.info("Connected to " + MODBUS_IP + " on Port " + MODBUS_PORT)
rec = mbclient.read_input_registers(MODBUS_REGISTER_ADDRESSES[i],
3)
if rec:
rectemp = rec.registers[2] / 40
logging.info('Received ' + str(rectemp))
except:
#mbclient.close()
logging.warning('Failed to Connect to Modbus')
class Connection():
client = ModbusTcpClient()
def connect(self, ip, port):
self.client.host = ip
self.client.port = port
return self.client.connect()
def disconnect(self):
return self.client.close()
def register_to_int(self, address):
try:
result = self.client.read_holding_registers(address, 1, unit=1).registers
decoder = BinaryPayloadDecoder.fromRegisters(result, byteorder=Endian.Big, wordorder=Endian.Big)
decoded = decoder.decode_16bit_int()
return decoded
except Exception as ex:
print(ex)
def int_to_register(self, address, value):
try:
# Create a builder
builder = BinaryPayloadBuilder(byteorder=Endian.Big, wordorder=Endian.Big)
# Add num to builder
builder.add_16bit_int(value)
payload = builder.to_registers()
payload = builder.build()
registers = builder.to_registers()
# Write value
self.client.write_registers(address, registers, unit=1)
except Exception as ex:
print(ex)
def write_coil(self, address, value):
try:
self.client.write_coil(address, value)
except Exception as ex:
print(ex)
def read_coil(self, address):
try:
return self.client.read_discrete_inputs(address).bits[0]
except Exception as ex:
print(ex)
def read_input_registers(self, address):
try:
result = self.client.read_input_registers(address, 1, unit=1).registers
decoder = BinaryPayloadDecoder.fromRegisters(result, byteorder=Endian.Big, wordorder=Endian.Big)
decoded = decoder.decode_16bit_int()
return decoded
except Exception as ex:
print(ex)
def read_string(self, address, length):
try:
# Read register
result = self.client.read_holding_registers(address, length, unit=1).registers
# Set decoder
decoder = BinaryPayloadDecoder.fromRegisters(result, byteorder=Endian.Big, wordorder=Endian.Big)
# Decode and format
decoded = decoder.decode_string(8)
decoded = decoded.decode('UTF-8')
decoded = decoded.replace("\x00", "")
return decoded
except Exception as ex:
print(ex)
def read_block(client, start, size):
result = []
while size > 0:
to_read = min(
76, size
) # important, only value I found that does not end up in the middle of some big register and thus fails
result += client.read_holding_registers(start, count=to_read,
unit=1).registers
size -= to_read
start += to_read
return bytes(b for i in result for b in [i >> 8, i & 0xff])
client = ModbusTcpClient(host=MODBUSIP, port=MODBUSPORT, timeout=1)
def decode(ty, data):
orig = ty
ty = ty.lower()
if ty == "uint16":
return struct.unpack('!H', data)[0]
elif ty == "int16":
return struct.unpack('!h', data)[0]
elif ty == "uint32":
if orig == "Uint32":
data = bytes([data[2], data[3], data[0], data[1]])
return struct.unpack('!I', data)[0]
elif ty == "acc32":
val = decimals_to_float32(val, next(data_iter))
elif tags[tag]["Data Type"] == "Word":
pass
elif tags[tag]["Data Type"] == "Int":
val = twos_comp(val, 16)
if tags[tag]['scale'] == 'x10':
val /= 10
tags[tag]['value'] = val
return tags
# load file
tags = csv_to_dict('plc_tags.csv')
#connect Modbus
mb = ModbusTcpClient('192.168.11.150', port=502, retries=3, timeout=3)
mb.connect()
#connect ELK
es = Elasticsearch()
#connect MQTT
mqttc = mqtt.Client()
mqttc.connect("test.mosquitto.org", 1883, 60)
#connect settime
time = datetime.now()
while True:
try:
# Read Modbus (ID address,byte of count, MOdbus slave ID)
rr = mb.read_holding_registers(address=0, count=103, unit=1)
assert (rr.function_code < 0x80), "register error"
class client:
"""
Modbus client (Master) class
"""
def __init__(self, client):
self._address = client.modbusclient.ip_address
self._port = client.modbusclient.port
self.trans_input_registers = []
self.trans_coils = []
self.trans_holding_registers = []
self.trans_discrete_inputs = []
self.variables = {}
self._variable_config = self._prepare_variable_config(client)
def _prepare_variable_config(self, client):
for var in client.variable_set.filter(active=1):
if not hasattr(var, 'modbusvariable'):
continue
FC = var.modbusvariable.function_code_read
if FC == 0:
continue
address = var.modbusvariable.address
bits_to_read = get_bits_by_class(var.value_class)
events = Event.objects.filter(variable=var)
self.variables[var.pk] = {
'value_class': var.value_class,
'writeable': var.writeable,
'record': var.record,
'name': var.name,
'adr': address,
'bits': bits_to_read,
'fc': FC,
'events': events
}
if FC == 1: # coils
self.trans_coils.append([address, var.pk, FC])
elif FC == 2: # discrete inputs
self.trans_discrete_inputs.append([address, var.pk, FC])
elif FC == 3: # holding registers
self.trans_holding_registers.append(
[address, var.value_class, bits_to_read, var.pk, FC])
elif FC == 4: # input registers
self.trans_input_registers.append(
[address, var.value_class, bits_to_read, var.pk, FC])
else:
continue
self.trans_discrete_inputs.sort()
self.trans_holding_registers.sort()
self.trans_coils.sort()
self.trans_input_registers.sort()
out = []
# input registers
old = -2
regcount = 0
for entry in self.trans_input_registers:
if (entry[0] != old) or regcount > 122:
regcount = 0
out.append(InputRegisterBlock()) # start new register block
out[-1].insert_item(entry[3], entry[0], entry[1],
entry[2]) # add item to block
old = entry[0] + entry[2] / 16
regcount += entry[2] / 16
# holding registers
old = -2
regcount = 0
for entry in self.trans_holding_registers:
if (entry[0] != old) or regcount > 122:
regcount = 0
out.append(HoldingRegisterBlock()) # start new register block
out[-1].insert_item(entry[3], entry[0], entry[1],
entry[2]) # add item to block
old = entry[0] + entry[2] / 16
regcount += entry[2] / 16
# coils
old = -2
for entry in self.trans_coils:
if (entry[0] != old + 1):
out.append(CoilBlock()) # start new coil block
out[-1].insert_item(entry[1], entry[0])
old = entry[0]
# discrete inputs
old = -2
for entry in self.trans_discrete_inputs:
if (entry[0] != old + 1):
out.append(DiscreteInputBlock()) # start new coil block
out[-1].insert_item(entry[1], entry[0])
old = entry[0]
return out
def _connect(self):
"""
connect to the modbus slave (server)
"""
self.slave = ModbusClient(self._address, int(self._port))
status = self.slave.connect()
return status
def _disconnect(self):
"""
close the connection to the modbus slave (server)
"""
self.slave.close()
def request_data(self):
"""
"""
data = {}
if not self._connect():
return False
for register_block in self._variable_config:
result = register_block.request_data(self.slave)
if result is None:
self._disconnect()
self._connect()
result = register_block.request_data(self.slave)
if result is not None:
data = dict(data.items() + result.items())
else:
for variable_id in register_block.variable_id:
log.error(("variable with id: %d is not accessible") %
(variable_id))
data[variable_id] = None
self._disconnect()
return data
def write_data(self, variable_id, value):
"""
write value to single modbus register or coil
"""
if not self.variables[variable_id]['writeable']:
return False
if self.variables[variable_id]['fc'] == 3:
# write register
if 0 <= self.variables[variable_id]['adr'] <= 65535:
self._connect()
if self.variables[variable_id]['bits'] / 16 == 1:
# just write the value to one register
self.slave.write_register(
self.variables[variable_id]['adr'], int(value))
else:
# encode it first
self.slave.write_registers(
self.variables[variable_id]['adr'],
list(
encode_value(
value,
self.variables[variable_id]['value_class'])))
self._disconnect()
return True
else:
log.error('Modbus Address %d out of range' %
self.variables[variable_id]['adr'])
return False
elif self.variables[variable_id]['fc'] == 1:
# write coil
if 0 <= self.variables[variable_id]['adr'] <= 65535:
self._connect()
self.slave.write_coil(self.variables[variable_id]['adr'],
bool(value))
self._disconnect()
return True
else:
log.error('Modbus Address %d out of range' %
self.variables[variable_id]['adr'])
else:
log.error('wrong function type %d' %
self.variables[variable_id]['fc'])
return False
import networkEncoder as ne
from pymodbus.client.sync import ModbusTcpClient
MODBUS_SLAVE = 'ms.ics.example.com'
random.seed(100)
response = ''
client = ModbusTcpClient(MODBUS_SLAVE)
print("Sensors online, enter injection attack type:")
print("[r]esponse - Fake slave values to trigger overflow")
print("[c]ommand - Fake master values to trigger overflow")
print("[q]uit")
while response != 'r' and response != 'c' and response != 'q':
response = input('>')
if response == 'q':
exit(0)
if response == 'r':
print("Enter stealth level:")
print("[1] - Blatantly obvious")
print("[2] - Plausible")
print("[3] - Harder to detect")
print("[4] - Hard to detect")
print("[q]uit")
while response != '1' and response != '2' and response != '3' and response != '4' and response != 'q':
response = input('>')
from pymodbus.client.sync import ModbusTcpClient
#client = ModbusTcpClient(ipaddress, port=502)
#resp= client.read_holding_registers(32066,1,unit=1)
#value1 = resp.registers[0]
#print(str(value1))
#all = format(value1, '04x') + format(value2, '04x')
#final = int(struct.unpack('>i', all.decode('hex'))[0])*-1
#f = open('/var/www/html/openWB/ramdisk/pvwatt', 'w')
#f.write(str(final))
#f.close()
#print(str(final))
client = ModbusTcpClient(ipaddress, port=502)
resp= client.read_holding_registers(32080,2,unit=1)
value1 = resp.registers[0]
value2 = resp.registers[1]
#print(str(value1))
#print(str(value2))
all = format(value1, '04x') + format(value2, '04x')
final = int(struct.unpack('>i', all.decode('hex'))[0])*-1
f = open('/var/www/html/openWB/ramdisk/pvwatt', 'w')
f.write(str(final))
f.close()
#print(str(final))
def __configure_master(self, config=None):
current_config = self.__config if config is None else config
master_config = dict()
master_config[
"host"] = current_config[HOST_PARAMETER] if current_config.get(
HOST_PARAMETER) is not None else self.__config.get(
HOST_PARAMETER, "localhost")
try:
master_config["port"] = int(
current_config[PORT_PARAMETER]) if current_config.get(
PORT_PARAMETER) is not None else self.__config.get(
int(PORT_PARAMETER), 502)
except ValueError:
master_config[
"port"] = current_config[PORT_PARAMETER] if current_config.get(
PORT_PARAMETER) is not None else self.__config.get(
PORT_PARAMETER, 502)
master_config["baudrate"] = current_config[
BAUDRATE_PARAMETER] if current_config.get(
BAUDRATE_PARAMETER) is not None else self.__config.get(
BAUDRATE_PARAMETER, 19200)
master_config["timeout"] = current_config[
TIMEOUT_PARAMETER] if current_config.get(
TIMEOUT_PARAMETER) is not None else self.__config.get(
TIMEOUT_PARAMETER, 35)
master_config[
"method"] = current_config[METHOD_PARAMETER] if current_config.get(
METHOD_PARAMETER) is not None else self.__config.get(
METHOD_PARAMETER, "rtu")
master_config["stopbits"] = current_config[
STOPBITS_PARAMETER] if current_config.get(
STOPBITS_PARAMETER) is not None else self.__config.get(
STOPBITS_PARAMETER, Defaults.Stopbits)
master_config["bytesize"] = current_config[
BYTESIZE_PARAMETER] if current_config.get(
BYTESIZE_PARAMETER) is not None else self.__config.get(
BYTESIZE_PARAMETER, Defaults.Bytesize)
master_config[
"parity"] = current_config[PARITY_PARAMETER] if current_config.get(
PARITY_PARAMETER) is not None else self.__config.get(
PARITY_PARAMETER, Defaults.Parity)
master_config[
"strict"] = current_config[STRICT_PARAMETER] if current_config.get(
STRICT_PARAMETER) is not None else self.__config.get(
STRICT_PARAMETER, True)
master_config["rtu"] = ModbusRtuFramer if current_config.get(
METHOD_PARAMETER) == "rtu" or (
current_config.get(METHOD_PARAMETER) is None
and self.__config.get(METHOD_PARAMETER)
== "rtu") else ModbusSocketFramer
if self.__previous_master_config != master_config:
self.__previous_master_config = master_config
if current_config.get(TYPE_PARAMETER) == 'tcp' or (
current_config.get(TYPE_PARAMETER) is None
and self.__config.get(TYPE_PARAMETER) == "tcp"):
master = ModbusTcpClient(master_config["host"],
master_config["port"],
master_config["rtu"],
timeout=master_config["timeout"])
elif current_config.get(TYPE_PARAMETER) == 'udp' or (
current_config.get(TYPE_PARAMETER) is None
and self.__config.get(TYPE_PARAMETER) == "udp"):
master = ModbusUdpClient(master_config["host"],
master_config["port"],
master_config["rtu"],
timeout=master_config["timeout"])
elif current_config.get(TYPE_PARAMETER) == 'serial' or (
current_config.get(TYPE_PARAMETER) is None
and self.__config.get(TYPE_PARAMETER) == "serial"):
master = ModbusSerialClient(method=master_config["method"],
port=master_config["port"],
timeout=master_config["timeout"],
baudrate=master_config["baudrate"],
stopbits=master_config["stopbits"],
bytesize=master_config["bytesize"],
parity=master_config["parity"],
strict=master_config["strict"])
else:
raise Exception("Invalid Modbus transport type.")
else:
master = self.__current_master
available_functions = {
1: master.read_coils,
2: master.read_discrete_inputs,
3: master.read_holding_registers,
4: master.read_input_registers,
5: master.write_coil,
6: master.write_register,
15: master.write_coils,
16: master.write_registers,
}
return master, available_functions
__author__ = 'alvin'
import sys
from PyQt5 import QtCore, QtGui, QtWidgets
from PyQt5.QtCore import pyqtSlot
from PyQt5.QtWidgets import QApplication, QWidget, QSlider
import PyQt5.QtCore
from PyQt5.QtCore import QTimer
# Create a Modbus TCP/IP Client
from pymodbus.client.sync import ModbusTcpClient
client = ModbusTcpClient('192.168.0.10')
# import the class 'Ui_batt' from 'battUI.py'
from bidircontrolUI import Ui_bidirControl
# import the class 'bidir' from 'bidirpymodbus.py'
from bidirpymodbus import bidir
# import the class 'panel3' from 'panel3pymodbus.py'
# from panel3pymodbus import panel3
class Mainbidir(QWidget, Ui_bidirControl):
def update_bidir_array(self):
bidir.bidir_array(self)
# panel3.p3_dc1_real_array(self)
def update_bidir_gui(self):
self.bidir_vdc.setText("" + str(self.BiDirCon_Vdc))
protocol_log = logging.getLogger("pysnmp.protocol")
store_log = logging.getLogger("pysnmp.store")
# Enable logging levels
server_log.setLevel(logging.DEBUG)
protocol_log.setLevel(logging.DEBUG)
client_log.setLevel(logging.DEBUG)
store_log.setLevel(logging.DEBUG)
# Initialize the logging
try:
logging.basicConfig()
except Exception, e:
print "Logging is not supported on this system"
from pymodbus.client.sync import ModbusTcpClient
import sys
client = ModbusTcpClient("10.10.10.1")
result = client.read_holding_registers(6, 1)
print(result.registers)
result2 = client.read_holding_registers(7, 1)
print(result2.registers)
from pymodbus import mei_message
rq = mei_message.ReadDeviceInformationRequest()
result3 = client.execute(rq)
print(result3.information)
client.close()
def __init__(self, ip_address='localhost', port='5021'):
Thread.__init__(self)
self.alive = Event()
self.alive.set()
self.client = ModbusTcpClient(ip_address, port=port)
import sys
import os
import time
import getopt
import socket
import struct
import binascii
import json
devicenumber = str(sys.argv[1])
seradd = str(sys.argv[2])
sdmid = int(sys.argv[3])
port = int(sys.argv[4])
from pymodbus.client.sync import ModbusTcpClient
client = ModbusTcpClient(seradd, port=port)
#KWH Total Import
resp = client.read_input_registers(0x0048, 2, unit=sdmid)
vwh = struct.unpack('>f', struct.pack('>HH', *resp.registers))
vwh2 = float("%.3f" % vwh[0]) * int(1000)
vwh3 = str(vwh2)
#Aktueller Verbrauch
resp = client.read_input_registers(0x000C, 2, unit=sdmid)
watti = struct.unpack('>f', struct.pack('>HH', *resp.registers))
watt = int(watti[0])
answer = '{"power":' + str(watt) + ',"powerc":' + str(vwh3) + '} '
f1 = open(
'/var/www/html/openWB/ramdisk/smarthome_device_ret' + str(devicenumber),
#!/usr/bin/python
import sys
import os
import time
import getopt
import socket
import ConfigParser
import struct
import binascii
ipaddress = str(sys.argv[1])
slave1id = int(sys.argv[2])
from pymodbus.client.sync import ModbusTcpClient
client = ModbusTcpClient(ipaddress, port=502)
#batterie auslesen und pv leistung korrigieren
resp= client.read_holding_registers(40084,2,unit=slave1id)
multipli = resp.registers[0]
multiplint = format(multipli, '04x')
fmultiplint = int(struct.unpack('>h', multiplint.decode('hex'))[0])
respw= client.read_holding_registers(40083,2,unit=slave1id)
value1w = respw.registers[0]
allw = format(value1w, '04x')
rawprodw = finalw = int(struct.unpack('>h', allw.decode('hex'))[0]) * -1
resp= client.read_holding_registers(40084,2,unit=slave1id)
mult2ipli = resp.registers[0]
mult2iplint = format(mult2ipli, '04x')
fmult2iplint = int(struct.unpack('>h', mult2iplint.decode('hex'))[0])
if fmultiplint == fmult2iplint:
if fmultiplint == 0:
rawprodw = rawprodw
class modbus:
def __init__(self, Pid, IP):
# Class Variablen
self._IP = IP
self._client = ''
self._pid = Pid
# Plenticore als Modbus Client einrichten
self._client = ModbusTcpClient(self._IP, port=1502)
#self._wr.client.connect()
def ReadRegister(self, address, count=1, **kwargs):
return self._client.read_holding_registers(address, count, **kwargs)
def ReadUInt16(self, addr):
data = self._client.read_holding_registers(addr, 1, unit=71)
UInt16register = BinaryPayloadDecoder.fromRegisters(
data.registers, byteorder=Endian.Big, wordorder=Endian.Little)
result = UInt16register.decode_16bit_uint()
return (result)
def ReadInt16(self, addr):
data = self._client.read_holding_registers(addr, 1, unit=71)
Int16register = BinaryPayloadDecoder.fromRegisters(
data.registers, byteorder=Endian.Big, wordorder=Endian.Little)
result = Int16register.decode_16bit_int()
return (result)
def ReadUInt32(self, addr):
data = self._client.read_holding_registers(addr, 2, unit=71)
UInt32register = BinaryPayloadDecoder.fromRegisters(
data.registers, byteorder=Endian.Big, wordorder=Endian.Little)
result = UInt32register.decode_32bit_uint()
return (result)
def ReadInt32(self, addr):
data = self._client.read_holding_registers(addr, 2, unit=71)
Int32register = BinaryPayloadDecoder.fromRegisters(
data.registers, byteorder=Endian.Big, wordorder=Endian.Little)
result = Int32register.decode_32bit_int()
return (result)
def ReadFloat32(self, addr):
data = self._client.read_holding_registers(addr, 2, unit=71)
Float32register = BinaryPayloadDecoder.fromRegisters(
data.registers, byteorder=Endian.Big, wordorder=Endian.Little)
result = Float32register.decode_32bit_float()
return (result)
def ReadUInt64(self, addr):
data = self._client.read_holding_registers(addr, 4, unit=71)
UInt64register = BinaryPayloadDecoder.fromRegisters(
data.registers, byteorder=Endian.Big, wordorder=Endian.Little)
result = UInt64register.decode_64bit_uint()
return (result)
def ReadString(self, addr):
data = self._client.read_holding_registers(addr, 8, unit=71)
Stringregister = BinaryPayloadDecoder.fromRegisters(
data.registers, byteorder=Endian.Big, wordorder=Endian.Little)
result = Stringregister.decode_string(8)
return (result)
def setstat(ip,status):
file_ip= '/var/www/html/openWB/ramdisk/keba_' + ip
f1 = open(file_ip, 'w')
f1.write(str(status))
f1.close()
if os.path.isfile(file_string):
f = open( file_string , 'a')
else:
f = open( file_string , 'w')
ipaddress=str(sys.argv[1])
newcurr=int(sys.argv[2])
client = ModbusTcpClient(ipaddress, port=502)
# maxcurr state 1100
resp= client.read_holding_registers(1100,2,unit=255)
decoder = BinaryPayloadDecoder.fromRegisters(resp.registers,byteorder=Endian.Big,wordorder=Endian.Big)
final = float( decoder.decode_32bit_uint()) / 1000
oldcurr = int("%.f" % final)
# cabel state 1004
resp= client.read_holding_registers(1004,2,unit=255)
decoder = BinaryPayloadDecoder.fromRegisters(resp.registers,byteorder=Endian.Big,wordorder=Endian.Big)
final2 = float( decoder.decode_32bit_uint())
plugs = "%.f" % final2
# max supported curr 1110
resp= client.read_holding_registers(1110,2,unit=255)
class PataraControl(object):
def __init__(self, ip="172.16.109.70", port=502, slave_id=1):
self.client = None
self.connected = False
self.read_len = 64
self.ip = ip
self.port = port
self.slave_id = slave_id
self.patara_data = pp.PataraHardwareParameters()
self.command_queue = Queue.Queue()
self.lock = threading.Lock()
self.response_pending = False
self.queue_pending_deferred = None
self.state = "unknown"
self.com0_state = "unknown"
self.channel1_state = "unknown"
self.shutter_state = False
self.status = ""
self.active_fault_list = list()
self.active_interlock_list = list()
self.setup_attr_params = dict()
# self.setup_attr_params["shutter"] = False
# self.setup_attr_params["emission"] = False
# self.setup_attr_params["channel1_active_current"] = 13.4
self.standby_polling_attrs = dict()
self.standby_polling_attrs["input_registers"] = 0.3
self.standby_polling_attrs["status"] = 0.3
self.standby_polling_attrs["control"] = 0.5
self.active_polling_attrs = dict()
self.active_polling_attrs["input_registers"] = 0.3
self.active_polling_attrs["status"] = 0.3
self.active_polling_attrs["control"] = 0.5
self.state_notifier_list = list()
self.logger = logging.getLogger("PataraControl")
while len(self.logger.handlers):
self.logger.removeHandler(self.logger.handlers[0])
# f = logging.Formatter("%(asctime)s - %(module)s. %(funcName)s - %(levelname)s - %(message)s")
f = logging.Formatter(
"%(asctime)s - %(name)s. %(funcName)s - %(levelname)s - %(message)s"
)
fh = logging.StreamHandler()
fh.setFormatter(f)
self.logger.addHandler(fh)
self.logger.setLevel(logging.INFO)
def init_client(self):
"""
Initialize the connection with patara modbus device.
:return:
"""
self.logger.info("Initialize client connection")
self.close_client()
self.client = ModbusClient(self.ip, self.port)
d = TangoTwisted.defer_to_thread(self.client.connect)
d.addCallback(self.init_client_cb)
d.addErrback(self.command_error)
return d
def init_client_cb(self, result):
if result is True:
self.connected = True
else:
self.connected = False
return self.connected
def close_client(self):
"""
Close connection to client
:return:
"""
self.logger.info("Close connection to client")
with self.lock:
self.command_queue = Queue.Queue()
self.cancel_queue_cmd_from_deferred(self.queue_pending_deferred)
self.queue_pending_deferred = None
if self.client is not None:
self.client.close()
self.client = None
self.connected = False
def read_coils(self):
for r in self.patara_data.coil_read_range:
d = TangoTwisted.defer_to_thread(self.client.read_coils,
address=r[0],
count=r[1] - r[0] + 1,
unit=self.slave_id)
return d
def read_control_state_queue_cmd(self):
"""
Read essential control bits from function 01, such as emission, standby, shutter
:return:
"""
min_addr = self.patara_data.coil_read_range[0][0]
max_addr = self.patara_data.coil_read_range[0][1]
self.logger.debug("Reading control state from {0} to {1}".format(
min_addr, max_addr))
d = TangoTwisted.defer_to_thread(self.client.read_coils,
min_addr,
max_addr - min_addr + 1,
unit=self.slave_id)
d.addCallbacks(self.process_control_state, self.client_error)
return d
def read_status_queue_cmd(self):
"""
Read status bit from function 02.
:return:
"""
min_addr = self.patara_data.discrete_input_read_range[0][0]
max_addr = self.patara_data.discrete_input_read_range[0][1]
self.logger.debug("Reading status from {0} to {1}".format(
min_addr, max_addr))
d = TangoTwisted.defer_to_thread(self.client.read_discrete_inputs,
min_addr,
max_addr - min_addr + 1,
unit=self.slave_id,
canceller=self.dummy_canceller)
d.addCallbacks(self.process_status, self.client_error)
return d
def defer_to_queue(self, f, *args, **kwargs):
self.logger.debug(
"Deferring {0} with args {1}, kwargs {2} to queue".format(
f, args, kwargs))
d = defer.Deferred(canceller=self.cancel_queue_cmd_from_deferred)
# cmd = (d, f, args, kwargs)
# cmd = d
# d.addCallback(f, args, kwargs)
# with self.lock:
# self.command_queue.put(cmd)
# return d
#
d.addCallback(self.queue_cb, f, *args, **kwargs)
with self.lock:
self.command_queue.put(d)
return d
def cancel_queue_cmd_from_deferred(self, d):
self.logger.info("Cancelling {0}".format(d))
if isinstance(d, defer.Deferred):
cmd_list = list()
with self.lock:
while self.command_queue.empty() is False:
cmd = self.command_queue.get_nowait()
if cmd != d:
cmd_list.append(cmd)
else:
self.logger.info("Found deferred in list. Remove it.")
for cmd in cmd_list:
self.command_queue.put(cmd)
def dummy_canceller(self, d):
self.logger.info("Dummy cancelling {0}".format(d))
def queue_cb(self, d_called, f, *args, **kwargs):
"""
Start thread running function. Copy callbacks from calling
deferred and clear them from the calling deferred, stalling
callback execution until the thread completes.
:param d_called: Result from callback of d_callback (it sends itself as result)
:param f: Function to execute in thread
:param args: Arguments to function
:param kwargs: Keyword arguments to function
:return: Nada
"""
d = TangoTwisted.defer_to_thread(f,
canceller=self.dummy_canceller,
*args,
**kwargs)
d.callbacks = d_called.callbacks
d.addCallbacks(self.command_done, self.command_error)
d_called.callbacks = []
def process_queue(self):
if self.response_pending is False:
try:
with self.lock:
if self.command_queue is not None:
d_cmd = self.command_queue.get_nowait()
except Queue.Empty:
# self.logger.debug("Queue empty. Exit processing")
return
self.queue_pending_deferred = d_cmd
self.logger.debug("Deferring {0}".format(d_cmd))
self.response_pending = True
d_cmd.callback(d_cmd)
def add_command(self, d_cmd):
"""
Add a deferred with command function as callback.
*DO NOT USE* - use defer to queue instead
:param d_cmd: Deferred with command as callback
:return:
"""
self.logger.info("Adding command {0} to queue".format(str(d_cmd)))
with self.lock:
self.command_queue.put(d_cmd)
def command_done(self, response):
self.logger.debug("Command done.")
self.response_pending = False
try:
if self.queue_pending_deferred.called is False:
self.queue_pending_deferred.callback(response)
except defer.AlreadyCalledError:
self.logger.error("Pending deferred already called")
self.process_queue()
# self.logger.info("Command done finished. Returning response {0}".format(response))
return response
def command_error(self, err):
self.logger.error(str(err))
self.response_pending = False
self.queue_pending_deferred.errback(err)
return err
def write_parameter(self, name, value, process_now=True, readback=True):
"""
Write a single named parameter to the Patara. If readback is True the same parameter is scheduled
to be read after the write. The retured deferred fires when the result is ready.
:param name: Name of the parameter according the eDrive User Manual
:param value: Value to write
:param process_now: True if the queue should be processes immediately
:param readback: True if the value should be read back from the Patara
:return: Deferred that fires when the result is ready
"""
p = self.get_parameter(name)
if p is None:
err = "Name {0} not in parameter dictionary".format(name)
self.logger.error(err)
d = defer.Deferred()
fail = failure.Failure(AttributeError(err))
d.errback(fail)
return d
addr = p.get_address()
func = p.get_function_code()
(factor, offset) = p.get_conversion()
w_val = np.uint16((value - offset) / factor)
self.logger.info(
"Writing to {0}. Addr: {1}, func {2}, value {3}".format(
name, addr, func, w_val))
if func == 1:
f = self.client.write_coil
elif func == 3:
f = self.client.write_register
else:
err = "Wrong function code {0}, should be 1, or 3".format(func)
self.logger.error(err)
d = defer.Deferred()
fail = failure.Failure(AttributeError(err))
d.errback(fail)
return d
d = self.defer_to_queue(f, addr, w_val, unit=self.slave_id)
# d = defer.Deferred()
d.addErrback(self.client_error)
if readback is True:
d = self.read_parameter(name, process_now)
if process_now is True:
self.process_queue()
return d
def clear_fault(self):
self.logger.info("Sending CLEAR FAULT command")
self.write_parameter("clear_fault",
True,
process_now=True,
readback=False)
def read_parameter(self, name, process_now=True):
"""
Read a single named parameter from the Patara and store the result in the parameter
dictionary. The retured deferred fires when the result is ready.
:param name: Name of the parameter according the eDrive User Manual
:param process_now: True if the queue should be processes immediately
:return: Deferred that fires when the result is ready
"""
p = self.get_parameter(name)
if p is None:
err = "Name {0} not in parameter dictionary".format(name)
self.logger.error(err)
d = defer.Deferred()
fail = failure.Failure(AttributeError(err))
d.errback(fail)
return d
addr = p.get_address()
func = p.get_function_code()
self.logger.debug("Reading {0}. Addr: {1}, func {2}".format(
name, addr, func))
if func == 1:
f = self.client.read_coils
elif func == 2:
f = self.client.read_discrete_inputs
elif func == 3:
f = self.client.read_holding_registers
elif func == 4:
f = self.client.read_input_registers
else:
err = "Wrong function code {0}, should be 1, 2, 3, or 4".format(
func)
self.logger.error(err)
d = defer.Deferred()
fail = failure.Failure(AttributeError(err))
d.errback(fail)
return d
d = self.defer_to_queue(f, addr, 1, unit=self.slave_id)
d.addCallback(self.process_parameters, min_addr=addr)
d.addErrback(self.client_error)
if process_now is True:
self.process_queue()
return d
def read_control_state(self, process_now=True, **kwargs):
"""
Place a read_coils command on the command queue. Returns a deferred that
fires when the command has finsihed executing.
Which read_coils to read are selected with range_id or min_addr + max_attr.
If nothing is specified, range_id=0 is presumed.
:param process_now: True if the queue should be processed immediately.
:param kwargs:
range_id: integer to index read_range variable in patara data
min_addr: starting read_coil to read
max_addr: end read_coil to read
:return:
"""
if "range_id" in kwargs:
range_id = kwargs["range_id"]
else:
range_id = 0
if "min_addr" in kwargs:
min_addr = kwargs["min_addr"]
else:
min_addr = self.patara_data.coil_read_range[range_id][0]
if "max_addr" in kwargs:
max_addr = kwargs["max_addr"]
else:
max_addr = self.patara_data.coil_read_range[range_id][1]
# min_addr = self.patara_data.coil_read_range[0][0]
# max_addr = self.patara_data.coil_read_range[0][1]
self.logger.debug("Reading control state from {0} to {1}".format(
min_addr, max_addr))
d = self.defer_to_queue(self.client.read_coils,
min_addr,
max_addr - min_addr + 1,
unit=self.slave_id)
d.addCallback(self.process_control_state, min_addr=min_addr)
d.addErrback(self.client_error)
if process_now is True:
self.process_queue()
return d
def read_status(self, process_now=True, **kwargs):
"""
Place a read_discrete_inputs command on the command queue. Returns a deferred that
fires when the command has finsihed executing.
Which discrete_inputs to read are selected with range_id or min_addr + max_attr.
If nothing is specified, range_id=0 is presumed.
:param process_now: True if the queue should be processed immediately.
:param kwargs:
range_id: integer to index read_range variable in patara data
min_addr: starting discrete_input to read
max_addr: end discrete_input to read
:return:
"""
if "range_id" in kwargs:
range_id = kwargs["range_id"]
else:
range_id = 0
if "min_addr" in kwargs:
min_addr = kwargs["min_addr"]
else:
min_addr = self.patara_data.discrete_input_read_range[range_id][0]
if "max_addr" in kwargs:
max_addr = kwargs["max_addr"]
else:
max_addr = self.patara_data.discrete_input_read_range[range_id][1]
# min_addr = self.patara_data.discrete_input_read_range[0][0]
# max_addr = self.patara_data.discrete_input_read_range[0][1]
self.logger.debug("Reading status from {0} to {1}".format(
min_addr, max_addr))
d = self.defer_to_queue(self.client.read_discrete_inputs,
min_addr,
max_addr - min_addr + 1,
unit=self.slave_id)
d.addCallback(self.process_status, min_addr=min_addr)
d.addErrback(self.client_error)
if process_now is True:
self.process_queue()
return d
def read_input_registers(self, process_now=True, **kwargs):
"""
Place a read_input_registers command on the command queue. Returns a deferred that
fires when the command has finsihed executing.
Which registers to read are selected with range_id or min_addr + max_attr.
If nothing is specified, range_id=0 is presumed.
:param process_now: True if the queue should be processed immediately.
:param kwargs:
range_id: integer to index read_range variable in patara data
min_addr: starting register to read
max_addr: end register to read
:return:
"""
if "range_id" in kwargs:
range_id = kwargs["range_id"]
else:
range_id = 0
if "min_addr" in kwargs:
min_addr = kwargs["min_addr"]
else:
min_addr = self.patara_data.input_register_read_range[range_id][0]
if "max_addr" in kwargs:
max_addr = kwargs["max_addr"]
else:
max_addr = self.patara_data.input_register_read_range[range_id][1]
self.logger.debug("Reading input registers from {0} to {1}".format(
min_addr, max_addr))
d = self.defer_to_queue(self.client.read_input_registers,
min_addr,
max_addr - min_addr + 1,
unit=self.slave_id)
d.addCallback(self.process_input_registers, min_addr=min_addr)
d.addErrback(self.client_error)
if process_now is True:
self.process_queue()
return d
def process_parameters(self, response, min_addr=0):
self.logger.debug(
"Processing parameters response: {0}".format(response))
func = response.function_code
if func == 1 or func == 2:
data = response.bits
else:
data = response.registers
t = time.time()
result = dict()
for addr, reg in enumerate(data):
self.logger.debug("Addr: {0}, reg {1}".format(
addr + min_addr, reg))
if addr == 16:
self.logger.info(
"Read channel1_active_current: {0}".format(reg))
set_res = self.patara_data.set_parameter_from_modbus_addr(
func, addr + min_addr, reg, t)
self.logger.debug("Set result: {0}".format(set_res))
name = self.patara_data.get_name_from_modbus_addr(
func, addr + min_addr)
try:
value = self.patara_data.parameters[name].get_value()
except KeyError:
self.logger.error("KeyError for name {0}, addr {1}".format(
name, addr + min_addr))
continue
self.logger.debug("Name: {0}, value: {1}".format(name, value))
result[name] = value
return result
def process_control_state(self, response, min_addr=0):
self.logger.debug("Processing status response: {0}".format(response))
try:
data = response.bits
except ValueError:
return response
t = time.time()
result = dict()
for addr, bit in enumerate(data):
self.patara_data.set_parameter_from_modbus_addr(
1, addr + min_addr, bit, t)
name = self.patara_data.get_name_from_modbus_addr(
1, addr + min_addr)
result[name] = bit
return result
def process_input_registers(self, response, min_addr=0):
self.logger.debug(
"Processing input registers response: {0}".format(response))
try:
data = response.registers
except ValueError:
return response
t = time.time()
result = dict()
for addr, reg in enumerate(data):
# self.logger.debug("Addr: {0}, reg {1}".format(addr + min_addr, reg))
self.patara_data.set_parameter_from_modbus_addr(
4, addr + min_addr, reg, t)
# self.logger.debug("Set result: {0}".format(set_res))
name = self.patara_data.get_name_from_modbus_addr(
4, addr + min_addr)
try:
value = self.patara_data.parameters[name].get_value()
except KeyError:
# self.logger.error("KeyError for name {0}, addr {1}".format(name, addr + min_addr))
continue
# self.logger.debug("Name: {0}, value: {1}".format(name, value))
result[name] = value
return result
def process_status(self, response, min_addr=0):
self.logger.debug("Processing status response: {0}".format(response))
try:
data = response.bits
except ValueError:
return response
t = time.time()
faults = list()
interlocks = list()
state = None
channel1_state = None
shutter_state = None
com0_state = None
for addr, bit in enumerate(data):
self.patara_data.set_parameter_from_modbus_addr(
2, addr + min_addr, bit, t)
name = self.patara_data.get_name_from_modbus_addr(
2, addr + min_addr)
try:
value = self.patara_data.parameters[name].get_value()
except KeyError:
# self.logger.error("KeyError for name {0}, addr {1}".format(name, addr + min_addr))
continue
self.logger.debug("Name: {0}, value: {1}".format(name, value))
if name in [
"fault_state", "off_state", "standby_state",
"pre-fire_state", "active_state"
]:
if value is True:
state = name
elif name in [
"channel1_off_state", "channel1_standby",
"channel1_active", "channel1_fault_state"
]:
if value is True:
channel1_state = name
elif name in [
"com0_off_state", "com0_standby_state",
"com0_active_state", "com0_fault_state"
]:
if value is True:
com0_state = name
elif name == "laser_shutter_state":
shutter_state = value
# if name is not None:
# if addr < 5:
# if bit == 1:
# self.state = name
# elif 32 <= addr <= 35:
# if bit == 1:
# self.channel1_state = name
# elif 80 <= addr <= 83:
# if bit == 1:
# self.com0_state = name
elif "fault" in name:
if value is True:
faults.append(name)
elif "interlock" in name:
if value is True:
interlocks.append(name)
self.channel1_state = channel1_state
self.com0_state = com0_state
self.set_state(state, shutter_state, faults, interlocks)
# with self.lock:
# self.active_fault_list = faults
# self.active_interlock_list = interlocks
return response
def client_error(self, err):
self.logger.error("Modbus error: {0}".format(err))
self.init_client()
def get_parameter(self, name):
"""
Get a stored patara parameter with name. If the parameter is not in the dictionary
return None.
:param name: Name of parameter according to Patara eDrive User Manual
:return: PataraParameter (Retrieve value with .get_value method)
"""
with self.lock:
try:
p = self.patara_data.parameters[name]
except KeyError:
p = None
return p
def get_parameters(self, name_list):
p_list = list()
for name in name_list:
with self.lock:
try:
p = self.patara_data.parameters[name]
except KeyError:
p = None
p_list.append(p)
return p_list
def get_fault_list(self):
with self.lock:
# Use copy here
fl = self.active_fault_list
return fl
def get_interlock_list(self):
with self.lock:
# Use copy here
il = self.active_interlock_list
return il
def set_status(self, new_status=None):
if new_status is not None:
self.status = new_status
for notifier in self.state_notifier_list:
new_status = self.get_status()
new_state = self.get_state()
notifier(new_state, new_status)
def get_status(self):
status = "State: {0}\n\n".format(self.get_state().upper())
status += self.status
fault_string = ""
interlock_string = ""
if len(self.active_fault_list) > 0:
fault_string = "\n--------------------------------\nActive FAULTS:\n"
for fault in self.active_fault_list:
fault_string += fault
fault_string += "\n"
if len(self.active_interlock_list) > 0:
interlock_string = "\n--------------------------------\nActive INTERLOCKS:\n"
for interlock in self.active_interlock_list:
interlock_string += interlock
interlock_string += "\n"
final_status_string = status + fault_string + interlock_string
return final_status_string
def set_state(self,
new_state,
shutter_state=None,
faults=None,
interlocks=None):
notify_state = False
if new_state != self.state or shutter_state != self.shutter_state:
self.state = new_state
self.shutter_state = shutter_state
notify_state = True
if faults != self.active_fault_list or interlocks != self.active_interlock_list:
self.active_fault_list = faults
self.active_interlock_list = interlocks
notify_state = True
if notify_state is True:
for notifier in self.state_notifier_list:
new_status = self.get_status()
notifier(new_state, new_status)
def get_state(self):
return self.state
def get_shutterstate(self):
return self.shutter_state
def add_state_notifier(self, notifier):
if notifier not in self.state_notifier_list:
self.state_notifier_list.append(notifier)
def __configure_master(self, config=None):
current_config = self.__config if config is None else config
host = current_config['host'] if current_config.get(
"host") is not None else self.__config.get("host", "localhost")
try:
port = int(current_config['port']) if current_config.get(
"port") is not None else self.__config.get(int("port"), 502)
except ValueError:
port = current_config['port'] if current_config.get(
"port") is not None else self.__config.get("port", 502)
baudrate = current_config['baudrate'] if current_config.get(
'baudrate') is not None else self.__config.get('baudrate', 19200)
timeout = current_config['timeout'] if current_config.get(
"timeout") is not None else self.__config.get("timeout", 35)
method = current_config['method'] if current_config.get(
'method') is not None else self.__config.get('method', 'rtu')
stopbits = current_config['stopbits'] if current_config.get(
'stopbits') is not None else self.__config.get(
'stopbits', Defaults.Stopbits)
bytesize = current_config['bytesize'] if current_config.get(
'bytesize') is not None else self.__config.get(
'bytesize', Defaults.Bytesize)
parity = current_config['parity'] if current_config.get(
'parity') is not None else self.__config.get(
'parity', Defaults.Parity)
strict = current_config["strict"] if current_config.get(
"strict") is not None else self.__config.get("strict", True)
rtu = ModbusRtuFramer if current_config.get("method") == "rtu" or (
current_config.get("method") is None
and self.__config.get("method") == "rtu") else ModbusSocketFramer
if current_config.get('type') == 'tcp' or (
current_config.get("type") is None
and self.__config.get("type") == "tcp"):
master = ModbusTcpClient(host, port, rtu, timeout=timeout)
elif current_config.get('type') == 'udp' or (
current_config.get("type") is None
and self.__config.get("type") == "udp"):
master = ModbusUdpClient(host, port, rtu, timeout=timeout)
elif current_config.get('type') == 'serial' or (
current_config.get("type") is None
and self.__config.get("type") == "serial"):
master = ModbusSerialClient(method=method,
port=port,
timeout=timeout,
baudrate=baudrate,
stopbits=stopbits,
bytesize=bytesize,
parity=parity,
strict=strict)
else:
raise Exception("Invalid Modbus transport type.")
available_functions = {
1: master.read_coils,
2: master.read_discrete_inputs,
3: master.read_holding_registers,
4: master.read_input_registers,
5: master.write_coil,
6: master.write_register,
15: master.write_coils,
16: master.write_registers,
}
return master, available_functions
class ModbusClient(object):
"""Establishes a secure connection with the
Modbus slave. Will be able to read and write
to all of the available I/O."""
def __init__(self, ip='192.168.2.17'):
self.ip = ip
self.client = ModbusTcpClient(self.ip)
self.connection = self.client.connect()
def isConnected(self):
"""Returns the connection status.
Return: True if connected, False if not."""
return self.connection
def sendInt(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_int(value)
payload = builder.build()
result = self.client.write_registers(address,
payload,
skip_encode=True,
unit=1)
return result
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.client.write_registers(address,
payload,
skip_encode=True,
unit=1)
return result
def readInt(self, address=12288, size=20):
"""Reads the number of addresses that the size contains.
The readings start from the given address.
Return: An array of read values"""
response = self.client.read_holding_registers(address, size, unit=1)
return response.registers
def readFloat(self, address=12301, size=2):
"""Reads two bytes from the given start address.
Returns the decoded float value"""
response = self.client.read_holding_registers(address, size, unit=1)
decoder = BinaryPayloadDecoder.fromRegisters(response.registers,
byteorder=Endian.Big,
wordorder=Endian.Little)
value = decoder.decode_32bit_float()
return value
def close(self):
"""Closes the connection with the port.
Return: True when the connection is closed."""
self.client.close()
return True
def cyclic(self, dt):
global energie, Pinst, conn_to_ccgx, seconds, conn_status, time_check, state_of_charge, grid_power, state, battery_alarm, battery_voltage, battery_current, connect_to_db
client = ModbusClient('192.169.1.107', port=502)
if (conn_status or (conn_status == False and time_check > 10)):
try:
conn_to_ccgx = False
if (client.connect()):
conn_to_ccgx = True
try:
# print("connected")
rr = client.read_holding_registers(12, 3, unit=246)
#rr = 1
if rr.getRegister(0) > 32767:
Pinst = rr.getRegister(0) - 65535
else:
Pinst = rr.getRegister(0)
if rr.getRegister(1) > 32767:
Pinst += rr.getRegister(1) - 65535
else:
Pinst += rr.getRegister(1)
if rr.getRegister(2) > 32767:
Pinst += rr.getRegister(2) - 65535
else:
Pinst += rr.getRegister(2)
soc = client.read_holding_registers(30, 2, unit=246)
state_of_charge = soc.getRegister(0) / 10
state = soc.getRegister(1)
battery_alarm_buffer = client.read_holding_registers(
35, 1, unit=246)
battery_alarm = battery_alarm_buffer.getRegister(0)
grid_ac = client.read_holding_registers(2600,
3,
unit=30)
if grid_ac.getRegister(0) > 32767:
grid_power[0] = grid_ac.getRegister(0) - 65535
else:
grid_power[0] = grid_ac.getRegister(0)
if grid_ac.getRegister(1) > 32767:
grid_power[1] = grid_ac.getRegister(1) - 65535
else:
grid_power[1] = grid_ac.getRegister(1)
if grid_ac.getRegister(2) > 32767:
grid_power[2] = grid_ac.getRegister(2) - 65535
else:
grid_power[2] = grid_ac.getRegister(2)
battery_acvc = client.read_holding_registers(26,
2,
unit=246)
battery_voltage = battery_acvc.getRegister(0)
battery_current = battery_acvc.getRegister(1)
print grid_power
print "Vittoria"
time_check = 1
conn_status = True
# print("connected")
print grid_power
except Exception:
print "error"
Pinst = 0
conn_status = False
grid_power = [0, 0, 0]
else:
Pinst = 0
conn_status = False
time_check = 1
conn_to_ccgx = False
except Exception:
print "error"
Pinst = 0
conn_status = False
# conn_to_ccgx = False
grid_power = [0, 0, 0]
time_check = 1
else:
time_check = time_check + 1
Pinst = 0
# conn_to_ccgx = False
seconds = seconds + 1
# Pinst = 30*10 #decomment ONLY for debug
# conn_status = True #decomment ONLY for debug
# seconds = seconds + 1 #decomment ONLY for debug
Pinst = Pinst * 10
client.close()
if (seconds % 10 == 0):
with open("log.txt", "a") as myfile:
data = [energie, Pinst, seconds]
myfile.write(
str(seconds) + "\t" + str(energie) + "\t" + str(Pinst) +
"\t" + str(state_of_charge) + "\t" + str(conn_status) +
"\t" + str(grid_power[0]) + "\t" + str(grid_power[1]) +
"\t" + str(grid_power[2]) + "\t" + str(state) + "\t" +
str(battery_alarm) + "\t" + str(battery_voltage) + "\t" +
str(battery_current) + "\t" + str(conn_to_ccgx) + "\n")
ts = time.time()
timestamp = datetime.datetime.fromtimestamp(ts).strftime(
'%Y-%m-%d %H:%M:%S')
# string = 'INSERT INTO sql11172989.Nuvola ' + '(Seconds, Energy, Pinst, StateOfCharge, ConnStatus, GridPower1, GridPower2, GridPower3, State, BatteryAlarm, Date) VALUES (' + str(seconds) + " , " + str(energie) + " , " + str(Pinst) + " , " + str(state_of_charge) + " , " + str(conn_status) + " , " + str(grid_power[0]) + " , " + str(grid_power[1]) + " , " + str(grid_power[2]) + " , " + str(state) + " , " + str(battery_alarm) + ' , ' + str(timestamp) + ')'
# print string
try:
ts = time.time()
timestamp = datetime.datetime.fromtimestamp(ts).strftime(
'%Y-%m-%d %H:%M:%S')
db = MySQLdb.connect(
host=
"sql11.freesqldatabase.com", # your host, usually localhost
user="******", # your username
passwd="gxPNMb9mdQ", # your password
db="sql11172989",
connect_timeout=0.1)
cur = db.cursor()
cur.execute(
'INSERT INTO sql11172989.' + table + ' ' +
'(Seconds, Energy, Pinst, StateOfCharge, ConnStatus, GridPower1, GridPower2, GridPower3, State, BatteryAlarm, BatteryVoltage, BatteryCurrent, ConnCCGX, Date_) '
'VALUES (' + str(seconds) + " , " + str(energie) + " , " +
str(Pinst) + " , " + str(state_of_charge) + " , " +
str(conn_status) + " , " + str(grid_power[0]) + " , " +
str(grid_power[1]) + " , " + str(grid_power[2]) + " , " +
str(state) + " , " + str(battery_alarm) + " , " +
str(battery_voltage) + " , " + str(battery_current) +
" , " + str(conn_to_ccgx) + ' , "' + str(timestamp) + '")')
print("sto scrivendo....")
cur.close()
db.commit()
connect_to_db = True
except Exception:
connect_to_db = False
print "Impossible to write to DB"
#rr = 2
if Pinst > 0:
energie += Pinst / 3600000.0
#rr = client.read_holding_registers(2700, 3, unit=0)
print(energie / 1)
#THIS WILL BE WRITTEN TOGETHER WITH backup3/5!! Every second!
# print "Error %d: %s" % (e.args[0],e.args[1])
data = [energie, Pinst, seconds]
call(["cp", "backup3.p", "backup5.p"])
write = open('backup3.p', 'wb')
pickle.dump(data, write)
client.close()
#self.energy.text = str(round(energie/3600000.0,3))+" kWh"
#self.euros.text = str(round(energie/3600000.0*0.15,3))+" eur"
# client.close()
#print("disconnected")
# print "There was an exception"
client.close()
#!/usr/bin/env python
from pymodbus.client.sync import ModbusTcpClient as ModbusClient
import modbus_utilities as utilities_modbus
import vision_utilities as utilities_vision
import cv2
import time
import numpy as np
# Create a client and connect to the camera server
client = ModbusClient(utilities_modbus.IP, port=utilities_modbus.PORT)
client.connect()
if __name__ == "__main__":
while True:
# Read the result register
rr = client.read_holding_registers(address=utilities_modbus.ADDRESS,
count=3,
unit=utilities_modbus.UNIT)
# While the result register is on wait (no result published), read the result register
while rr.registers[1] == utilities_modbus.RESULT_WAIT:
rr = client.read_holding_registers(
address=utilities_modbus.ADDRESS,
count=3,
unit=utilities_modbus.UNIT)
time.sleep(utilities_modbus.VISUALIZER_REQUEST_RATE)
# Load the images showing the different steps in the image processing (input/cropping/hsv_filter)
state, image_0 = utilities_vision.loadImage("images/step_0.jpg")
from pymodbus.client.sync import ModbusTcpClient
client = ModbusTcpClient('127.0.0.1')
client.write_coil(1, True)
result = client.read_coils(1, 1)
print result.bits[0]
client.close()
def run_binary_payload_ex():
# ----------------------------------------------------------------------- #
# We are going to use a simple client to send our requests
# ----------------------------------------------------------------------- #
client = ModbusClient('127.0.0.1', port=5020)
client.connect()
# ----------------------------------------------------------------------- #
# If you need to build a complex message to send, you can use the payload
# builder to simplify the packing logic.
#
# Here we demonstrate packing a random payload layout, unpacked it looks
# like the following:
#
# - a 8 byte string 'abcdefgh'
# - a 32 bit float 22.34
# - a 16 bit unsigned int 0x1234
# - another 16 bit unsigned int 0x5678
# - an 8 bit int 0x12
# - an 8 bit bitstring [0,1,0,1,1,0,1,0]
# - an 32 bit uint 0x12345678
# - an 32 bit signed int -0x1234
# - an 64 bit signed int 0x12345678
# The packing can also be applied to the word (wordorder) and bytes in each
# word (byteorder)
# The wordorder is applicable only for 32 and 64 bit values
# Lets say we need to write a value 0x12345678 to a 32 bit register
# The following combinations could be used to write the register
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
# Word Order - Big Byte Order - Big
# word1 =0x1234 word2 = 0x5678
# Word Order - Big Byte Order - Little
# word1 =0x3412 word2 = 0x7856
# Word Order - Little Byte Order - Big
# word1 = 0x5678 word2 = 0x1234
# Word Order - Little Byte Order - Little
# word1 =0x7856 word2 = 0x3412
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
# ----------------------------------------------------------------------- #
combos = [(wo, bo) for wo in [Endian.Big, Endian.Little]
for bo in [Endian.Big, Endian.Little]]
for wo, bo in combos:
print("-" * 60)
print("Word Order: {}".format(ORDER_DICT[wo]))
print("Byte Order: {}".format(ORDER_DICT[bo]))
print()
builder = BinaryPayloadBuilder(byteorder=bo, wordorder=wo)
strng = "abcdefgh"
builder.add_string(strng)
builder.add_bits([0, 1, 0, 1, 1, 0, 1, 0])
builder.add_8bit_int(-0x12)
builder.add_8bit_uint(0x12)
builder.add_16bit_int(-0x5678)
builder.add_16bit_uint(0x1234)
builder.add_32bit_int(-0x1234)
builder.add_32bit_uint(0x12345678)
builder.add_16bit_float(12.34)
builder.add_16bit_float(-12.34)
builder.add_32bit_float(22.34)
builder.add_32bit_float(-22.34)
builder.add_64bit_int(-0xDEADBEEF)
builder.add_64bit_uint(0x12345678DEADBEEF)
builder.add_64bit_uint(0x12345678DEADBEEF)
builder.add_64bit_float(123.45)
builder.add_64bit_float(-123.45)
payload = builder.to_registers()
print("-" * 60)
print("Writing Registers")
print("-" * 60)
print(payload)
print("\n")
payload = builder.build()
address = 0
# Can write registers
# registers = builder.to_registers()
# client.write_registers(address, registers, unit=1)
# Or can write encoded binary string
client.write_registers(address, payload, skip_encode=True, unit=1)
# ----------------------------------------------------------------------- #
# If you need to decode a collection of registers in a weird layout, the
# payload decoder can help you as well.
#
# Here we demonstrate decoding a random register layout, unpacked it looks
# like the following:
#
# - a 8 byte string 'abcdefgh'
# - a 32 bit float 22.34
# - a 16 bit unsigned int 0x1234
# - another 16 bit unsigned int which we will ignore
# - an 8 bit int 0x12
# - an 8 bit bitstring [0,1,0,1,1,0,1,0]
# ----------------------------------------------------------------------- #
address = 0x0
count = len(payload)
result = client.read_holding_registers(address, count, unit=1)
print("-" * 60)
print("Registers")
print("-" * 60)
print(result.registers)
print("\n")
decoder = BinaryPayloadDecoder.fromRegisters(result.registers,
byteorder=bo,
wordorder=wo)
assert decoder._byteorder == builder._byteorder, \
"Make sure byteorder is consistent between BinaryPayloadBuilder and BinaryPayloadDecoder"
assert decoder._wordorder == builder._wordorder, \
"Make sure wordorder is consistent between BinaryPayloadBuilder and BinaryPayloadDecoder"
decoded = OrderedDict([
('string', decoder.decode_string(len(strng))),
('bits', decoder.decode_bits()),
('8int', decoder.decode_8bit_int()),
('8uint', decoder.decode_8bit_uint()),
('16int', decoder.decode_16bit_int()),
('16uint', decoder.decode_16bit_uint()),
('32int', decoder.decode_32bit_int()),
('32uint', decoder.decode_32bit_uint()),
('16float', decoder.decode_16bit_float()),
('16float2', decoder.decode_16bit_float()),
('32float', decoder.decode_32bit_float()),
('32float2', decoder.decode_32bit_float()),
('64int', decoder.decode_64bit_int()),
('64uint', decoder.decode_64bit_uint()),
('ignore', decoder.skip_bytes(8)),
('64float', decoder.decode_64bit_float()),
('64float2', decoder.decode_64bit_float()),
])
print("-" * 60)
print("Decoded Data")
print("-" * 60)
for name, value in iteritems(decoded):
print("%s\t" % name,
hex(value) if isinstance(value, int) else value)
# ----------------------------------------------------------------------- #
# close the client
# ----------------------------------------------------------------------- #
client.close()
#!/usr/bin/python
import sys
import os
import time
import getopt
import socket
import ConfigParser
import struct
import binascii
ipaddress = str(sys.argv[1])
from pymodbus.client.sync import ModbusTcpClient
client = ModbusTcpClient(ipaddress, port=502)
#print "SoC batt"
resp= client.read_holding_registers(30845,2,unit=3)
value1 = resp.registers[0]
value2 = resp.registers[1]
all = format(value1, '04x') + format(value2, '04x')
final = int(struct.unpack('>i', all.decode('hex'))[0])
f = open('/var/www/html/openWB/ramdisk/speichersoc', 'w')
f.write(str(final))
f.close()
#print "be-entladen watt"
resp= client.read_holding_registers(31393,2,unit=3)
value1 = resp.registers[0]
value2 = resp.registers[1]
all = format(value1, '04x') + format(value2, '04x')
ladung = int(struct.unpack('>i', all.decode('hex'))[0])
resp= client.read_holding_registers(31395,2,unit=3)
value1 = resp.registers[0]
# ! You need to launch the server first !
from pymodbus.client.sync import ModbusTcpClient
import time
def number_to_raw_data(val):
if val < 0:
val = (1 << 15) - val
return int(val)
if __name__ == '__main__':
print "--- START"
client = ModbusTcpClient('192.168.1.52', port=5020)
client.connect()
print "Connected to modbus server"
print "Update tool"
client.write_register(500, 1)
time.sleep(2)
print "Enable TCP"
client.write_register(600, 1)
time.sleep(2)
print "Set TCP"
tcp_rpy = [0.2, -0.1, 0.0, 0.0, 1.5, 0.0]
tcp_rpy_to_send = list(map(lambda x: number_to_raw_data(x * 1000),
'S16':1,
'U16':1,
'S32':2,
'U32':2,
'U64':4,
'STR16':8,
'STR32':16
}
# Load the modbus register map for the inverter
modmap_file = "modbus-" + config.model
modmap = __import__(modmap_file)
print ("Load ModbusTcpClient")
client = ModbusTcpClient(config.inverter_ip, port=config.inverter_port)
print("Connect")
client.connect()
try:
mqtt_client = mqtt.Client('pv_data')
mqtt_client.connect(config.mqtt_server, port=config.mqtt_port)
except:
mqtt_client = None
try:
flux_client = InfluxDBClient(config.influxdb_ip,
config.influxdb_port,
config.influxdb_user,
config.influxdb_password,
config.influxdb_database,
def main(args):
global client
print("# connecting to %s:%s id %s" % (args.ip, args.port, args.slave))
start_t = time.time()
client = ModbusClient(args.ip, args.port, timeout=args.timeout)
conn = client.connect()
if not conn:
exit("# unable to connect to %s:%s" % (args.ip, args.port))
end_t = time.time()
time_t = (end_t - start_t) * 1000
print("# connection established in %dms" % time_t)
print("# delay: %ss timeout: %ss" % (args.delay, args.timeout))
print("# smoothing factor %f" % args.factor)
smoothing_factor = args.factor
average = 100
errors = 0
while True:
with open(args.csv_file) as csv_file:
csv_reader = csv.reader(csv_file, delimiter=",")
for row in csv_reader:
if row[0].startswith("#"):
continue
function = row[0]
register = int(row[1])
register_length = int(row[2])
try:
multiplier = float(row[3])
except ValueError:
multiplier = 1
encoding = row[4]
start_t = time.time()
if function == "3":
result = client.read_holding_registers(register,
register_length,
unit=args.slave)
elif function == "4":
result = client.read_input_registers(register,
register_length,
unit=args.slave)
else:
log_error(register, "FUNCTION %s NOT SUPPORTED" % function)
continue
end_t = time.time()
if result.isError():
if isinstance(result, ModbusIOException):
log_error(register, "I/O ERROR (TIMEOUT)")
else:
log_error(register, "REGISTER NOT FOUND")
continue
decoder = BinaryPayloadDecoder.fromRegisters(
result.registers,
byteorder=Endian.Big,
wordorder=Endian.Big,
)
try:
encoding = encoding.upper()
if encoding not in ENCODINGS:
log_error(encoding, "FORMAT NOT SUPPORTED")
continue
decoded = eval(ENCODINGS[encoding])
# Apply transformations
if isinstance(decoded, bytes):
decoded = decoded.decode().rstrip()
else:
decoded = round(decoded * multiplier, 3)
except struct.error as e:
decoded = "DECODE FAILED (e:'%s' raw:'%s')" % (
e,
decoder.decode_string(register_length * 2).decode(),
)
time_t = round((end_t - start_t) * 1000, 2)
average = round((smoothing_factor * time_t) +
(1 - smoothing_factor) * average, 2)
print(separator.join(
(str(datetime.now()), str(args.ip), str(register),
str(decoded), str(time_t), str(average), str(errors))),
flush=True)
time.sleep(args.delay)
if args.loop == 0:
break
time.sleep(args.loop)
import random
import time
import NetworkEncoder as ne
from pymodbus.client.sync import ModbusTcpClient
MODBUS_SLAVE = 'ms.ics.example.com'
client = ModbusTcpClient(MODBUS_SLAVE)
def readRegisters():
# Read values from slave
result = client.read_holding_registers(0, 21, unit=1)
addWater = ne.modbusDecode(0, 2, 2, result.registers)
addFire = ne.modbusDecode(2, 2, 0, result.registers)
waterLevel = ne.modbusDecode(3, 4, 4, result.registers)
waterTemp = ne.modbusDecode(7, 2, 2, result.registers)
powerOut = ne.modbusDecode(9, 6, 2, result.registers)
steamStep = ne.modbusDecode(13, 2, 4, result.registers)
powerIn = ne.modbusDecode(16, 6, 2, result.registers)
serverSeconds = ne.modbusDecode(20, 2, 0, result.registers)
return addWater, addFire, waterLevel, waterTemp, powerOut, steamStep, powerIn, serverSeconds
response = ''
serverSeconds = 0
print("Sensors online, enter injection attack type:")
print("[r]esponse - Fake slave values to trigger overflow")
print("[c]ommand - Fake master values to trigger overflow")
print("[q]uit")
