enode-host 0.1.0__py3-none-any.whl

enode_host/backup/esp_mesh.py

@@ -0,0 +1,136 @@
+import socket
+import time
+import threading
+import logging
+import struct
+import datetime
+import getmac 
+import os
+from queue import Queue
+import config
+from scipy.interpolate import interp1d
+from numpy import where, logical_and, empty, append, array, delete, floor
+try:
+    from . import queues
+except ImportError:
+    import queues
+
+
+# CONFIGURATION
+rawFileLength_sec = config.rawFileLength_sec
+port = config.port
+target_dir = config.target_dir 
+from model import packet_size, ChannelType, CmdType
+
+npackets = 63
+
+logger = logging.getLogger(__name__)
+
+class Esp_Mesh():
+
+    def __init__(self, model):
+        
+        self.model = model
+        self.sockets = {}
+
+        thread = threading.Thread(target = self.mesh_svr_begin)
+        thread.start()
+        logger.info("mesh_server started.")
+
+    def get_ip_address(self):
+
+        try:
+            # This will get the local IP address of your machine
+            host_name = socket.gethostname()
+            ip_address = socket.gethostbyname(host_name)
+            return ip_address
+        except socket.error as e: 
+            print(f"Error: {e}")
+            return None
+        
+    def handle_client(self, client_socket, ip_address):
+
+        logger.info("handle_client called...")
+        data = bytearray()
+        nodeID = 0   
+        # client_socket.settimeout(0)   
+        is_socket_stored = False  
+                
+        while True:
+            try:                     
+                # Managing Sockets: store the handle for access from outside
+                if True:
+                    data += client_socket.recv(packet_size * npackets) 
+                else:
+                    data += client_socket.recv(packet_size * 1) 
+                # Storing socket handler for access from outside
+                if not is_socket_stored and len(data) >= packet_size:
+                    packet = data[:packet_size]
+                    rec = struct.unpack('>H', packet[:2])   # B = unsigned char (1byte), 
+                                                            # H = unsigned short integer (2byte), 
+                    nodeID = rec[0]  # consisting of nodeType (uint8_t) + nodeNUmber (uint8_t) 
+                    logger.info('nodeID={}'.format(nodeID))
+                    self.sockets[nodeID] = client_socket
+                    is_socket_stored = True
+                # forward the data to parser
+                if is_socket_stored:
+                    self.model.data_push(nodeID, data)
+                    logger.debug('data_pushed {} bytes'.format(len(data)))
+                    data.clear()
+                #time.sleep(0.5)
+
+            # except BlockingIOError:
+            #     time.sleep(0.1)
+            # except socket.timeout:
+            #     time.sleep(0.1)
+            except Exception as e:
+                errnum = e.args[0]
+                if errnum in [104, 113, 110] :
+                    # 110: connection tiemout
+                    # peer closed the connection, then svr closes it as well
+                    break
+                else:
+                    raise
+        # delete socket handle if disconnected
+        del self.sockets[nodeID]
+        logger.info("close()...")        
+        client_socket.close()
+        # queues.Mesh2GUI.put({'updateType': 1, 'nodeID': nodeID, 'connection': False})
+
+    def mesh_svr_begin(self):
+
+        # Create a socket object
+        server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        # print("recv buffer size = {}".format(server_socket.getsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF)))    
+        hostname = socket.gethostname()
+        # if hostname in ['wing1a', 'wing3.lan']:
+        #     host = self.get_ip_address()    
+        # else:
+        #     host = '192.168.1.104'
+        host = '192.168.1.202'
+        logger.info(f"ip address= {host}")
+
+        while(True):
+            try:
+                server_socket.bind((host, port)) # Bind the socket to the host and port
+                break
+            except:
+                print(".")
+                time.sleep(1)
+        server_socket.listen(20)    # Listen for incoming connections; The argument is the maximum number of queued connections
+        logger.info(f"Server is listening on {host}:{port}")
+        while True:
+            logger.info("Waiting for a connection...")
+            client_socket, client_address = server_socket.accept()
+            logger.info(f"Accepted connection from {client_address}")
+            # Start a new thread to handle the client
+            client_handler = threading.Thread(target=self.handle_client, args=(client_socket, client_address,))
+            client_handler.start()   
+
+    def send_cmd(self, nodeID, cmd, data0 = 0, data1 = 0):
+        
+        msg = struct.pack('=BBBBB', cmd, data0, data1, 0, 0)
+        logger.info('msg={}'.format(msg))
+        self.sockets[nodeID].send(msg)
+
+        

