Class name changed

Author: PayalLakra

chords_wifi.py

@@ -4,7 +4,7 @@
 import socket
 from scipy.signal import butter, filtfilt
 
-class NPG_Wifi:
+class Chords_WIFI:
     def __init__(self, stream_name='NPG', channels=3, sampling_rate=250, block_size=13, timeout_sec=1):
         self.stream_name = stream_name
         self.channels = channels
@@ -129,7 +129,7 @@ def __del__(self):
 if __name__ == "__main__":
     client = None
     try:
-        client = NPG_Wifi()
+        client = Chords_WIFI()
         client.connect()
         client.process_data()
     except Exception as e:

connection.py

@@ -1,6 +1,6 @@
-from chords_serial import Serial_USB
-from chords_wifi import NPG_Wifi
-from chords_ble import NPG_Ble
+from chords_serial import Chords_USB
+from chords_wifi import Chords_WIFI
+from chords_ble import Chords_BLE
 from pylsl import StreamInfo, StreamOutlet
 import argparse
 import time
@@ -13,7 +13,7 @@ class Connection:
     def __init__(self, csv_logging=False):
         self.ble_connection = None
         self.wifi_connection = None
-        self.lsl_outlet = None
+        self.lsl_connection = None
         self.stream_name = "BioAmpDataStream"
         self.stream_type = "EXG"
         self.stream_format = "float32"
@@ -28,7 +28,7 @@ def __init__(self, csv_logging=False):
         self.num_channels = 0
 
     async def get_ble_device(self):
-        devices = await NPG_Ble.scan_devices()
+        devices = await Chords_BLE.scan_devices()
         if not devices:
             print("No NPG devices found!")
             return None
@@ -49,40 +49,47 @@ async def get_ble_device(self):
 
     def setup_lsl(self, num_channels, sampling_rate):
         info = StreamInfo(self.stream_name, self.stream_type, num_channels, sampling_rate, self.stream_format, self.stream_id)
-        self.lsl_outlet = StreamOutlet(info)
+        self.lsl_connection = StreamOutlet(info)
         print(f"LSL stream started: {num_channels} channels at {sampling_rate}Hz")
         self.num_channels = num_channels
 
     def setup_csv(self):
-        if not self.csv_logging:
-            return
+        if not self.csv_logging or self.csv_file:
+            return  # Already set up or logging disabled
 
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"ChordsPy{timestamp}.csv"
-        self.csv_file = open(filename, 'w', newline='')
-        headers = ['Counter'] + [f'Channel{i+1}' for i in range(self.num_channels)]
-        self.csv_writer = csv.writer(self.csv_file)
-        self.csv_writer.writerow(headers)
-        print(f"CSV logging started: {filename}")
+        try:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"ChordsPy_{timestamp}.csv"
+            self.csv_file = open(filename, 'w', newline='')
+            headers = ['Counter'] + [f'Channel{i+1}' for i in range(self.num_channels)]
+            self.csv_writer = csv.writer(self.csv_file)
+            self.csv_writer.writerow(headers)
+            print(f"CSV logging started: {filename}")
+        except Exception as e:
+            print(f"Error setting up CSV logging: {str(e)}")
+            self.csv_logging = False
 
     def log_to_csv(self, sample_data):
         if not self.csv_logging or not self.csv_writer:
             return
 
-        self.sample_counter += 1
-        row = [self.sample_counter] + sample_data
-        self.csv_writer.writerow(row)
+        try:
+            self.sample_counter += 1
+            row = [self.sample_counter] + sample_data
+            self.csv_writer.writerow(row)
+        except Exception as e:
+            print(f"Error writing to CSV: {str(e)}")
+            self.csv_logging = False
 
     def connect_ble(self, device_address=None):
-        self.ble_connection = NPG_Ble()
+        self.ble_connection = Chords_BLE()
         original_notification_handler = self.ble_connection.notification_handler
-        
-        def wrapped_notification_handler(sender, data):
+            
+        def notification_handler(sender, data):
             if len(data) == self.ble_connection.NEW_PACKET_LEN:
-                if not self.lsl_outlet:
+                if not self.lsl_connection:
                     self.setup_lsl(num_channels=3, sampling_rate=500)
                     self.setup_csv()
