class Net: recvbuff = stack(maxsize=512) sendbuff = stack(maxsize=512) socket = MeshSocket( get_ip_address(), port=4444, ) def __init__(self, target, port, tries=100, node_type=True, data_backup=None): """ py2p documentation (p2p-project) https://dev-docs.p2p.today/python/tutorial/mesh.html :param target: target computer :param port: target port :param tries: timeout :param node_type: True -> initially connecting, False -> initially listening -if both try to connect at once it disconnects both """ try: self.logger = logging.getLogger("Networking") if node_type: i = 0 while not self.socket.routing_table and i < tries: try: self.socket.connect(target, port) self.logger.info(f"Connected to {target}:{port}") break except BaseException as e: self.logger.info( f"\rFailed to Connect to {target}:{port} ({i}/{tries})" ) i += 1 if not self.socket.routing_table: exit(-1) else: while not self.socket.routing_table: self.logger.info("Waiting for Connection") sleep(1) self.logger.info("Connected") except BaseException as e: print(e) print(self.socket.status) if isinstance(data_backup, DataBackup): self.data_backup = data_backup else: self.data_backup = None
def __init__(self, target, port, szbuff=2048): self.wbuff = stack(maxsize=szbuff) self.rbuff = stack(maxsize=szbuff) self.socket = mesh.MeshSocket(get_ip_address(), port) self.t, self.p = target, port self.loop1 = asyncio.new_event_loop() threading.Thread(target=self.loop1.run_forever).start() f1 = asyncio.run_coroutine_threadsafe(self._send_thread(), self.loop1) self.loop2 = asyncio.new_event_loop() threading.Thread(target=self.loop2.run_forever).start() f2 = asyncio.run_coroutine_threadsafe(self._recv_thread(), self.loop2)
class DataBackup: buffer = stack(maxsize=2048) def __init__(self, config:dict): self.cfg = config["data"] self.cnt = 0 self.logger = logging.getLogger("DataLogging") self.loop = asyncio.new_event_loop() threading.Thread(target=self.loop.run_until_complete).start() f1 = asyncio.run_coroutine_threadsafe(self.BackupLoop(), self.loop) def dump(self, data): self.buffer.put_nowait(pickle.dumps(data)) def backup(self, data:dict): fname = f"{self.cnt}-{self.cfg['prefix']}.{self.cfg['postfix']}" data = json.dumps(data, indent=4) with open(fname, "w") as f: f.write(data) f.close() self.logger.debug(f"Wrote {sizeof(data)} bytes to {fname}") async def BackupLoop(self): while 1: if not self.buffer.empty(): self.backup(self.buffer.get_nowait())
def postOrder(self, root): if not root: return s1 = stack() s2 = stack() s1.put(root) while not s1.empty(): temp = s1.get() s2.put(temp) if temp.left_child: s1.get(temp.left_child) if temp.right_child: s1.get(temp.right_child) while not s2.empty(): self._visit(s2.get())
class terminalNetwork: #tcp client recvbuffer = stack(maxsize=2048) sendbuffer = stack(maxsize=2048) def __init__(self, server): self.addr = server self.logger = logging.getLogger() async def conn(self): self.logger.info("Trying to Create Connection") self.r, self.w = await asyncio.open_connection(host=self.addr[0], port=self.addr[1]) self.logger.info( f"[terminalNetwork] Established Reader and Writer streams to server:\t{self.addr}" ) def read(self): if not self.recvbuffer.empty(): return self.recvbuffer.get_nowait() return None def write(self, data): self.sendbuffer.put_nowait(data) async def net_send_loop(self): self.logger.info("net_send_loop started") while 1: if not self.sendbuffer.empty(): msg = self.sendbuffer.get_nowait() msg = pack(msg) self.w.write(msg) await self.w.drain() self.logger.info( f"[terminalNetwork] wrote {len(msg)} bytes to {self.w}") async def net_recv_loop(self): self.logger.info("net_recv_loop started") while 1: data = await self.r.readline() self.logger.info( f"[terminalNetwork] read {len(data)} bytes from {self.r}") data = pickle.loads(data) self.recvbuffer.put_nowait(data)
def preOrder(self, root): if not root: return s = stack() temp = root while temp or not s.empty(): while temp: self._visit(temp) s.put(temp) temp = temp.left_child if not s.empty(): temp = s.get() temp = temp.right_child
class hardwareNetwork: recvbuffer = stack(maxsize=2048) sendbuffer = stack(maxsize=2048) def __init__(self, addr): self.addr = addr self.logger = logging.getLogger() self.svr = socket.create_server(self.addr) self.svr.listen(5) self.logger.info("Successfully Created Server") self.conn, self.caddr = self.svr.accept() self.logger.info(f"Connected to {self.caddr}") async def net_send_loop(self): while 1: await asyncio.sleep(0.1) async def net_recv_loop(self): while 1: await asyncio.sleep(0.1)
def __init__(self, target, port, szbuff=2048, backup=None, auto_start_threading=False): self.wbuff = stack(maxsize=szbuff) self.rbuff = stack(maxsize=szbuff) self.socket = mesh.MeshSocket(get_ip_address(), port) self.t, self.p = target, port if backup != None: self.backup = backup else: self.backup = backup self.threading = auto_start_threading if auto_start_threading: self.loop1 = asyncio.new_event_loop() threading.Thread(target=self.loop1.run_forever).start() f1 = asyncio.run_coroutine_threadsafe(self._send_thread(), self.loop1) self.loop2 = asyncio.new_event_loop() threading.Thread(target=self.loop2.run_forever).start() f2 = asyncio.run_coroutine_threadsafe(self._recv_thread(), self.loop2)
class HardwareManager: cmdbuffer = stack(max=64) #true -> on #false -> off states = { "pressurize_tanks": False, "lox_vent": False, "kerosene_vent": False, "lox_dump": False, "kerosene_dump": False, "shutdown": False, "emergency_shutdown": False } current_pressures = {"p1": 0, "p2": 0, "p3": 0, "p4": 0} def init_load_cell(self, cfg): self.lc = VoltageRatioInput() self.lc.setDeviceSerialNumber(cfg["serialnumber"]) self.lc.setChannel(cfg["channel"]) def __init__(self, cfg, net: Net): self.hcfg = cfg["rpi"]["GPIO"] self.net = net self.logger = logging.getLogger("Hardware") #init gpio for valve in self.hcfg["valves"].keys(): GPIO.setup(self.hcfg[valve]["v"], GPIO.OUT, initial=GPIO.LOW) for sensor in self.hcfg["pressure"].keys(): pass self.init_load_cell(self.hcfg["loadcell"]) self.logger.info("Hardware Initialized") def report_states(self): return self.states def report_data(self) -> dict: pass async def collect_data(self): while 1: pass def cmd(self, cmd): self.cmdbuffer.put_nowait(cmd) def exec(self, cmd: str): """ executes necessary hardware changes to cause system change :param cmd: string for selected hardware sequence :return: nothing """ if cmd == "lox_vent": self.states["lox_vent"] = True elif cmd == "kerosene_vent": self.states["kerosene_vent"] = True elif cmd == "ignition": self.states["kerosene_dump"] = True self.states["lox_dump"] = True elif cmd == "kerosene_dump": self.states["kerosene_dump"] = True elif cmd == "lox_dump": self.states["lox_dump"] = True elif cmd == "pressurize": self.states["pressurize"] = True elif cmd == "shutdown": pass
def __init__(self): self.stack_out = stack() # Pop stack self.stack_in = stack() # Push stack
from queue import LifoQueue as stack import asyncio global recv global svr recv = stack(maxsize=2048) svr = ("staic", 999) async def client(): global recv r, w = await asyncio.open_connection()