enode_host/backup/gui_comps.py

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'gui_v2.ui'
+#
+# Created by: PyQt5 UI code generator 5.15.9
+#
+# WARNING: Any manual changes made to this file will be lost when pyuic5 is
+# run again.  Do not edit this file unless you know what you are doing.
+
+
+from PyQt5 import QtCore, QtGui, QtWidgets
+
+
+class Ui_MainWindow(object):
+    def setupUi(self, MainWindow):
+        MainWindow.setObjectName("MainWindow")
+        MainWindow.resize(860, 596)
+        self.centralwidget = QtWidgets.QWidget(MainWindow)
+        self.centralwidget.setObjectName("centralwidget")
+        self.widget = QtWidgets.QWidget(self.centralwidget)
+        # self.widget.setGeometry(QtCore.QRect(10, 10, 831, 531))
+        self.widget.setObjectName("widget")
+
+        #
+        # LAYOUTS
+        #
+
+        # Vertical layout
+        self.verticalLayout = QtWidgets.QVBoxLayout(self.widget)
+        # self.verticalLayout.setContentsMargins(0, 0, 0, 0)
+        self.verticalLayout.setObjectName("verticalLayout")
+
+        # Horizontal layout 1
+        self.horizontalLayout1 = QtWidgets.QHBoxLayout()
+        self.horizontalLayout1.setObjectName("horizontalLayout1")
+        
+        # Horizontal layout 2
+        self.horizontalLayout2 = QtWidgets.QHBoxLayout()
+        self.horizontalLayout2.setObjectName("horizontalLayout2")
+        
+        self.verticalLayout.addLayout(self.horizontalLayout1)
+        self.verticalLayout.addLayout(self.horizontalLayout2)
+
+        # add Widgets for Horizontal layout1       
+        self.label = QtWidgets.QLabel(self.widget)
+        font = QtGui.QFont()
+        font.setFamily("Arial")
+        font.setBold(True)
+        font.setWeight(75)
+        self.label.setFont(font)
+        self.label.setObjectName("label")
+        self.label.setText("Number of Nodes")
+        self.horizontalLayout1.addWidget(self.label)
+
+        self.spinBox = QtWidgets.QSpinBox(self.widget)
+        self.spinBox.setMaximum(16)
+        self.spinBox.setProperty("value", 14)
+        self.spinBox.setObjectName("spinBox")
+        self.spinBox.valueChanged.connect(self.update_nnodes)
+        self.horizontalLayout1.addWidget(self.spinBox)
+
+        self.pushButton = QtWidgets.QPushButton(self.widget)
+        self.pushButton.setObjectName("pushButton")
+        self.horizontalLayout1.addWidget(self.pushButton)
+        self.pushButton_2 = QtWidgets.QPushButton(self.widget)
+        self.pushButton_2.setObjectName("pushButton_2")
+        self.horizontalLayout1.addWidget(self.pushButton_2)
+
+        # Add widgets for Horizontal layout2        
+        self.tableView = QtWidgets.QTableView(self.widget)
+        self.tableView.setObjectName("tableView")
+        self.horizontalLayout2.addWidget(self.tableView, stretch = 1)
+       
+        self.listView = []
+        # self.listView = QtWidgets.QListView(self.widget)
+        # self.listView.setObjectName("listView")
+        # self.verticalLayout.addWidget(self.listView, stretch=3)
+
+        self.centralwidget.setLayout(self.verticalLayout)
+        MainWindow.setCentralWidget(self.centralwidget)
+
+        # self.menubar = QtWidgets.QMenuBar(MainWindow)
+        # self.menubar.setGeometry(QtCore.QRect(0, 0, 860, 20))
+        # self.menubar.setObjectName("menubar")
+        # self.menu_File = QtWidgets.QMenu(self.menubar)
+        # self.menu_File.setObjectName("menu_File")
+        # MainWindow.setMenuBar(self.menubar)
+        # self.statusbar = QtWidgets.QStatusBar(MainWindow)
+        # self.statusbar.setObjectName("statusbar")
+        # MainWindow.setStatusBar(self.statusbar)
+        # self.action_Open = QtWidgets.QAction(MainWindow)
+        # self.action_Open.setObjectName("action_Open")
+        # self.action_Action1 = QtWidgets.QAction(MainWindow)
+        # self.action_Action1.setObjectName("action_Action1")
+        # self.menu_File.addAction(self.action_Open)
+        # self.menubar.addAction(self.menu_File.menuAction())
+
+        self.retranslateUi(MainWindow)
+        QtCore.QMetaObject.connectSlotsByName(MainWindow)
+
+    def retranslateUi(self, MainWindow):
+        pass
+        _translate = QtCore.QCoreApplication.translate
+        MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
+        self.label.setText(_translate("MainWindow", "Number of Nodes"))
+        self.pushButton.setText(_translate("MainWindow", "Start DAQ All"))
+        self.pushButton_2.setText(_translate("MainWindow", "Reboot All"))
+        # self.menu_File.setTitle(_translate("MainWindow", "&File"))
+        # self.action_Open.setText(_translate("MainWindow", "&Quit"))
+        # self.action_Action1.setText(_translate("MainWindow", "&Action1"))
+
+    def update_nnodes(self, value):
+        print("nnode={}".format(value))

