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()
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()
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("")
def __init__(self, host, port="502", timeout=5, loop=None): # pylint: disable=unpacking-non-sequence LOGGER.debug("creating loop and client") self.loop, self.client = AsyncModbusTCPClient( schedulers.ASYNC_IO, port=port, host=host, loop=loop ) LOGGER.debug("created loop and client") self.timeout = timeout self._time_offset = None
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 testTcpTornadoClient(self, mock_iostream, mock_ioloop): """ Test the TCP tornado client client initialize """ protocol, future = AsyncModbusTCPClient(schedulers.IO_LOOP, framer=ModbusSocketFramer(ClientDecoder())) client = future.result() assert(isinstance(client, AsyncTornadoModbusTcpClient)) assert(0 == len(list(client.transaction))) assert(isinstance(client.framer, ModbusSocketFramer)) assert(client.port == 502) assert client._connected assert(client.stream.connect.call_count == 1) assert(client.stream.read_until_close.call_count == 1) def handle_failure(failure): assert(isinstance(failure.exception(), ConnectionException)) d = client._build_response(0x00) d.add_done_callback(handle_failure) assert(client._connected) client.close() protocol.stop() assert(not client._connected)
def testTcpTornadoClient(self, mock_iostream, mock_ioloop): """ Test the TCP tornado client client initialize """ protocol, future = AsyncModbusTCPClient(schedulers.IO_LOOP, framer=ModbusSocketFramer(ClientDecoder())) client = future.result() assert(isinstance(client, AsyncTornadoModbusTcpClient)) assert(0 == len(list(client.transaction))) assert(isinstance(client.framer, ModbusSocketFramer)) assert(client.port == 502) assert client._connected assert(client.stream.connect.call_count == 1) assert(client.stream.read_until_close.call_count == 1) def handle_failure(failure): assert(isinstance(failure.exception(), ConnectionException)) d = client._build_response(0x00) d.add_done_callback(handle_failure) assert(client._connected) client.close() protocol.stop() assert(not client._connected)
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("")
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) 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 testTcpTwistedClient(self): """ Test the TCP Twisted client :return: """ from twisted.internet import reactor with patch("twisted.internet.reactor") as mock_reactor: def test_callback(client): pass def test_errback(client): pass AsyncModbusTCPClient(schedulers.REACTOR, framer=ModbusSocketFramer(ClientDecoder()), callback=test_callback, errback=test_errback)
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()
) as json_file: data = json.load(json_file) #Only insterested in what this script controls #Decided upon by the OpenHAB group try: data_1 = data[group] except KeyError: logger.error(f"No items found for {group}") things = dict() #Iterate through the Things assigned to this script for key, val in data_1.items(): plug = AeotechZW096() # Give the instance the variables obtained from config.json plug.__dict__ = val # Things is a dictionary where the key is the plug UID # The value is an instnace of the Aeotech class things[plug.UID] = plug # Get the event loop loop = asyncio.get_event_loop() # Create an instance of AsyncModbusTCPClient which is connected to meter 192.168.0.116 loop, client = ModbusClient(schedulers.ASYNC_IO, host=meter_1_IP, loop=loop) logger.info(f"Creating smart meter instance with IP of {meter_1_IP}") # Create an instance of the smart_meter class passing the IP and connection to meter 192.168.0.116 meter_1 = smart_meter(meter_1_IP, client) # Add main() to the event loop as a task passing smart_meter instance and dictionary of AeotechZW096 instances loop.create_task(main(meter_1, things)) logger.info(f"Entering event loop") # Run the loop forever loop.run_forever()
# 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 # # --------------------------------------------------------------------------- # # --------------------------------------------------------------------------- # # 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 __name__ == "__main__": protocol, deferred = AsyncModbusTCPClient(schedulers.REACTOR, port=5020) # protocol, deferred = AsyncModbusUDPClient(schedulers.REACTOR, port=5020) # callback=beginAsynchronousTest, # errback=err) deferred.addCallback(beginAsynchronousTest) deferred.addErrback(err)