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()