enode_host/backup/gui_wx_bk.py

@@ -0,0 +1,270 @@
+#!/usr/local/bin/python3
+# -*- coding: utf-8 -*-
+
+###########################################################################
+## Python code generated with wxFormBuilder (version 4.2.1-0-g80c4cb6)
+## http://www.wxformbuilder.org/
+##
+## PLEASE DO *NOT* EDIT THIS FILE!
+###########################################################################
+
+import wx
+import wx.xrc
+import wx.grid
+
+import gettext
+_ = gettext.gettext
+
+###########################################################################
+## Class MyFrame1
+###########################################################################
+
+class MyFrame1 ( wx.Frame ):
+
+    def __init__( self, parent ):
+        wx.Frame.__init__ ( self, parent, id = wx.ID_ANY, title = _(u"Wireless Sensor DAQ"), pos = wx.DefaultPosition, size = wx.Size( 1024,600 ), style = wx.DEFAULT_FRAME_STYLE|wx.TAB_TRAVERSAL )
+
+        self.SetSizeHints( wx.DefaultSize, wx.DefaultSize )
+
+        bSizer1 = wx.BoxSizer( wx.VERTICAL )
+
+        bSizer2 = wx.BoxSizer( wx.HORIZONTAL )
+
+        self.m_staticText2 = wx.StaticText( self, wx.ID_ANY, _(u"Sensor Nodes:"), wx.DefaultPosition, wx.DefaultSize, 0 )
+        self.m_staticText2.Wrap( -1 )
+
+        bSizer2.Add( self.m_staticText2, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5 )
+
+        self.m_textCtrl2 = wx.TextCtrl( self, wx.ID_ANY, wx.EmptyString, wx.DefaultPosition, wx.DefaultSize, 0 )
+        bSizer2.Add( self.m_textCtrl2, 1, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5 )
+
+        self.m_staticText3 = wx.StaticText( self, wx.ID_ANY, _(u"Fs="), wx.DefaultPosition, wx.DefaultSize, 0 )
+        self.m_staticText3.Wrap( -1 )
+
+        bSizer2.Add( self.m_staticText3, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5 )
+
+        m_choice1Choices = [ _(u"62.5"), _(u"125") ]
+        self.m_choice1 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, m_choice1Choices, 0 )
+        self.m_choice1.SetSelection( 0 )
+        bSizer2.Add( self.m_choice1, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5 )
+
+        self.m_staticText4 = wx.StaticText( self, wx.ID_ANY, _(u"Hz"), wx.DefaultPosition, wx.DefaultSize, 0 )
+        self.m_staticText4.Wrap( -1 )
+
+        bSizer2.Add( self.m_staticText4, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5 )
+
+        self.m_button1 = wx.Button( self, wx.ID_ANY, _(u"Start DAQ"), wx.DefaultPosition, wx.DefaultSize, 0 )
+        bSizer2.Add( self.m_button1, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5 )
+
+        self.m_button2 = wx.Button( self, wx.ID_ANY, _(u"Stop DAQ"), wx.DefaultPosition, wx.DefaultSize, 0 )
+        bSizer2.Add( self.m_button2, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5 )
+
+
+        bSizer1.Add( bSizer2, 0, wx.EXPAND, 5 )
+
+        bSizer3 = wx.BoxSizer( wx.HORIZONTAL )
+
+        bSizer4 = wx.BoxSizer( wx.VERTICAL )
+
+        self.m_staticText21 = wx.StaticText( self, wx.ID_ANY, _(u"WiFi Mesh Status"), wx.DefaultPosition, wx.DefaultSize, 0 )
+        self.m_staticText21.Wrap( -1 )
+
+        bSizer4.Add( self.m_staticText21, 0, wx.ALL, 5 )
+
+        self.m_grid2 = wx.grid.Grid( self, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, 0 )
+
+        # Grid
+        self.m_grid2.CreateGrid( 5, 6 )
+        self.m_grid2.EnableEditing( True )
+        self.m_grid2.EnableGridLines( True )
+        self.m_grid2.EnableDragGridSize( True )
+        self.m_grid2.SetMargins( 0, 0 )
+
+        # Columns
+        self.m_grid2.SetColSize( 0, 70 )
+        self.m_grid2.SetColSize( 1, 100 )
+        self.m_grid2.SetColSize( 2, 20 )
+        self.m_grid2.SetColSize( 3, 40 )
+        self.m_grid2.SetColSize( 4, 40 )
+        self.m_grid2.SetColSize( 5, 45 )
+        self.m_grid2.EnableDragColMove( False )
+        self.m_grid2.EnableDragColSize( True )
+        self.m_grid2.SetColLabelValue( 0, _(u"Node ID") )
+        self.m_grid2.SetColLabelValue( 1, _(u"Status") )
+        self.m_grid2.SetColLabelValue( 2, _(u"L") )
+        self.m_grid2.SetColLabelValue( 3, _(u"RSSI") )
+        self.m_grid2.SetColLabelValue( 4, _(u"PPS") )
+        self.m_grid2.SetColLabelValue( 5, _(u"Data") )
+        self.m_grid2.SetColLabelSize( wx.grid.GRID_AUTOSIZE )
+        self.m_grid2.SetColLabelAlignment( wx.ALIGN_CENTER, wx.ALIGN_CENTER )
+
+        # Rows
+        self.m_grid2.EnableDragRowSize( True )
+        self.m_grid2.SetRowLabelSize( wx.grid.GRID_AUTOSIZE )
+        self.m_grid2.SetRowLabelAlignment( wx.ALIGN_CENTER, wx.ALIGN_CENTER )
+
+        # Label Appearance
+
+        # Cell Defaults
+        self.m_grid2.SetDefaultCellAlignment( wx.ALIGN_LEFT, wx.ALIGN_TOP )
+        bSizer4.Add( self.m_grid2, 1, wx.ALL|wx.EXPAND, 5 )
+
+
+        bSizer3.Add( bSizer4, 0, wx.EXPAND, 5 )
+
+        self.m_notebook2 = wx.Notebook( self, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, 0 )
+        self.m_panel1 = wx.Panel( self.m_notebook2, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL )
+        self.m_notebook2.AddPage( self.m_panel1, _(u"Time history plot"), True )
+        self.m_panel2 = wx.Panel( self.m_notebook2, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL )
+        self.m_notebook2.AddPage( self.m_panel2, _(u"PSD plot"), False )
+
+        bSizer3.Add( self.m_notebook2, 1, wx.ALL|wx.EXPAND, 5 )
+
+
+        bSizer1.Add( bSizer3, 1, wx.EXPAND, 5 )
+
+        self.m_textCtrl21 = wx.TextCtrl( self, wx.ID_ANY, _(u"\"test line 1\ntest2 line|\""), wx.DefaultPosition, wx.Size( -1,100 ), 0 )
+        bSizer1.Add( self.m_textCtrl21, 0, wx.ALL|wx.EXPAND, 5 )
+
+
+        self.SetSizer( bSizer1 )
+        self.Layout()
+
+        
+        # MENU
+        self.m_statusBar1 = self.CreateStatusBar(1, wx.STB_SIZEGRIP, wx.ID_ANY)
+        self.m_menubar = wx.MenuBar(0)
+        self.m_menu_file = wx.Menu()
+        self.m_menu_file_open = wx.MenuItem(self.m_menu_file, wx.ID_ANY, _(u"&Open"), wx.EmptyString, wx.ITEM_NORMAL)
+        self.m_menu_file_save = wx.MenuItem(self.m_menu_file, wx.ID_ANY, _(u"&Save"), wx.EmptyString, wx.ITEM_NORMAL)
+        self.m_menu_file_quit = wx.MenuItem(self.m_menu_file, wx.ID_ANY, _(u"&Quit"), wx.EmptyString, wx.ITEM_NORMAL)
+        self.m_menu_file.Append(self.m_menu_file_open)
+        self.m_menu_file.Append(self.m_menu_file_save)
+        self.m_menu_file.AppendSeparator()
+        self.m_menu_file.Append(self.m_menu_file_quit)
+        self.m_menubar.Append(self.m_menu_file, _(u"&File"))
+
+        self.m_menu_help = wx.Menu()
+        self.m_menu_help_about = wx.MenuItem(self.m_menu_help, wx.ID_ANY, _(u"&Help"), wx.EmptyString, wx.ITEM_NORMAL)
+        self.m_menu_help.Append(self.m_menu_help_about)
+        self.m_menubar.Append(self.m_menu_help, _(u"&Help"))
+
+        self.SetMenuBar(self.m_menubar) 
+
+        self.Centre( wx.BOTH )
+
+        # Connect Events
+        self.m_textCtrl2.Bind( wx.EVT_TEXT, self.test )
+
+
+
+    def __del__( self ):
+        pass
+
+
+    # Virtual event handlers, override them in your derived class
+    def test( self, event ):
+        event.Skip()
+
+import wx
+import wx.lib.agw.aui as aui
+import wx.lib.mixins.inspection as wit
+from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas
+from matplotlib.backends.backend_wxagg import \
+    NavigationToolbar2WxAgg as NavigationToolbar
+from matplotlib.figure import Figure
+
+class Plot(wx.Panel):
+    def __init__(self, parent, id=-1, dpi=None, **kwargs):
+        super().__init__(parent, id=id, **kwargs)
+        self.figure = Figure(dpi=dpi, figsize=(2, 2))
+        self.canvas = FigureCanvas(self, -1, self.figure)
+        self.toolbar = NavigationToolbar(self.canvas)
+        self.toolbar.Realize()
+
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(self.canvas, 1, wx.EXPAND)
+        sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
+        self.SetSizer(sizer)
+
+class PlotNotebook(wx.Panel):
+    def __init__(self, parent, id=-1):
+        super().__init__(parent, id=id)
+        self.nb = aui.AuiNotebook(self)
+        sizer = wx.BoxSizer()
+        sizer.Add(self.nb, 1, wx.EXPAND)
+        self.SetSizer(sizer)
+
+    def add(self, name="plot"):
+        page = Plot(self.nb)
+        self.nb.AddPage(page, name)
+        return page.figure
+
+
+import wx.grid as gridlib
+import configparser
+import os
+
+CONFIG_FILE = 'config.ini'
+
+def save_config(options):
+    config = configparser.ConfigParser()
+
+    config['Settings'] = {
+        'option1': options['option1'],
+        'option2': options['option2']
+    }
+
+    with open(CONFIG_FILE, 'w') as configfile:
+        config.write(configfile)
+
+def load_config():
+    config = configparser.ConfigParser()
+
+    if not os.path.exists(CONFIG_FILE):
+        # Return default options if config file doesn't exist
+        return {
+            'option1': 'default_value1',
+            'option2': 'default_value2'
+        }
+
+    config.read(CONFIG_FILE)
+    options = {
+        'option1': config.get('Settings', 'option1', fallback='default_value1'),
+        'option2': config.get('Settings', 'option2', fallback='default_value2')
+    }
+
+    return options
+
+def MainWindow():
+    # window = wx.Frame(None, title = "wxPython Frame", size = (300,200)) 
+    frame1 = MyFrame1(None)
+
+
+    fig1 = Plot(frame1.m_panel1)
+    # plotter = PlotNotebook(frame1.m_notebook2)
+    axes1 = fig1.figure.add_subplot()
+    axes1.plot([1, 2, 3], [2, 1, 4])
+    fig2 = Plot(frame1.m_panel2)
+    axes2 = fig2.figure.add_subplot()
+    axes2.plot([1, 2, 3, 4, 5], [2, 1, 4, 2, 3])
+
+    canvas = FigureCanvas(frame1.m_panel1, -1, fig1.figure)
+    sizer = wx.BoxSizer(wx.VERTICAL)
+    sizer.Add(canvas, 1, wx.EXPAND)
+
+    # Set the sizer for the panel
+    frame1.m_panel1.SetSizer(sizer)
+
+    # Change the background color of cell (1, 1)
+    attr = gridlib.GridCellAttr()
+    attr.SetBackgroundColour(wx.Colour(255, 255, 0))  # Yellow
+    frame1.m_grid2.SetAttr(1, 1, attr)
+
+
+    frame1.Show(True) 
+
+    
+    
+    return frame1 
+

