for kk in range(A):
while 1:
if datetime.now() >= next:
next += dt
break
sleep(1)
a = datetime.now()
print(str(kk + 1) + ':' + str(a))
totaldata = {}
# ads1
for i in range(len(bus1)): # 读1234总线
client = ModbusClient('192.168.1.82',
port=1030 + bus1[i],
timeout=3,
framer=ModbusFramer)
is_connected = client.connect()
if not is_connected: # modbus连接失败
log.info('Modbus Connect Failed')
client.close()
sleep(1)
continue
for j in range(len(ads1[i])):
sleep(1)
rr = client.read_holding_registers(ads1[i][j][1] * 0x40,
0x08,
unit=0x01)
if not hasattr(rr, 'registers'): # 无返回数据
log.info('No Data Return')
#!/usr/bin/env python3
import sys
import time
from pymodbus.client.sync import ModbusTcpClient as ModbusClient
from pymodbus.exceptions import ConnectionException
ip = sys.argv[1]
client = ModbusClient(ip, port=502)
client.connect()
while True:
client.write_register(1, 0) # Bottle is not filled
client.write_register(2, 0) # Bottle is not under the nozzle
client.write_register(3, 1) # Start the roller
client.write_register(4, 1) # Open the nozzle
client.write_register(16, 1) # Start the plant
def fn_read_VeoStat_1(self,
my_dict,
my_unit,
my_port=fn_serial_port_list(),
my_timeout=1,
my_baudrate=9600):
client = ModbusClient(method='rtu',
port=my_port,
timeout=my_timeout,
baudrate=my_baudrate)
client.connect()
if client.connect():
#rq = client.write_register(2002, 1, unit=my_unit)
#rq = client.write_register(2003, 1, unit=my_unit)
#rq = client.write_registers(2002, [0]*5, unit=my_unit)
#rq = client.write_register(self._dict.vLCDMessage.register - 1, 0, unit=my_unit)
#rq = client.write_registers(self._dict.oFanEnable.register - 1, [1]*5, unit=my_unit)
for key, value in my_dict.items():
# run througn writable vars and send to DGU
if value.writable == "Yes":
#print(value.writable, " is writable")
rq = client.write_register(value.register - 1,
value.value,
unit=my_unit)
pass
float_registers = client.read_input_registers(
1000, 38, unit=my_unit) # Read 32bit float values
float_registers = fn_decode_float(
float_registers.registers) # Decode 32bit float values
rr = client.read_input_registers(2000, 41,
unit=my_unit) # Read 16bit values.
tt = client.read_input_registers(6566, 1,
unit=my_unit) # Read TemplateID
client.close()
# UPDATE THINK ABOUT DEFAULT VALUE FOR KEY IF SCAN RETURNS VALUES BUT SOME ARE MISSING
# UPDATE GUARD AGAINST FAILED SCANS
# UPDATE GUARD AGAINST SCANS THAT RETURN NUMBER OF VALUES THAT DONT MATCH THE NUMBER OF KEYS
# UPDATE INCLUDE TIME STAMP FOR HEARTBEAT
count = 0
for key, value in my_dict.items():
if value["format"] == "Float32" and value[
"register"] <= 1038 and count <= len(float_registers):
value["value"] = float_registers[count]
count += 1
pass
count = 0
# could limit this by len(rr.registers)
for key, value in my_dict.items():
if value["format"] == "Init16" and value[
"register"] <= 2041 and count <= len(rr.registers):
value["value"] = rr.registers[count]
count += 1
pass
elif value["format"] == "Init16" and value["register"] == 6567:
value["value"] = tt.registers[0]
count = 1
for key, value in my_dict.items():
#if value["format"] == "Init16":
#if value["format"] == "Float32":
#print(count, value["name"], value["value"])
count += 1
pass
# 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.
#
# If you use the UDP or TCP clients, you can override the framer being used
# to use a custom implementation (say RTU over TCP). By default they use the
# socket framer::
#
# client = ModbusClient('localhost', port=5020, framer=ModbusRtuFramer)
#
# It should be noted that you can supply an ipv4 or an ipv6 host address for
# both the UDP and TCP clients.
#---------------------------------------------------------------------------#
client = ModbusClient('localhost', port=5020)
#client = ModbusClient(method='ascii', port='/dev/pts/2', timeout=1)
#client = ModbusClient(method='rtu', port='/dev/pts/2', timeout=1)
client.connect()
#---------------------------------------------------------------------------#
# example requests
#---------------------------------------------------------------------------#
# simply call the methods that you would like to use. An example session
# is displayed below along with some assert checks. Note that some modbus
# implementations differentiate holding/input discrete/coils and as such
# you will not be able to write to these, therefore the starting values
# are not known to these tests. Furthermore, some use the same memory
# blocks for the two sets, so a change to one is a change to the other.
# Keep both of these cases in mind when testing as the following will
# _only_ pass with the supplied async modbus server (script supplied).
'mean_value': 600,
'noise_range': 50,
'always_positive': False
},
'temperature': {
'binary': False,
'mean_value': 60,
'noise_range': 5,
'always_positive': False
},
'on_off': {
'binary': True,
'mean_value': 0,
'probability': .1
}
}
fakePLC = FakePLC(8080, example_reading_structure)
# Modbus UDP client from pymodbus package
client = ModbusClient('localhost', port=8080)
plcThread = Thread(target=fakePLC.start_server, daemon=True)
plcThread.start()
client.connect()
while True:
try:
sleep(2)
response = client.read_holding_registers(0, 3)
print('Response registers:', response.registers)
except KeyboardInterrupt:
print('Quiting...')
exit(0)
query2 = 'select avg(Temperature) from test1 where Location =' + str(merge_loc)
cursor.execute(query2)
result = cursor.fetchall()
avg = result[0][0]
query3 = 'delete from test1 where Location = ' + str(merge_loc)
cursor.execute(query3)
db.commit()
query4 = query = ("""insert into test1(Date_and_Time, Temperature, Target_Time, Status, Location, Colour) values (%s,%s,%s,%s,%s,%s)""", (merge_date, avg ,merge_target,merge_status,merge_loc,merge_colour))
cursor.execute(*query4)
db.commit()
#Modbus Connection initialise
client = ModbusClient(host = '192.168.178.10',port = 502) ##Modbus connection establish
client.connect()
client.write_registers(0, [0]*10) ##Open Connection
#mode :Store = 0, Unstore = 1, Idle = 2
mode = 2
try:
while True:
if mode == 2:
while True:
statusupdate()
unstore_status = unstore_needed()
if unstore_status == 1:
mode = 1
break
#data = [int(x.encode('hex'),16) for x in data]
print data
print len(data)
if not len(data) % 2 == 0:
data += "\x00"
print hexString(data)
print len(data)
data_list = []
for i in range(0, len(data) - 8, 2): # -8 is last time array
data_list.append(unpack("H", data[i:i + 2])[0])
#data_list = list(unpack("<()h".format(len(data)/2), data))
print data_list
time_array = data[-8:]
time_array = [int(x.encode('hex'), 10) for x in time_array]
data_list += time_array
print "with time:", data_list
ser.close()
# tcp client
client = ModbusClient(host=client_settings.ip, port=client_settings.port)
rq = client.write_registers(client_settings.start_address,
data_list,
unit=client_settings.id)
#assert(rq.function_code < 0x80)
client.close()
#---------------------------------------------------------------------------#
# configure the client logging
#---------------------------------------------------------------------------#
import logging
logging.basicConfig()
log = logging.getLogger()
#log.setLevel(logging.DEBUG)
#---------------------------------------------------------------------------#
# choose the client
#---------------------------------------------------------------------------#
#
# client = ModbusClient('localhost', retries=3, retry_on_empty=True)
#---------------------------------------------------------------------------#
client = ModbusClient('10.3.1.205', port=502)
#client = ModbusClient(method='ascii', port='/dev/pts/2', timeout=1)
#client = ModbusClient(method='rtu', port='/dev/pts/2', timeout=1)
client.connect()
k = 0
debug = True
#l={98+k,76+k,54+k,32+k,10+k,987+k,654+k,321+k}
l = {6757, 2340, 340, 8730, 0, 0, 0, 0}
print "======================"
print "Con el Tofino activado"
print "======================"
leer_id()
return False
#---------------------------------------------------------------------------#
# 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.
#---------------------------------------------------------------------------#
# MODBUS_SERVER_IP = '172.16.16.1'
# MODBUS_SERVER_PORT = 503
MODBUS_SERVER_IP = '127.0.0.1'
MODBUS_SERVER_PORT = 5020
MODUBS_ADDRESS = 0x162
client = ModbusClient(MODBUS_SERVER_IP, port=MODBUS_SERVER_PORT)
# slaves = [10, 11, 12]
slaves = [0x01]
GRID_SUPPORT_VALUE = 1 if is_enable() == True else 0
log.debug("Write to a Coil and read back")
for slave_id in slaves:
log.debug("slave: {}".format(slave_id))
rq = client.write_coil(0, GRID_SUPPORT_VALUE, unit=slave_id)
rr = client.read_coils(0, 1, unit=slave_id)
print("~" * 10, rq)
assert (not rq.isError()) # test that we are not an error
assert (rr.bits[0] == True) # test the expected value
def read(self):
# list to hold final readings
readings = []
for device_info, sensors in self._settings.MODBUS_RTU_TARGETS:
# use the same timestamp for all of the sensors on this device
ts = time.time()
try:
try:
serial_port, device_addr, kwargs = device_info
except:
serial_port, device_addr = device_info
kwargs = {}
endian = kwargs.get('endian', 'big')
timeout = kwargs.get('timeout', 1.0)
baudrate = kwargs.get('baudrate', 9600)
if endian not in ('big', 'little'):
raise ValueError(f'Improper endian value for Modbus device {device_info}')
with ModbusClient(method='rtu', port=serial_port, timeout=timeout, baudrate=baudrate) as client:
for sensor_info in sensors:
try:
try:
register, sensor_name, kwargs = sensor_info
except:
register, sensor_name = sensor_info
kwargs = {}
datatype = kwargs.get('datatype', 'uint16')
transform = kwargs.get('transform', None)
register_type = kwargs.get('register_type', 'holding')
reading_type = kwargs.get('reading_type', 'value')
# determine number of registers to read and the correct struct
# unpacking code based upon the data type for this sensor.
try:
reg_count, unpack_fmt = {
'uint16': (1, 'H'),
'int16': (1, 'h'),
'uint32': (2, 'I'),
'int32': (2, 'i'),
'float': (2, 'f'),
'float32': (2, 'f'),
'double': (4, 'd'),
'float64': (4, 'd'),
}[datatype]
except:
logging.exception(f'Invalid Modbus Datatype: {datatype} for Sensor {sensor_info}')
continue
# Determine the correct function to use for reading the values
try:
read_func = {
'holding': client.read_holding_registers,
'input': client.read_input_registers,
'coil': client.read_coils,
'discrete': client.read_discrete_inputs
}[register_type]
except:
logging.exception(f'Invalid Modbus register type for Sensor {sensor_info}')
continue
try:
reading_type_code = {
'value': base_reader.VALUE,
'state': base_reader.STATE,
'counter': base_reader.COUNTER
}[reading_type]
except:
logging.exception(f'Invalid Reading Type for Sensor {sensor_info}')
continue
result = read_func(register, reg_count, unit=device_addr)
if not hasattr(result, 'registers'):
raise ValueError(f'An error occurred while reading Sensor {sensor_info} from Modbus Device {device_info}')
# make an array of register values with least-signifcant value first
registers = result.registers
# calculate the integer equivalent of the registers read
if endian == 'big':
registers = reversed(registers)
val = 0
mult = 1
for reg in registers:
val += reg * mult
mult *= 2**16
# Use the struct module to convert this number into the appropriate data type.
# First, create a byte array that encodes this unsigned number according to
# how many words it contains.
reg_count_to_pack_fmt = {
1: 'H',
2: 'I',
4: 'Q'
}
pack_fmt = reg_count_to_pack_fmt[reg_count]
packed_bytes = struct.pack(pack_fmt, val)
# unpack bytes to convert to correct datatype
val = struct.unpack(unpack_fmt, packed_bytes)[0]
if transform:
val = eval(transform)
sensor_id = f'{self._settings.LOGGER_ID}_{sensor_name}'
readings.append( (ts, sensor_id, val, reading_type_code) )
except Exception as err:
logging.exception(str(err))
continue # on to next sensor
except Exception as err:
logging.exception(str(err))
continue # on to next device
return readings
6: 'current limiting'
}
def charging_status(self):
return self.read_register(288) & 0x00ff
def charging_status_label(self):
return CHARGING_STATE.get(self.charging_status())
# Connect to the controller and get values
client = ModbusClient(method='rtu',
port='/dev/ttyUSB0',
baudrate=9600,
stopbits=1,
bytesize=8,
parity='N')
client.connect()
#https://raw.githubusercontent.com/corbinbs/solarshed/master/solarshed/controllers/renogy_rover.py
Model = client.read_holding_registers(12, 8, unit=1)
pprint.pprint(f"(Info) Model == {Model.registers[0]}")
BatteryType = client.read_holding_registers(57348, 1, unit=1)
pprint.pprint(
f"(Info) BatteryType == {BATTERY_TYPE[BatteryType.registers[0]]}")
BatteryCapacity = client.read_holding_registers(57346, 1, unit=1)
pprint.pprint(f"(Info) BatteryCapacity == {BatteryCapacity.registers[0]}")
# "tags": {"host": influx_host},
# "time": iso,
# "fields": {
# "value": co2_2,
# }
# }
# ]
# return json_body
capture_interval = 5.0
client = InfluxDBClient(influx_host, port, user, password, dbname)
clientMB = ModbusClient(method="rtu",
port="/dev/ttyAMA0",
stopbits=1,
bytesize=8,
parity='N',
baudrate=115200,
timeout=0.5)
while 1:
connection = clientMB.connect()
result = clientMB.read_holding_registers(0, 7, unit=0x04)
result2 = clientMB.read_holding_registers(0, 7, unit=0x05)
result3 = clientMB.read_holding_registers(0, 2, unit=0x06)
a = result.registers[0] / 16
temp_1 = round(a, 1)
humidity_1 = result.registers[6]
co2_1 = result.registers[1]
IO2input1value = False # Conveyor belt
IO2input2value = False
IO2output1value = False
IO2output2value = False
# Define the OPC-UA nodes
IO1input1 = remoteIO1.get_node("ns=1;s=Read Input 1.")
IO1input2 = remoteIO1.get_node("ns=1;s=Read Input 2.")
IO1output1 = remoteIO1.get_node("ns=1;s=Control Output 1.")
IO1output2 = remoteIO1.get_node("ns=1;s=Control Output 2.")
IO2input1 = remoteIO2.get_node("ns=1;s=Read Input 1.")
IO2input2 = remoteIO2.get_node("ns=1;s=Read Input 2.")
IO2output1 = remoteIO2.get_node("ns=1;s=Control Output 1.")
IO2output2 = remoteIO2.get_node("ns=1;s=Control Output 2.")
client = ModbusClient(plcip, port=502)
client.connect()
# Set OPC-UA mode on the PLC
rq = client.write_register(1032, 1, unit=1)
while True:
# Generate Process image
start_time = datetime.datetime.now()
IO1input1value = IO1input1.get_value()
IO1input2value = IO1input2.get_value()
IO1output1value = IO1output1.get_value()
IO1output2value = IO1output2.get_value()
IO2input1value = IO2input1.get_value()
IO2input2value = IO2input2.get_value()
IO2output1value = IO2output1.get_value()
def create(self):
if not DBClient.db_created_already:
DBClient.db = InfluxDBClient(self.host, self.port, self.user, self.passcode, self.dbName)
DBClient.db.create_database(self.dbName)
DBClient.db_created_already = True
def write(self, json_data):
DBClient.db.write_points(json_data)
power_queue = Queue()
energy_queue = Queue()
c = DBClient('ascco_world', 8086)
c.create()
modC = ModbusClient(socket.gethostbyname('ascoworldmodem.hopto.org'), port=502)
modC.connect()
s1 = sched.scheduler(time.time, time.sleep)
s2 = sched.scheduler(time.time, time.sleep)
def worker1(q, c):
while True:
data = q.get()
##############################
templateLoader = jinja2.FileSystemLoader(searchpath='./', followlinks=True)
templateEnv = jinja2.Environment(loader=templateLoader)
TEMPLATE_FILE = "EMeter2_others.jinja"
template = templateEnv.get_template(TEMPLATE_FILE)
templateVars = {
"m1": "remote_monitor",
#!/usr/bin/env python
from pymodbus.client.sync import ModbusTcpClient as ModbusClient
import modbus_utilities as utilities_modbus
# --------------------------------------------------------------------------- #
# configure the service logging
# --------------------------------------------------------------------------- #
import logging
import time
log = logging.getLogger()
log.setLevel(logging.DEBUG)
# Create a client and connect to the camera server
client = ModbusClient(utilities_modbus.IP, port=utilities_modbus.PORT)
client.connect()
def run_sync_client(modbus_client, request):
# Read the registers
rr = modbus_client.read_holding_registers(address=utilities_modbus.ADDRESS,
count=3,
unit=utilities_modbus.UNIT)
if (rr.registers[0] == utilities_modbus.GET_BRICK_COLOR_WAIT):
print("INFO: Server is ready (waiting for order)")
if (rr.registers[1] == utilities_modbus.RESULT_WAIT):
print("INFO: Server is ready (result slot available)")
if (request == utilities_modbus.GET_BRICK_COLOR_BLUE):
if sendRequest(modbus_client, request):
checkResult(modbus_client, request)
elif (request == utilities_modbus.GET_BRICK_COLOR_RED):
# print('Read complete')
break
else:
# print('\nIncorrect input, try again')
time.sleep(0.5)
pass
except:
pass
print('\nIncorrect input, try again')
return d1
baudrate = 19200
client = ModbusClient(method='rtu',
port='COM11',
baudrate=baudrate,
parity='N',
timeout=1000)
connection = client.connect()
print('Modbus connect : ', connection)
lMeter = getDataPowerMeter(8)
# print(lMeter)
print('Meter6:', (lMeter[38] * 65536) + lMeter[39], 'kWh')
print('Amp P1:', lMeter[1] * 0.001, 'A')
print('Amp P2:', lMeter[3] * 0.001, 'A')
print('Amp P3:', lMeter[5] * 0.001, 'A')
print('V12:', (((lMeter[8] * 65536) + lMeter[9]) * 0.001), 'V')
print('V23:', (((lMeter[10] * 65536) + lMeter[11]) * 0.001), 'V')
print('V31:', (((lMeter[12] * 65536) + lMeter[13]) * 0.001), 'V')
print('V P1:', (((lMeter[14] * 65536) + lMeter[15]) * 0.001), 'V')
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()
def connect_bus(ip="192.168.88.250", PortN = 502, timeout = 3):
client = ModbusClient(host=ip, port=PortN, timeout=timeout, RetryOnEmpty = True, retries = 3)
time.sleep(1)
client.connect()
time.sleep(1)
return client
# import the server implementation
from pymodbus.client.sync import ModbusSerialClient as ModbusClient
#from test.testdata import ModbusMockClient as ModbusClient
from pymodbus.mei_message import *
from pyepsolartracer.registers import registers, coils
# configure the client logging
import logging
logging.basicConfig()
log = logging.getLogger()
log.setLevel(logging.INFO)
# choose the serial client
client = ModbusClient(method='rtu',
port='/dev/ttyXRUSB0',
baudrate=115200,
stopbits=1,
bytesize=8,
timeout=1)
client.connect()
request = ReadDeviceInformationRequest(unit=1)
response = client.execute(request)
print repr(response.information)
for reg in registers:
print
print "reg.address: %x" % reg.address
rr = client.read_input_registers(reg.address, 1, unit=1)
if hasattr(rr, "getRegister"):
print "read_input_registers:", rr.getRegister(0)
else:
logging.basicConfig(level="INFO")
log = logging.getLogger()
log.setLevel(logging.INFO)
MQTT_SERVER = "192.168.1.216"
MQTT_TOPIC_ROOT = "/MIRAI/"
# count= the number of registers to read
# unit= the slave unit this request is targeting
# address= the starting address to read from
try:
client_ModBus = ModbusClient(
method="rtu",
port="/dev/ttyUSB0",
stopbits=1,
bytesize=8,
parity='E',
baudrate=9600)
client_Mqtt = mqtt.Client("MIRAI-001")
print("Connecting to MQTT server... ", MQTT_SERVER)
if client_Mqtt.connect(MQTT_SERVER) == 0: # connect
while True:
# Connect to the serial modbus server
connection = client_ModBus.connect()
# print (connection)
if connection:
result1_start = 8970
def setUp(self):
""" Initializes the test environment """
super(Runner, self).setUp()
self.client = ModbusClient()
# Initialising energy meter variables for modbus client
method = "rtu"
port = "/dev/ttyUSB0"
baudrate = 2400
stopbits = 1
bytesize = 8
parity = "N"
timeout = 1
retries = 2
try:
client = ModbusClient(method=method,
port=port,
stopbits=stopbits,
bytesize=bytesize,
parity=parity,
baudrate=baudrate,
timeout=timeout,
retries=retries)
connection = client.connect()
except:
print("Modbus connection error / DDS238")
from flask import Flask, render_template, request
app = Flask(__name__)
global dds238_total
global dds238_export
global dds238_import
global voltage
#!/usr/bin/env python
import time
from pymodbus.constants import Endian
from pymodbus.payload import BinaryPayloadDecoder
from pymodbus.payload import BinaryPayloadBuilder
#from pymodbus.client.sync import ModbusTcpClient as ModbusClient
from pymodbus.client.sync import ModbusSerialClient as ModbusClient
#client = ModbusClient('10.18.78.222', port=502)
client = ModbusClient(method='rtu', port='/dev/ttyUSB0', baudrate=19200, timeout=0.1, dtr=False)
connection = client.connect()
client.socket.dtr = 0
client.socket.rts = 0
time.sleep(1.5)
client.socket.flushInput()
result = client.read_holding_registers(64,8,unit=3)
print result.registers
inp_num = raw_input("Input to change: ")
inp_mode = raw_input("New Mode: ")
rq = client.write_register(63+int(inp_num), int(inp_mode), unit=3)
result = client.read_holding_registers(64,8,unit=3)
print result.registers
#!/usr/bin/env python
from pymodbus.constants import Defaults
from pymodbus.client.sync import ModbusTcpClient as ModbusClient
Defaults.Timeout = 25
Defaults.Retries = 5
client = ModbusClient('ipaddress.of.venus', port='502')
client.write_register(806, 0)
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 successful 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
values = context.getValues(self.function_code, self.address,
self.count)
return CustomModbusResponse(values)
#---------------------------------------------------------------------------#
# This could also have been defined as
#---------------------------------------------------------------------------#
from pymodbus.bit_read_message import ReadCoilsRequest
class Read16CoilsRequest(ReadCoilsRequest):
def __init__(self, address):
''' Initializes a new instance
:param address: The address to start reading from
'''
ReadCoilsRequest.__init__(self, address, 16)
#---------------------------------------------------------------------------#
# execute the request with your client
#---------------------------------------------------------------------------#
# using the with context, the client will automatically be connected
# and closed when it leaves the current scope.
#---------------------------------------------------------------------------#
with ModbusClient('127.0.0.1') as client:
request = CustomModbusRequest(0)
result = client.execute(request)
print result
from pymodbus.client.sync import ModbusTcpClient as ModbusClient
import time
client = ModbusClient('127.0.0.1', port=502)
client.connect()
UNIT = 1
i = 0
while True:
# i = i+1
rq = client.write_registers(1, 0, unit=UNIT)
time.sleep(1)
def execute_extended_requests():
# ------------------------------------------------------------------------#
# 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.
#
# It should be noted that you can supply an ipv4 or an ipv6 host address
# for both the UDP and TCP clients.
# ------------------------------------------------------------------------#
client = ModbusClient(method='rtu', port="/dev/ttyp0")
# client = ModbusClient('127.0.0.1', port=5020)
client.connect()
# ----------------------------------------------------------------------- #
# extra requests
# ----------------------------------------------------------------------- #
# If you are performing a request that is not available in the client
# mixin, you have to perform the request like this instead::
#
# from pymodbus.diag_message import ClearCountersRequest
# from pymodbus.diag_message import ClearCountersResponse
#
# request = ClearCountersRequest()
# response = client.execute(request)
# if isinstance(response, ClearCountersResponse):
# ... do something with the response
#
#
# What follows is a listing of all the supported methods. Feel free to
# comment, uncomment, or modify each result set to match with your ref.
# ----------------------------------------------------------------------- #
# ----------------------------------------------------------------------- #
# information requests
# ----------------------------------------------------------------------- #
log.debug("Running ReadDeviceInformationRequest")
rq = ReadDeviceInformationRequest(unit=UNIT)
rr = client.execute(rq)
print(rr)
# assert(rr == None) # not supported by reference
# assert (rr.function_code < 0x80) # test that we are not an error
# assert (rr.information[0] == b'Pymodbus') # test the vendor name
# assert (rr.information[1] == b'PM') # test the product code
# assert (rr.information[2] == b'1.0') # test the code revision
log.debug("Running ReportSlaveIdRequest")
rq = ReportSlaveIdRequest(unit=UNIT)
rr = client.execute(rq)
print(rr)
# assert(rr == None) # not supported by reference
# assert(rr.function_code < 0x80) # test that we are not an error
# assert(rr.identifier == 0x00) # test the slave identifier
# assert(rr.status == 0x00) # test that the status is ok
log.debug("Running ReadExceptionStatusRequest")
rq = ReadExceptionStatusRequest(unit=UNIT)
rr = client.execute(rq)
print(rr)
# assert(rr == None) # not supported by reference
# assert(rr.function_code < 0x80) # test that we are not an error
# assert(rr.status == 0x55) # test the status code
log.debug("Running GetCommEventCounterRequest")
rq = GetCommEventCounterRequest(unit=UNIT)
rr = client.execute(rq)
print(rr)
# assert(rr == None) # not supported by reference
# assert(rr.function_code < 0x80) # test that we are not an error
# assert(rr.status == True) # test the status code
# assert(rr.count == 0x00) # test the status code
log.debug("Running GetCommEventLogRequest")
rq = GetCommEventLogRequest(unit=UNIT)
rr = client.execute(rq)
print(rr)
# assert(rr == None) # not supported by reference
# assert(rr.function_code < 0x80) # test that we are not an error
# assert(rr.status == True) # test the status code
# assert(rr.event_count == 0x00) # test the number of events
# assert(rr.message_count == 0x00) # test the number of messages
# assert(len(rr.events) == 0x00) # test the number of events
# ------------------------------------------------------------------------#
# diagnostic requests
# ------------------------------------------------------------------------#
log.debug("Running ReturnQueryDataRequest")
rq = ReturnQueryDataRequest(unit=UNIT)
rr = client.execute(rq)
print(rr)
# assert(rr == None) # not supported by reference
# assert(rr.message[0] == 0x0000) # test the resulting message
log.debug("Running RestartCommunicationsOptionRequest")
rq = RestartCommunicationsOptionRequest(unit=UNIT)
rr = client.execute(rq)
print(rr)
# assert(rr == None) # not supported by reference
# assert(rr.message == 0x0000) # test the resulting message
log.debug("Running ReturnDiagnosticRegisterRequest")
rq = ReturnDiagnosticRegisterRequest(unit=UNIT)
rr = client.execute(rq)
print(rr)
# assert(rr == None) # not supported by reference
log.debug("Running ChangeAsciiInputDelimiterRequest")
rq = ChangeAsciiInputDelimiterRequest(unit=UNIT)
rr = client.execute(rq)
print(rr)
# assert(rr == None) # not supported by reference
log.debug("Running ForceListenOnlyModeRequest")
rq = ForceListenOnlyModeRequest(unit=UNIT)
rr = client.execute(rq) # does not send a response
print(rr)
log.debug("Running ClearCountersRequest")
rq = ClearCountersRequest()
rr = client.execute(rq)
print(rr)
# assert(rr == None) # not supported by reference
log.debug("Running ReturnBusCommunicationErrorCountRequest")
rq = ReturnBusCommunicationErrorCountRequest(unit=UNIT)
rr = client.execute(rq)
print(rr)
# assert(rr == None) # not supported by reference
log.debug("Running ReturnBusExceptionErrorCountRequest")
rq = ReturnBusExceptionErrorCountRequest(unit=UNIT)
rr = client.execute(rq)
print(rr)
# assert(rr == None) # not supported by reference
log.debug("Running ReturnSlaveMessageCountRequest")
rq = ReturnSlaveMessageCountRequest(unit=UNIT)
rr = client.execute(rq)
print(rr)
# assert(rr == None) # not supported by reference
log.debug("Running ReturnSlaveNoResponseCountRequest")
rq = ReturnSlaveNoResponseCountRequest(unit=UNIT)
rr = client.execute(rq)
print(rr)
# assert(rr == None) # not supported by reference
log.debug("Running ReturnSlaveNAKCountRequest")
rq = ReturnSlaveNAKCountRequest(unit=UNIT)
rr = client.execute(rq)
print(rr)
# assert(rr == None) # not supported by reference
log.debug("Running ReturnSlaveBusyCountRequest")
rq = ReturnSlaveBusyCountRequest(unit=UNIT)
rr = client.execute(rq)
print(rr)
# assert(rr == None) # not supported by reference
log.debug("Running ReturnSlaveBusCharacterOverrunCountRequest")
rq = ReturnSlaveBusCharacterOverrunCountRequest(unit=UNIT)
rr = client.execute(rq)
print(rr)
# assert(rr == None) # not supported by reference
log.debug("Running ReturnIopOverrunCountRequest")
rq = ReturnIopOverrunCountRequest(unit=UNIT)
rr = client.execute(rq)
print(rr)
# assert(rr == None) # not supported by reference
log.debug("Running ClearOverrunCountRequest")
rq = ClearOverrunCountRequest(unit=UNIT)
rr = client.execute(rq)
print(rr)
# assert(rr == None) # not supported by reference
log.debug("Running GetClearModbusPlusRequest")
rq = GetClearModbusPlusRequest(unit=UNIT)
rr = client.execute(rq)
print(rr)
# assert(rr == None) # not supported by reference
# ------------------------------------------------------------------------#
# close the client
# ------------------------------------------------------------------------#
client.close()
def setUp(self):
""" Initializes the test environment """
self.initialize(
["../tools/reference/diagslave", "-m", "tcp", "-p", "12345"])
self.client = ModbusClient(port=12345)
def power_modbus2mongodb():
try:
t = time()
DBclient = MongoClient('mongodb://192.168.1.10/',
username='******',
password='******',
authSource='admin',
serverSelectionTimeoutMS=1000)
# try: # 数据库连接测试
# # The ismaster command is cheap and does not require auth.
# DBclient.admin.command('ismaster')
# except ConnectionFailure as e: # Exception
# DBclient.close()
# log.error(e)
# # print("Server not available")
# return
db = DBclient['sensor_management']
# collection = db['air_condition']
collection = db['power_test_0116']
name = ['room1', 'room2', 'room4']
gateway = [24, 48, 87]
register = [0x2000, 0x4000]
length = [18, 2]
var_n = [[
['voltage', 0],
['electric_current', 2],
['instant_total_active_power', 4],
['instant_useless_total_power', 6],
['instant_apparent_total_power', 8],
['power_factor_total', 10],
['grid_frequency', 14],
], [['total_active_energy', 0]]]
client = ModbusClient('192.168.1.146',
port=12345,
timeout=3,
framer=ModbusFramer)
is_connected = client.connect()
if is_connected: # modbus connect fail
for i in range(3):
data = {}
for j in range(2):
sleep(1)
rr = client.read_holding_registers(register[j],
length[j],
unit=gateway[i])
if hasattr(rr, 'registers'):
# data_modbus = {}
for v in var_n[j]:
# IEEE-754 hex to float
B = '{:0>16b}{:0>16b}'.format(
rr.registers[v[1]], rr.registers[v[1] + 1])
s = int(B[0])
e = int(B[1:9], 2) - 127
M = B[9:32]
if e > 0:
Mi = int('1' + M[0:e], 2)
Mf = M[e:23]
elif e == 0:
Mi = 1.0
Mf = M
else:
Mi = 0.0
Mf = '1' + M
for k in range(-e - 1):
Mf = '0' + Mf
xm = 0.0
for k in range(len(Mf)):
xm += int(Mf[k]) / 2**(k + 1)
x = (-1)**s * (Mi + xm)
data[v[0]] = x
else: # no data return
data['0x{:4x}'.format(register[j])] = 'No Data Return'
data_db = {
'name': name[i],
'data': data,
'datetime': datetime.now()
}
result = collection.insert_one(data_db)
else:
data_db = {
'name': '{:0>2d}xxxx'.format(bus),
'err': 'Modbus Connect Failed',
'datetime': datetime.now()
}
result = collection.insert_one(data_db)
client.close()
except ConnectionFailure as e:
log.error(e)
except Exception as e:
# log.exception(e)
# client.close()
# DBclient.close()
log.error(e)
return
finally:
DBclient.close()