-                    print("BLE LSL stream started")
 
                 original_notification_handler(sender, data)
 
@@ -96,25 +103,30 @@ def wrapped_notification_handler(sender, data):
                         ]
                         self.last_sample = channels
                         self.ble_samples_received += 1
+                
+                        if self.lsl_connection:             # Push to LSL
+                            self.lsl_connection.push_sample(channels)
+                        self.log_to_csv(channels)           # Log to CSV
 
-                        if self.lsl_outlet:             # Push to LSL
-                            self.lsl_outlet.push_sample(channels)
-                        self.log_to_csv(channels)       # Log to CSV
-        
-        self.ble_connection.notification_handler = wrapped_notification_handler
-        
-        if device_address:
-            self.ble_connection.connect(device_address)
-        else:
-            selected_device = asyncio.run(self.get_ble_device())
-            if not selected_device:
-                return
-            self.ble_connection.connect(selected_device.address)
-        
-        print("BLE connection established. Waiting for data...")
+        self.ble_connection.notification_handler = notification_handler
+            
+        try:
+            if device_address:
+                print(f"Connecting to BLE device: {device_address}")
+                self.ble_connection.connect(device_address)
+            else:
+                selected_device = asyncio.run(self.get_ble_device())
+                if not selected_device:
+                    return
+                print(f"Connecting to BLE device: {selected_device.name}")
+                self.ble_connection.connect(selected_device.address)
+            
+            print("BLE connection established. Waiting for data...")
+        except Exception as e:
+            print(f"BLE connection failed: {str(e)}")
 
     def connect_usb(self):
-        serial_connection = Serial_USB()
+        serial_connection = Chords_USB()
         if serial_connection.detect_hardware():
             self.num_channels = serial_connection.num_channels
             sampling_rate = serial_connection.supported_boards[serial_connection.board]["sampling_rate"]
@@ -125,21 +137,25 @@ def connect_usb(self):
             original_read_data = serial_connection.read_data
             def wrapped_read_data():
                 original_read_data()
-                if hasattr(serial_connection, 'data') and self.lsl_outlet:
+                if hasattr(serial_connection, 'data') and self.lsl_connection:
                     sample = serial_connection.data[:, -1]
-                    self.lsl_outlet.push_sample(sample)
+                    self.lsl_connection.push_sample(sample)
                     self.log_to_csv(sample.tolist())
 
             serial_connection.read_data = wrapped_read_data
             serial_connection.start_streaming()
 
     def connect_wifi(self):
-        self.wifi_connection = NPG_Wifi()
+        self.wifi_connection = Chords_WIFI()
         self.wifi_connection.connect()
 
         self.num_channels = self.wifi_connection.channels
-        self.setup_lsl(self.num_channels, self.wifi_connection.sampling_rate)
-        self.setup_csv()
+        sampling_rate = self.wifi_connection.sampling_rate
+
+        if not self.lsl_connection:
+            self.setup_lsl(self.num_channels, sampling_rate)
+            if self.csv_logging:
+                self.setup_csv()
 
         try:
             print("\nConnected! (Press Ctrl+C to stop)")
@@ -158,10 +174,11 @@ def connect_wifi(self):
                             sample = int.from_bytes(block[offset:offset + 2], byteorder='big', signed=True)
                             channel_data.append(sample)
 
-                        if self.lsl_outlet:           # Push to LSL
-                            self.lsl_outlet.push_sample(channel_data)
-                        self.log_to_csv(channel_data) # Log to CSV
-                
+                        if self.lsl_connection:                   # Push to LSL
+                            self.lsl_connection.push_sample(channel_data)
+                        if self.csv_logging and self.csv_writer:  # Only log if CSV is set up
+                            self.log_to_csv(channel_data)
+                    
         except KeyboardInterrupt:
             self.wifi_connection.disconnect()
             print("\nDisconnected")
@@ -190,7 +207,7 @@ def main():
         elif args.protocol == 'ble':
             manager.connect_ble(args.ble_address)
     except KeyboardInterrupt:
-        print("\nDisconnecting...")
+        print("\nCleanup Completed.")
     except Exception as e:
         print(f"Error: {str(e)}")