enode_host/backup/load_file.py

@@ -0,0 +1,27 @@
+from numpy import *
+import struct
+import datetime
+import os
+import pandas as pd
+
+
+def load_adxl355_file(filename):
+    t, y = [], []
+    with open(filename, 'rb') as file:
+        while True:
+            chunk = file.read(24)
+            if not chunk:
+                break
+            data = struct.unpack('<QIfff', chunk)
+
+            t_ = datetime.datetime.fromtimestamp(data[0])
+            t_ = t_.replace(microsecond = data[1])
+            t.append(t_)
+            y.append(data[2:])
+    t = array(t)
+    y = array(y)
+    df = pd.DataFrame({'timestamps': t, "X": y[:, 0], "Y": y[:, 1], "Z": y[:, 2]})
+    df.set_index(df['timestamps'], inplace = True)
+    del df['timestamps']    
+    return df 
+

enode_host/backup/s.py

@@ -0,0 +1,151 @@
+#!/usr/local/bin/python3
+
+#----------------------------------------------
+# HOW TO USE THE SYSTEM
+#
+# 1. please execute this file first, so that the server is ready to receive data from ndoes
+# 2. turn on the node(s)
+#    - the PPS LED on the display can be believed
+#    - please don't believe RSSI, Lv, BAT %, as they are not completed yet.
+# 3. Files are saved under data2 folder in HDF 
+# 4. Please read example.ipynb for how to load data file and display it
+#    - Please notice the time is in UTC to avoid any issues regarding British Summer Time
+# 5. For time-sync, never reset the acc node, but power-cycle it. 
+#    - there are two buttons on the sensor node: 
+#      - one for power next to the USB-c port
+#      - the other for reset next to the SD slot
+#    - pressing the pwr button for 5 sec will shutdown the node, and pressing it for 1 sec will start the node
+
+
+import logging
+import gui
+import mesh
+import sys
+from PyQt5 import QtCore, QtGui, QtWidgets
+from PyQt5.QtGui import QColor
+import threading
+import queues
+from numpy import array
+import shm_sigproc
+import glob
+import os 
+
+from matplotlib.pyplot import *
+
+
+
+os.makedirs("log", exist_ok = True)
+os.makedirs("data", exist_ok = True)
+os.makedirs("data2", exist_ok = True)
+
+
+logging.basicConfig(level=logging.INFO,  # Set the minimum log level
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                    handlers=[logging.FileHandler('log/my_log_file.log'), logging.StreamHandler()])
+logger = logging.getLogger(__name__)
+
+
+df = []
+psd = []
+
+
+def begin():
+
+    mesh.begin()
+    shm_sigproc.begin()
+
+    app = QtWidgets.QApplication(sys.argv)
+    window = gui.MainWindow()    
+    app.exec_()
+
+
+
+def export():
+
+    global df
+
+    raw_data_dir = 'data2'
+
+    node_IDs = []
+    
+    import os 
+    import pandas as pd
+
+
+    entries = os.listdir(raw_data_dir)
+    files = [f for f in entries if f.endswith('.hd5')]
+
+    # IDENTIFY NODE IDs
+    for file in files:
+        node_IDs.append(file.split('-')[0])
+    node_IDs = sorted(set(node_IDs))
+
+    # READ AND MERGE ALL RAW DATA FILES
+    dfs = []
+    for node_ID in node_IDs:
+        dfs_ = []
+        files_ = [f for f in entries if f.endswith('.hd5') and f.startswith(node_ID)]
+        for file_ in files_:
+            dfs_.append(pd.read_hdf(os.path.join(raw_data_dir, file_)))
+        df_ = pd.concat(dfs_, axis = 0)
+        df_ = df_.rename(columns={
+                                'X': '{}-X'.format(node_ID),
+                                'Y': '{}-Y'.format(node_ID),
+                                'Z': '{}-Z'.format(node_ID)
+                                                })
+        dfs.append(df_)
+
+    df = pd.concat(dfs, axis = 1)
+    df = df.dropna()
+    df.plot(figsize=(24, 6))
+    show()
+
+    filename = "data/daq-{}".format(df.index[0].strftime("%Y_%m%d_%H%M"))
+    df.to_hdf(filename, key="df")
+
+    
+
+def clear():
+    # DELETE TEMPORARIL FILES
+    for file in glob.glob("data2/*.hd5"):
+        try:
+            os.remove(file)
+        except Exception as e:
+            logger.error(f"Error deleting file {file}: {e}")
+
+
+
+if __name__ == '__main__':
+    begin()
+
+# thread = threading.Thread(target = main)
+# thread.start()
+# logger.info("mesh_server started.")
+
+# grid_time = int(datetime.datetime.now().timestamp()/config.TIME_WINDOW_LENGTH_SEC) * config.TIME_WINDOW_LENGTH_SEC
+
+# timeWindow = [datetime.datetime.fromtimestamp(grid_time),
+#               datetime.datetime.fromtimestamp(grid_time + config.TIME_WINDOW_LENGTH_SEC)]
+# tdata = thp_lines[nodeID-1].get_xdata()
+# ydata = thp_lines[nodeID-1].get_ydata()
+# idx = where(array(tdata) < timeWindow[0])
+# tdata = delete(tdata, idx[0])
+# ydata = delete(ydata, idx[0], 0)
+# tdata = append(tdata, t)
+# ydata = append(ydata, y)
+# thp_lines[nodeID - 1].set_xdata(tdata)
+# thp_lines[nodeID - 1].set_ydata(ydata)
+# sc = window.m_ui.listView
+# sc.axes[0].set_xlim(timeWindow[0], timeWindow[1])
+# sc.axes[0].xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))
+# draw()
+# # pause(0.05)
+# # show(block = False)
+# logger.info("len(tdata) = {}".format(len(tdata)))
+
+
+# for t, y_ in zip(t, y):
+#     logger.info("{}, {}, {}, {}".format(t, y_[0], y_[1], y_[2]))
+
+# time.sleep(0.1)
+