Untitled

import socket
import threading
import tkinter as tk

class TCPDataCollector:
    def __init__(self, server_ip, server_port, identifier):
        self.server_ip = server_ip
        self.server_port = server_port
        self.identifier = identifier
        
        self.data_collector = None
        self.collecting = False
        self.receive_thread = None
        self.received_data = []  # List to store received data
        self.first_data_value = ""
        self.lock = threading.Lock()  # Lock for thread safety
        
        # Setup GUI
        self.root = tk.Tk()
        self.root.title("TCP Data Collector")
        
        # Set the font to larger and bold
        self.font = ("Helvetica", 200, "bold")
        self.label = tk.Label(self.root, text="", font=self.font)
        self.label.pack(pady=20)
        self.update_gui()
    
    def start_collecting(self):
        self.collecting = True
        self.data_collector = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        
        try:
            self.data_collector.connect((self.server_ip, self.server_port))
            self.receive_thread = threading.Thread(target=self.receive_data)
            self.receive_thread.start()
            self.root.mainloop()  # Start the GUI event loop
        except Exception as e:
            print(f"Error connecting to {self.server_ip}:{self.server_port}: {e}")
            self.collecting = False
    
    def stop_collecting(self):
        self.collecting = False
        if self.data_collector:
            self.data_collector.close()
        if self.receive_thread:
            self.receive_thread.join()
    
    def receive_data(self):
        while self.collecting:
            try:
                received_data = self.data_collector.recv(1024)
                if received_data:
                    decoded_data = received_data.decode('utf-8').strip()
                    
                    # Check if the line starts with '$F'
                    if decoded_data.startswith('$F'):
                        with self.lock:
                            self.received_data.append(decoded_data)
                            
                            # Split the line by commas and process the first data value
                            parts = decoded_data.split(',')
                            if len(parts) > 1:
                                self.first_data_value = parts[1].strip()
                        
                        self.log_data_to_file(decoded_data)
                        
                        # Further process if identifier matches
                        if len(parts) >= 2 and parts[1] == str(self.identifier):
                            data_value = parts[4].strip('"')
                            self.print_filtered_data(data_value)
            except Exception as e:
                print(f"Error receiving data: {e}")
                self.stop_collecting()
                break
    
    def update_gui(self):
        with self.lock:
            # Only set the number value in the label
            self.label.config(text=self.first_data_value)
        self.root.after(1000, self.update_gui)  # Refresh every 1000 ms (1 second)
    
    def print_filtered_data(self, value):
        print(f"Filtered Data: {value}")
    
    def log_data_to_file(self, data):
        log_file_path = "received_data_log.txt"  # Update this to your desired path
        with open(log_file_path, "a") as file:
            file.write(data + "\n")

if __name__ == '__main__':
    server_ip = '192.168.1.140'  # Replace with the IP address of your server
    server_port = 50000  # Replace with the port your server is listening on
    identifier = 96  # Replace with the identifier you are interested in
    
    collector = TCPDataCollector(server_ip, server_port, identifier)
    collector.start_collecting()
    
    try:
        while True:
            pass
    except KeyboardInterrupt:
        collector.stop_collecting()
        print("\nData collection stopped.")