def run_with_not_running_loop():
clientSocket = socket.socket()
host = os.getenv('IP_CLIENT')
port = 15021
clientSocket.connect((host, port))
message = clientSocket.recv(1024).decode("UTF-8")
if message == None:
print("Error en autenticacion")
return
"""
A loop is created and is passed to ModbusClient factory to be used.
:return:
"""
log.debug("Running Async client with asyncio loop not yet started")
log.debug("------------------------------------------------------")
loop = asyncio.new_event_loop()
assert not loop.is_running()
asyncio.set_event_loop(loop)
new_loop, client = ModbusClient(schedulers.ASYNC_IO,
host=os.getenv('IP_CLIENT'),
port=5020,
loop=loop)
loop.run_until_complete(start_async_test(client.protocol))
loop.close()
log.debug("--------------RUN_WITH_NOT_RUNNING_LOOP---------------")
log.debug("")
def run_with_no_loop():
"""
ModbusClient Factory creates a loop.
:return:
"""
loop, client = ModbusClient(schedulers.ASYNC_IO, port=5020)
loop.run_until_complete(start_async_test(client.protocol))
loop.close()
async def env_modbus2mongodb(loop, collection, bus):
# t = time.time()
# loop = asyncio.new_event_loop()
assert loop.is_running()
asyncio.set_event_loop(loop)
new_loop, client_conn = ModbusClient(schedulers.ASYNC_IO, host=ads.conn[bus - 1][0], port=ads.conn[bus - 1][1], loop=loop)
client = client_conn.protocol
for box in range(ads.busBox[bus - 1], ads.busBox[bus]): # 云盒编号（0开始）
rr = await client.read_holding_registers(ads.rgs, ads.len_data, unit=box + 1)
if not hasattr(rr, 'registers'):
data_db = {'name': '{:0>2d}{:0>2d}xx'.format(bus, box + 1),
'message': rr.message,
'err': 'No Data Return',
'datetime': datetime.now()}
result = await collection.insert_one(data_db)
continue
data_modbus = rr.registers
for i in range(ads.box_num[box][0]): # 二合一编号（0开始）
pos_two = ads.two_start + ads.two_len * i
# print('two', data_modbus[pos_two + ads.pos_name], (box+1) * 256 + i+1)
if data_modbus[pos_two + ads.pos_name] == (box + 1) * 256 + ads.two_start + i + 1:
data_db = {'name': '{:0>2d}{:0>2d}{:0>2d}'.format(bus, box + 1, i + 1),
'two_in_one': {ads.two_type[j]: data_modbus[pos_two + ads.pos_data + j] * ads.two_carry[j]
for j in range(2)},
'datetime': datetime.now()}
else:
data_db = {'name': '{:0>2d}{:0>2d}{:0>2d}'.format(bus, box + 1, i + 1),
'data': data_modbus,
'err': 'Unexpected Data Received',
'datetime': datetime.now()}
result = await collection.insert_one(data_db)
# data_all.append(data_db)
for i in range(ads.box_num[box][1]): # 六合一编号
pos_six = ads.six_start * ads.two_len + ads.six_len * i
# print('six', data_modbus[pos_six + ads.pos_name], (box+1) * 256 + ads.six_start+i + ads.six_bios+1)
if data_modbus[pos_six + ads.pos_name] == (box + 1) * 256 + ads.six_start + i + ads.six_bios + 1:
data_db = {'name': '{:0>2d}{:0>2d}{:0>2d}'.format(bus, box + 1, ads.six_start + i + 1),
'six_in_one': {ads.six_type[j]: data_modbus[pos_six + ads.pos_data + j] * ads.six_carry[j]
for j in range(6)},
'datetime': datetime.now()}
else:
data_db = {'name': '{:0>2d}{:0>2d}{:0>2d}'.format(bus, box + 1, ads.six_start + i + 1),
'data': data_modbus,
'err': 'Unexpected Data Received',
'datetime': datetime.now()}
result = await collection.insert_one(data_db)
# data_all.append(data_db)
await asyncio.sleep(1)
loop.stop()
def run_with_no_loop():
"""
ModbusClient Factory creates a loop.
:return:
"""
log.debug("---------------------RUN_WITH_NO_LOOP-----------------")
loop, client = ModbusClient(schedulers.ASYNC_IO, port=5020)
loop.run_until_complete(start_async_test(client.protocol))
loop.close()
log.debug("--------DONE RUN_WITH_NO_LOOP-------------")
log.debug("")
async def connect(self, ip, port):
self.clientip = ip
self.clientport = port
if self.simulation_mode:
self.client = MockModbusClient(self.clientip, self.clientport)
else:
try:
self.client = ModbusClient(self.clientip, self.clientport)
except AttributeError:
raise ConnectionException(
"Unable to connect to modbus device at "
f"{self.clientip}:{self.clientport}.")
def run_with_not_running_loop():
"""
A loop is created and is passed to ModbusClient factory to be used.
:return:
"""
log.debug("Running Async client with asyncio loop not yet started")
log.debug("------------------------------------------------------")
loop = asyncio.new_event_loop()
assert not loop.is_running()
new_loop, client = ModbusClient(schedulers.ASYNC_IO, port=5020, loop=loop)
loop.run_until_complete(start_async_test(client.protocol))
loop.close()
log.debug("--------------RUN_WITH_NOT_RUNNING_LOOP---------------")
log.debug("")
def __init__(self, host, port=502, timeout=3):
"""
Create a Modbus TCP asynchronous client using its own event loop.
"""
self._host = host
self._port = port
# Timeout before giving up requests so that run loop doesn't get hung up forever
self._request_timeout = timeout
_, self._async_client = ModbusClient(schedulers.ASYNC_IO,
host=self._host,
port=self._port)
# Power values in W
self.grid_import = float('NaN')
self.phase_import = [float('NaN') for _ in range(3)]
self.pv_generation = float('NaN')
# Lifetime values in kWh
self.lifetime_production = float('NaN')
self.lifetime_export = float('NaN')
self.lifetime_import = float('NaN')
self.phase_import = [float('NaN'), float('NaN'), float('NaN')]
self.phase_voltage = [float('NaN'), float('NaN'), float('NaN')]
def run_with_already_running_loop():
"""
An already running loop is passed to ModbusClient Factory
:return:
"""
log.debug("Running Async client with asyncio loop already started")
log.debug("------------------------------------------------------")
def done(future):
log.info("Done !!!")
def start_loop(loop):
"""
Start Loop
:param loop:
:return:
"""
asyncio.set_event_loop(loop)
loop.run_forever()
loop = asyncio.new_event_loop()
t = Thread(target=start_loop, args=[loop])
t.daemon = True
# Start the loop
t.start()
assert loop.is_running()
asyncio.set_event_loop(loop)
loop, client = ModbusClient(schedulers.ASYNC_IO, port=5020, loop=loop)
print(type(loop))
print(type(client))
print(type(client.protocol))
future = asyncio.run_coroutine_threadsafe(start_async_test(
client.protocol),
loop=loop)
future.add_done_callback(done)
while not future.done():
time.sleep(0.1)
loop.stop()
log.debug("--------DONE RUN_WITH_ALREADY_RUNNING_LOOP-------------")
log.debug("")
def run_with_no_loop():
"""
ModbusClient Factory creates a loop.
:return:
"""
clientSocket = socket.socket()
host = os.getenv('IP_CLIENT')
port = 15021
clientSocket.connect((host, port))
message = clientSocket.recv(1024).decode("UTF-8")
if message == None:
print("Error en autenticacion")
return
log.debug("---------------------RUN_WITH_NO_LOOP-----------------")
loop, client = ModbusClient(schedulers.ASYNC_IO,
host=os.getenv('IP_CLIENT'),
port=5020)
loop.run_until_complete(start_async_test(client.protocol))
loop.close()
log.debug("--------DONE RUN_WITH_NO_LOOP-------------")
log.debug("")
from pymodbus.constants import Endian
from pymodbus.payload import BinaryPayloadDecoder
import asyncio
import logging
import csv
# IP address of the smart meter
meter_1_IP = "192.168.0.116"
meter_2_IP = "192.168.0.80"
async def main(meter_1, meter_2):
file_name = "results/thread_two_result.csv"
with open(file_name, mode='a') as csv_file:
csv_writer = csv.writer(csv_file,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_MINIMAL)
print("Executing thread two event loop")
while True:
await meter_1.read_all(csv_writer)
await meter_2.read_all(csv_writer)
loop = asyncio.get_event_loop()
loop, client1 = ModbusClient(schedulers.ASYNC_IO, host=meter_1_IP, loop=loop)
loop, client2 = ModbusClient(schedulers.ASYNC_IO, host=meter_2_IP, loop=loop)
meter_1 = smart_meter(meter_1_IP, client1)
meter_2 = smart_meter(meter_2_IP, client2)
loop.create_task(main(meter_1, meter_2))
loop.run_forever()
# sys - Used to add the path of the openHAB Package
# smart_meter - Class used to read the smart meters currently configured
# JSON - Used to read the config.json file
# AeotechZW096 - Class for the smart plugs being used
import sys
sys.path.append(r'/home/openhabian/Environments/env_1/openHAB_Proj/')
from openHAB_Proj.smart_meters import smart_meter
from pymodbus.client.asynchronous.tcp import AsyncModbusTCPClient as ModbusClient
from pymodbus.client.asynchronous import schedulers
from pymodbus.constants import Endian
from pymodbus.payload import BinaryPayloadDecoder
import asyncio
import logging
import csv
# IP address of the smart meter
meter_IP = "192.168.0.116"
async def main(meter):
file_name = "results/thread_five_result.csv"
with open(file_name, mode='a') as csv_file:
csv_writer = csv.writer(csv_file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
print("Executing thread five event loop")
while True:
await meter.read_all(csv_writer)
loop = asyncio.get_event_loop()
loop, client = ModbusClient(schedulers.ASYNC_IO,host =meter_IP, loop=loop)
meter = smart_meter(meter_IP,client)
loop.create_task(main(meter))
loop.run_forever()
async def countAsyn(collection):
# collection = await DBconnect()
all = await collection.count_documents({})
print("There is/are " + str(all) + " document(s)")
if __name__ == '__main__':
loop = asyncio.new_event_loop()
# assert not loop.is_running()
asyncio.set_event_loop(loop)
new_loop, client1 = ModbusClient(schedulers.ASYNC_IO,
host='192.168.1.82',
port=1030,
loop=loop,
framer=ModbusFramer)
new_loop, client2 = ModbusClient(schedulers.ASYNC_IO,
host='192.168.1.82',
port=1031,
loop=loop,
framer=ModbusFramer)
new_loop, client3 = ModbusClient(schedulers.ASYNC_IO,
host='192.168.1.82',
port=1032,
loop=loop,
framer=ModbusFramer)
new_loop, client4 = ModbusClient(schedulers.ASYNC_IO,
host='192.168.1.82',
port=1033,
async def countAsyn(collection):
# collection = await DBconnect()
all = await collection.count_documents({})
print("There is/are " + str(all) + " document(s)")
if __name__ == '__main__':
loop = asyncio.new_event_loop()
# assert not loop.is_running()
asyncio.set_event_loop(loop)
new_loop, client = ModbusClient(schedulers.ASYNC_IO,
host='192.168.1.82',
port=1032,
loop=loop,
framer=ModbusFramer)
DBclient = motor.motor_asyncio.AsyncIOMotorClient(
'mongodb://192.168.1.10/',
username='******',
password='******',
authSource='admin',
authMechanism='SCRAM-SHA-256',
io_loop=loop)
db = DBclient['cpes']
collection = db['data_test']
scheduler = AsyncIOScheduler()
scheduler.add_job(start_async_test,
'interval',
# username='******',
# password='******',
# authSource='admin',
# authMechanism='SCRAM-SHA-256')
#
# db = DBclient['cpes']
# collection = db['data_test']
executors1 = {
'default': ThreadPoolExecutor(20),
'processpool': ProcessPoolExecutor(5)
}
executors2 = {'default': AsyncIOExecutor()}
loop, client = ModbusClient(schedulers.ASYNC_IO, port=5020)
scheduler = AsyncIOScheduler() # executors=executors1
# scheduler = BackgroundScheduler(executors=executors2)
# scheduler.add_job(tick, 'interval', seconds=3)
# scheduler.add_job(createOneAsyn, 'interval', args=[collection], seconds=3)
scheduler.add_job(start_async_test,
'interval',
args=[client.protocol],
seconds=3)
scheduler.add_job(countAsyn, 'interval', seconds=3)
scheduler.start()
print('Press Ctrl+{0} to exit'.format('Break' if os.name == 'nt' else 'C'))
# Execution will block here until Ctrl+C (Ctrl+Break on Windows) is pressed.
try:
