update canvas engine for sdr-tcp

sdr-tcp/client-gui.py

@@ -26,14 +26,14 @@ class SDRClient(QMainWindow):
         # Параметры подключения к серверу
         self.server_ip = '127.0.0.1'
         self.server_port = 5003
-        self.sock = None
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         # Параметры для отрисовки
         self.channel_data = {
-            'time': np.array([]),
-            'channel_g': np.array([]),
-            'channel_rf': np.array([]),
-            'channel_adc_ttl': np.array([]),
-            'channel_rf_ttl': np.array([])
+            'time': np.array([], dtype=np.int64),
+            'channel_g': np.array([], dtype=np.int16),
+            'channel_rf': np.array([], dtype=np.int16),
+            'channel_adc_ttl': np.array([], dtype=np.int16),
+            'channel_rf_ttl': np.array([], dtype=np.int16)
         }
         self.wavetypes = ["default"]
         # Настройка окна
@@ -88,12 +88,15 @@ class SDRClient(QMainWindow):
         self.disconnect_button.clicked.connect(self.disconnect_from_server)
         self.add_event_button.clicked.connect(self.add_event_dialog)
         self.add_rfwave_button.clicked.connect(self.add_wavetype_dialog)
+        self.run_event_list_button.clicked.connect(self.run_event_list)
+        self.clear_event_list_button.clicked.connect(self.clear_event_list)
+        self.recv_sim_data_button.clicked.connect(self.receive_sim_data)
 
     def connect_to_server(self):
         try:
-            self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             self.sock.connect((self.server_ip, self.server_port))
             print(f"Connected to SDR server at {self.server_ip}:{self.server_port}")
+            QMessageBox.information(self, "Connection Successful", f"Successfully connected to SDR server at {self.server_ip}:{self.server_port}")
         except Exception as e:
             print(f"Failed to connect to server: {e}")
             QMessageBox.critical(self, "Connection Error", f"Failed to connect to server: {e}")
@@ -102,7 +105,6 @@ class SDRClient(QMainWindow):
     def disconnect_from_server(self):
         if self.sock:
             self.sock.close()
-            self.sock = None
             QMessageBox.information(self, "Disconnected", "Successfully disconnected from SDR server")
             print("Disconnected from SDR server")
 
@@ -141,7 +143,9 @@ class SDRClient(QMainWindow):
 
     def submit_event(self):
         try:
-            event_data = {
+            msg = {
+                "magic": 0xAA,
+                "cmd": 0x10,
                 "time": int(self.event_inputs["Start Time (ticks)"].text()),
                 "duration": int(self.event_inputs["Duration (ticks)"].text()),
                 "wave": self.event_inputs["Waveform Type"].currentText(),
@@ -153,11 +157,16 @@ class SDRClient(QMainWindow):
                 "rf_end": int(self.event_inputs["time_end_rf (ticks)"].text()),
                 "carrier_freq": float(self.event_inputs["rf_freq (Hz)"].text())
             }
-            msg = msgpack.packb({"command": 0x10, "data": event_data})
+            msg = msgpack.packb(msg, use_bin_type=True)
             self.sock.sendall(msg)
+            raw_resp = self.sock.recv(4096)
+            if not raw_resp:
+                raise Exception("No response from server")
+            resp = msgpack.unpackb(raw_resp, raw=False)
+            if resp["cmd"] != 0xFE or resp["code"] != 0x00000010:
+                raise Exception(f"Server error: {resp['message']}")
             print("Event added successfully")
             QMessageBox.information(self, "Success", "Event added successfully")
-            self.add_event_dialog.close()
         except Exception as e:
             print(f"Failed to add event: {e}")
             QMessageBox.critical(self, "Error", f"Failed to add event: {e}")
@@ -187,7 +196,7 @@ class SDRClient(QMainWindow):
                     }
                     packed_msg = msgpack.packb(msg, use_bin_type=True)
                     self.sock.sendall(packed_msg)
-                    resp = self.sock.recv(1024)
+                    resp = self.sock.recv(4096)
                     if not resp:
                         raise Exception("No response from server")
                     unpacked_resp = msgpack.unpackb(resp, raw=False)
@@ -260,7 +269,7 @@ class SDRClient(QMainWindow):
             packed_header = msgpack.packb(header_msg, use_bin_type=True)
             self.sock.sendall(packed_header)
             
-            raw_resp = self.sock.recv(1024)
+            raw_resp = self.sock.recv(4096)
             if not raw_resp:
                 raise Exception("No response from server")
             resp = msgpack.unpackb(raw_resp, raw=False)
@@ -282,19 +291,19 @@ class SDRClient(QMainWindow):
                     "cmd": 0x2C,
                     "packet_index": i,
                     "packet_length": packet_length,
-                    "wavedata_q": total_wavedata_q[start_idx:end_idx],
-                    "wavedata_i": total_wavedata_i[start_idx:end_idx]
+                    "wavedata_q": total_wavedata_q[start_idx:end_idx].tobytes(),
+                    "wavedata_i": total_wavedata_i[start_idx:end_idx].tobytes()
                 }
                 packed_packet = msgpack.packb(packet_data, use_bin_type=True)
                 self.sock.sendall(packed_packet)
-                raw_resp = self.sock.recv(1024)
+                raw_resp = self.sock.recv(4096)
                 if not raw_resp:
                     raise Exception("No response from server")
                 resp = msgpack.unpackb(raw_resp, raw=False)
                 if resp["cmd"] != 0xFE or resp["code"] != 0x00000002:
                     raise Exception(f"Server error: {resp['message']}")
                 self.sock.sendall(b"ACK") # Send ACK to server to indicate ready for next packet
-            raw_resp = self.sock.recv(1024)
+            raw_resp = self.sock.recv(4096)
             if not raw_resp:
                 raise Exception("No response from server after sending all packets")
             resp = msgpack.unpackb(raw_resp, raw=False)
@@ -310,6 +319,137 @@ class SDRClient(QMainWindow):
         QMessageBox.information(self, "Success", f"Added new waveform type: {name}")
         dialog.close()
 
+    def run_event_list(self):
+        msg = {
+            "magic": 0xAA,
+            "cmd": 0x30,
+            "interpolation_method": "linear"  # Placeholder, can be extended to allow user selection of interpolation method
+        }
+        try:
+            packed_msg = msgpack.packb(msg, use_bin_type=True)
+            self.sock.sendall(packed_msg)
+            print("Sent run event list command to server")
+        except Exception as e:
+            print(f"Failed to send run event list command: {e}")
+            QMessageBox.critical(self, "Error", f"Failed to send run event list command: {e}")
+            return
+        raw_resp = self.sock.recv(4096)
+        if not raw_resp:
+            print("No response from server after sending run event list command")
+            QMessageBox.warning(self, "No Response", "No response from server after sending run event list command")
+            return
+        resp = msgpack.unpackb(raw_resp, raw=False)
+        if resp["cmd"] != 0xFE or resp["code"] != 0x00000032:
+            print(f"Server error after sending run event list command: {resp['message']}")
+            QMessageBox.warning(self, "Server Error", f"Server error after sending run event list command: {resp['message']}")
+            return
+        QMessageBox.information(self, "Success", "Run event list command sent to server")
+
+    def clear_event_list(self):
+        msg = {
+            "magic": 0xAA,
+            "cmd": 0x60
+        }
+        try:
+            packed_msg = msgpack.packb(msg, use_bin_type=True)
+            self.sock.sendall(packed_msg)
+            print("Sent clear event list command to server")
+        except Exception as e:
+            print(f"Failed to send clear event list command: {e}")
+            QMessageBox.critical(self, "Error", f"Failed to send clear event list command: {e}")
+            return
+        raw_resp = self.sock.recv(4096)
+        if not raw_resp:
+            print("No response from server after sending clear event list command")
+            QMessageBox.warning(self, "No Response", "No response from server after sending clear event list command")
+            return
+        resp = msgpack.unpackb(raw_resp, raw=False)
+        if resp["cmd"] != 0xFE or resp["code"] != 0x00000040:
+            print(f"Server error after sending clear event list command: {resp['message']}")
+            QMessageBox.warning(self, "Server Error", f"Server error after sending clear event list command: {resp['message']}")
+            return
+        QMessageBox.information(self, "Success", "Clear event list command sent to server")
+
+    def plot_sim_data(self):
+        self.plot_canvas.axes.clear()
+        self.plot_canvas.axes.plot(self.channel_data["time"], self.channel_data["channel_g"], label="Gradient")
+        self.plot_canvas.axes.plot(self.channel_data["time"], self.channel_data["channel_rf"], label="RF")
+        self.plot_canvas.axes.plot(self.channel_data["time"], self.channel_data["channel_adc_ttl"], label="ADC TTL")
+        self.plot_canvas.axes.plot(self.channel_data["time"], self.channel_data["channel_rf_ttl"], label="RF TTL")
+        self.plot_canvas.axes.set_xlabel("Time (ticks)")
+        self.plot_canvas.axes.set_ylabel("Signal Value")
+        self.plot_canvas.axes.set_title("Simulation Data from SDR Server")
+        self.plot_canvas.axes.legend()
+        self.plot_canvas.draw()
+
+    def receive_sim_data(self):
+        msg = {
+            "magic": 0xAA,
+            "cmd": 0x40
+        }
+
+        try:
+            packed_msg = msgpack.packb(msg, use_bin_type=True)
+            self.sock.sendall(packed_msg)
+            print("Sent request to receive simulation data from server")
+        except Exception as e:
+            print(f"Failed to send request for simulation data: {e}")
+            QMessageBox.critical(self, "Error", f"Failed to send request for simulation data: {e}")
+            return
+        try:
+            raw_resp = self.sock.recv(4096)
+            if not raw_resp:
+                raise Exception("No response from server after requesting simulation data")
+            resp = msgpack.unpackb(raw_resp, raw=False) 
+            if resp["cmd"] != 0xFE or resp["code"] != 0x00000043:
+                raise Exception(f"Server error after requesting simulation data: {resp['message']}")
+        except Exception as e:
+            print(f"Failed to receive simulation data header: {e}")
+            QMessageBox.critical(self, "Error", f"Failed to receive simulation data header: {e}")
+            return
+        
+        print(f"Server is ready to send simulation data: {resp['message']}")
+        self.sock.sendall(b"ACK") # Send ACK to server to indicate ready to receive simulation data
+
+        while True:
+            try:
+                raw_packet = self.sock.recv(8192)
+                if not raw_packet:
+                    print("No more data from server, finished receiving simulation data")
+                    break
+                packet = msgpack.unpackb(raw_packet, raw=False)
+                if packet["cmd"] == 0xFE and packet["code"] == 0x00000044:
+                    print(f"Received end of simulation data message from server: {self.channel_data}") # Debug print to check received data
+                    self.plot_sim_data()
+                    QMessageBox.information(self, "Simulation Data Received", "All simulation data packets received from server")
+                    break
+                if packet["cmd"] != 0x33:
+                    print(f"Received non-simulation data message from server: {packet}")
+                    continue
+                channel = packet["channel"]
+                packet_index = packet["packet_index"]
+                total_packets = packet["total_packets"]
+                data_length = packet["data_length"]
+                print(f"Received simulation data packet {packet_index}/{total_packets} for channel {channel} with length {data_length} bytes")
+                if channel not in self.channel_data:
+                    print(f"Unknown channel {channel} in received simulation data packet")
+                    continue
+                points = None
+                if channel == "time":
+                    points = np.frombuffer(packet["data"], dtype=np.int64)
+                else:
+                    # Append received data to channel data
+                    points = np.frombuffer(packet["data"], dtype=np.int16)
+                    print(f"Packet data preview (first 16 points): {points[:16]}") # Debug print to check packet data
+                self.channel_data[channel] = np.append(self.channel_data[channel], points)
+                # Send ACK to server to indicate ready for next packet
+                self.sock.sendall(b"ACK")
+            except Exception as e:
+                print(f"Failed to receive or process simulation data packet: {e}")
+                QMessageBox.critical(self, "Error", f"Failed to receive or process simulation data packet: {e}")
+                return
+
+
 app = QApplication([])
 client = SDRClient()
 client.show()

sdr-tcp/server-simulator.py

@@ -7,10 +7,12 @@ import socket
 class ServerSimulator:
     def __init__(self):
         self.events = []
-        self.rfwaves = []
+        self.rfwaves = {"default": (np.ones(512, dtype=np.int16) * np.floor(3.3 / 5 * 32767), np.zeros(512, dtype=np.int16))} # Default RF wave is a 100-sample pulse at max amplitude
         self.time = 0
         #Socket parameters
         self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.sock.bind(('127.0.0.1', 5003))
+        self.sock.listen()
         self.conn = 0
         self.magic = 0xAA
         self.cmd = 0x00
@@ -18,6 +20,13 @@ class ServerSimulator:
         self.simview = {}
         #Simulation parameters
         self.level = 20000
+        self.simview = {
+            "time": np.array([], dtype=np.int64),
+            "channel_g": np.array([], dtype=np.int16),
+            "channel_rf_ttl": np.array([], dtype=np.int16),
+            "channel_adc_ttl": np.array([], dtype=np.int16),
+            "channel_rf": np.array([], dtype=np.int16)
+        }
         #32bit Codes
         self.errCode = 0x00000000
         self.statCode = 0x00000000
@@ -32,15 +41,15 @@ class ServerSimulator:
            0x00: self.disconnect
         }
 
-    def connect(self, host, port):
-        self.sock.bind((host, port))
-        self.sock.listen(1)
-        self.conn, addr = self.sock.accept()
-        print(f"New connection from {addr}")
+    def connect(self):
+        self.conn, self.addr = self.sock.accept()
+        print(f"New connection from {self.addr}")
         return True
 
     def disconnect(self):
         self.conn.close()
+        print(f"Connection with {self.addr} closed")
+        return True
 
     def getErrorMsg(self, errCode, errString):
         error = {
@@ -62,7 +71,7 @@ class ServerSimulator:
 
 
     def acceptCommand(self):
-        rawdata = self.sock.recv(4096)
+        rawdata = self.conn.recv(4096)
         
         # Check if data is received
         if not rawdata:
@@ -89,7 +98,7 @@ class ServerSimulator:
         return True
 
     def addEvent(self, data): 
-        if not all (k in data for k in ("time", "duration", "wave", "time_front_rf_trigger", "time_back_rf", "rf_start", "rf_end", "time_adc_trigger", "time_back_adc")):
+        if not all (k in data for k in ("time", "duration", "wave", "time_front_rf_trigger", "time_back_rf_trigger", "rf_start", "rf_end", "time_front_adc_trigger", "time_back_adc_trigger")):
             print("Missing event parameters")
             self.errCode = 0x00000001 # Missing parameters
             self.conn.sendall(self.getErrorMsg(self.errCode, "Missing event parameters"))
@@ -101,11 +110,11 @@ class ServerSimulator:
             "wave": data["wave"],
             "carrier_freq": data["carrier_freq"],
             "time_front_rf_trigger": data["time_front_rf_trigger"],
-            "time_back_rf_trigger": data["time_back_rf"],
+            "time_back_rf_trigger": data["time_back_rf_trigger"],
             "rf_start": data["rf_start"],
             "rf_end": data["rf_end"],
-            "time_front_adc_trigger": data["time_adc_trigger"],
-            "time_back_adc_trigger": data["time_back_adc"],
+            "time_front_adc_trigger": data["time_front_adc_trigger"],
+            "time_back_adc_trigger": data["time_back_adc_trigger"],
         }
 
         if event["start_time"] < self.time:
@@ -113,9 +122,6 @@ class ServerSimulator:
             self.errCode = 0x00000002 # Event in the past
             self.conn.sendall(self.getErrorMsg(self.errCode, "Event start time is in the past"))
             return False
-        
-        self.time = event["start_time"] + event["duration"]
-
         if event["time_front_rf_trigger"] < 0 or event["time_back_rf_trigger"] < 0 or event["rf_start"] < 0 or event["rf_end"] < 0:
             print("RF trigger times and delays must be non-negative")
             self.errCode = 0x00000003 # Negative times
@@ -151,12 +157,12 @@ class ServerSimulator:
             self.errCode = 0x00000009 # ADC triggers overlap
             self.conn.sendall(self.getErrorMsg(self.errCode, "ADC triggers overlap"))
             return False
-        if event["rf_start"] < event["rf_end"]:
+        if event["rf_start"] > event["rf_end"]:
             print("RF start and end times overlap")
             self.errCode = 0x0000000A # RF start/end times overlap
             self.conn.sendall(self.getErrorMsg(self.errCode, "RF start and end times overlap"))
             return False
-        if event["rf_start"] < event["time_front_rf_trigger"] or event["rf_end"] > event["time_back_rf_trigger"]:
+        if event["rf_start"] < event["time_back_rf_trigger"] or event["rf_end"] > event["time_front_rf_trigger"]:
             print("RF start and end times must be within RF trigger times")
             self.errCode = 0x0000000B # RF start/end times outside triggers
             self.conn.sendall(self.getErrorMsg(self.errCode, "RF start and end times must be within RF trigger times"))
@@ -167,6 +173,7 @@ class ServerSimulator:
             self.conn.sendall(self.getErrorMsg(self.errCode, "RF pulse duration must be at least as long as the wave length"))
             return False
         self.events.append(event)
+        self.time = event["start_time"] + event["duration"]
         print(f"Added event: {event}")
         self.conn.sendall(self.getStatusMsg(0x00000010, "Event added successfully"))
         return True
@@ -209,8 +216,8 @@ class ServerSimulator:
                 self.conn.sendall(self.getErrorMsg(self.errCode, "Missing wave data in RF wave packet"))
                 return False
             
-            wave_q = packet_data["wavedata_q"]
-            wave_i = packet_data["wavedata_i"]
+            wave_q = np.frombuffer(packet_data["wavedata_q"], dtype=np.int16)
+            wave_i = np.frombuffer(packet_data["wavedata_i"], dtype=np.int16)
 
             if len(wave_q) != len(wave_i):
                 print("In-phase and quadrature wave data must have the same length in RF wave packet")
@@ -237,10 +244,12 @@ class ServerSimulator:
     
     def runEventList(self, data):
         time_linspace = np.linspace(0, self.time, self.time+1)
-        channel_g = np.ones(self.time, dtype=np.int16) * np.floor(3.3 / 5 * 32767)
-        channel_rf_ttl = np.zeros(self.time, dtype=np.int16)
-        channel_adc_ttl = np.zeros(self.time, dtype=np.int16)
-        channel_rf = np.zeros(self.time, dtype=np.int16)
+        self.simview["time"] = time_linspace.astype(np.int64)
+
+        channel_g = np.ones(self.time+1, dtype=np.int16) * np.floor(3.3 / 5 * 32767).astype(np.int16)
+        channel_rf_ttl = np.zeros(self.time+1, dtype=np.int16)
+        channel_adc_ttl = np.zeros(self.time+1, dtype=np.int16)
+        channel_rf = np.zeros(self.time+1, dtype=np.int16)
 
         for event in self.events:
             print(f"Running event: {event}")
@@ -249,8 +258,8 @@ class ServerSimulator:
             rf_wave_i = self.rfwaves[event["wave"]][1]
 
             rf_pulse_length = event["rf_end"] - event["rf_start"]
-            rf_trigger_length = event["time_back_rf_trigger"] - event["time_front_rf_trigger"]
-            adc_trigger_length = event["time_back_adc_trigger"] - event["time_front_adc_trigger"]
+            rf_trigger_length = -event["time_back_rf_trigger"] + event["time_front_rf_trigger"]
+            adc_trigger_length = -event["time_back_adc_trigger"] + event["time_front_adc_trigger"]
 
             rf_wave_length = len(rf_wave_q)
 
@@ -260,6 +269,7 @@ class ServerSimulator:
             rf_trigger_time = np.linspace(0, rf_trigger_length, rf_trigger_length+1)
             adc_trigger_time = np.linspace(0, adc_trigger_length, adc_trigger_length+1)
             event_time = np.linspace(0, event_length, event_length+1)
+            print(f"RF pulse length: {rf_pulse_length}, RF trigger length: {rf_trigger_length}, ADC trigger length: {adc_trigger_length}, Event length: {event_length}")
 
             if rf_pulse_length < rf_wave_length:
                 print("RF pulse length is shorter than RF wave length, cannot run event")
@@ -271,47 +281,47 @@ class ServerSimulator:
             interp_wave_q = np.zeros(rf_pulse_length, dtype=np.int16)
             interp_wave_i = np.zeros(rf_pulse_length, dtype=np.int16)
             if data["interpolation_method"] == "linear":
-                interp_func_q = interp.interp1d(np.linspace(0, rf_wave_length, rf_wave_length), rf_wave_q, kind='linear')
-                interp_func_i = interp.interp1d(np.linspace(0, rf_wave_length, rf_wave_length), rf_wave_i, kind='linear')
+                interp_func_q = interp.interp1d(np.linspace(0, rf_wave_length, rf_wave_length), rf_wave_q, kind='linear', fill_value="extrapolate")
+                interp_func_i = interp.interp1d(np.linspace(0, rf_wave_length, rf_wave_length), rf_wave_i, kind='linear', fill_value="extrapolate")
                 interp_wave_q = interp_func_q(rf_time).astype(np.int16)
                 interp_wave_i = interp_func_i(rf_time).astype(np.int16)
             elif data["interpolation_method"] == "nearest":
-                interp_func_q = interp.interp1d(np.linspace(0, rf_wave_length, rf_wave_length), rf_wave_q, kind='nearest')
-                interp_func_i = interp.interp1d(np.linspace(0, rf_wave_length, rf_wave_length), rf_wave_i, kind='nearest')
+                interp_func_q = interp.interp1d(np.linspace(0, rf_wave_length, rf_wave_length), rf_wave_q, kind='nearest', fill_value="extrapolate")
+                interp_func_i = interp.interp1d(np.linspace(0, rf_wave_length, rf_wave_length), rf_wave_i, kind='nearest', fill_value="extrapolate")
                 interp_wave_q = interp_func_q(rf_time).astype(np.int16)
                 interp_wave_i = interp_func_i(rf_time).astype(np.int16)
             elif data["interpolation_method"] == "cubic":
-                interp_func_q = interp.interp1d(np.linspace(0, rf_wave_length, rf_wave_length), rf_wave_q, kind='cubic')
-                interp_func_i = interp.interp1d(np.linspace(0, rf_wave_length, rf_wave_length), rf_wave_i, kind='cubic')
+                interp_func_q = interp.interp1d(np.linspace(0, rf_wave_length, rf_wave_length), rf_wave_q, kind='cubic', fill_value="extrapolate")
+                interp_func_i = interp.interp1d(np.linspace(0, rf_wave_length, rf_wave_length), rf_wave_i, kind='cubic', fill_value="extrapolate")
                 interp_wave_q = interp_func_q(rf_time).astype(np.int16)
                 interp_wave_i = interp_func_i(rf_time).astype(np.int16)
 
-            channel_rf[event["rf_start"]:event["rf_end"]+1] = np.floor((interp_wave_q * np.cos(2 * np.pi * event["carrier_freq"] * rf_time * 8e-9) - interp_wave_i * np.sin(2 * np.pi * event["carrier_freq"] * rf_time * 8e-9)) / np.sqrt(2)).astype(np.int16)
-            channel_rf_ttl[event["time_front_rf_trigger"]:event["time_back_rf_trigger"]+1] = 1
-            channel_adc_ttl[event["time_front_adc_trigger"]:event["time_back_adc_trigger"]+1] = 1
+            channel_rf[event["start_time"]+event["rf_start"]:event["start_time"]+event["rf_end"]+1] = np.floor((interp_wave_q * np.sin(2 * np.pi * event["carrier_freq"] * rf_time * 8e-9) - interp_wave_i * np.cos(2 * np.pi * event["carrier_freq"] * rf_time * 8e-9)) / np.sqrt(2)).astype(np.int16)
+            channel_rf_ttl[event["start_time"]+event["time_back_rf_trigger"]:event["start_time"]+event["time_front_rf_trigger"]+1] = np.int16(1 * np.floor(3.3 / 5 * 32767))
+            channel_adc_ttl[event["start_time"]+event["time_back_adc_trigger"]:event["start_time"]+event["time_front_adc_trigger"]+1] = np.int16(1 * np.floor(3.3 / 5 * 32767))
             channel_g[event["start_time"]:(event["start_time"]+event["duration"]+1)] = 0
 
-        self.simview = {
-            "time": time_linspace,
-            "channel_g": channel_g,
-            "channel_rf_ttl": channel_rf_ttl,
-            "channel_adc_ttl": channel_adc_ttl,
-            "channel_rf": channel_rf
-        }
+        self.simview["channel_g"] = channel_g
+        self.simview["channel_rf_ttl"] = channel_rf_ttl
+        self.simview["channel_adc_ttl"] = channel_adc_ttl
+        self.simview["channel_rf"] = channel_rf
+        print(f"Simulation data: time length {len(self.simview['time'])}, channel_g length {len(self.simview['channel_g'])}, channel_rf_ttl length {len(self.simview['channel_rf_ttl'])}, channel_adc_ttl length {len(self.simview['channel_adc_ttl'])}, channel_rf length {len(self.simview['channel_rf'])}")
         self.conn.sendall(self.getStatusMsg(0x00000032, "Event list simulation complete"))
         return True
     
     def sendSimViewData(self, data):
         data_length = len(self.simview["time"])
-        channels = ["channel_g", "channel_rf_ttl", "channel_adc_ttl", "channel_rf"]
-        packet_size = 1024
-        total_packets = (data_length * len(channels) * 2) // packet_size + 1
+        channels = ["channel_g", "channel_rf_ttl", "channel_adc_ttl", "channel_rf", "time"]
+        packet_size = 512
+        total_packets = (data_length * len(channels)) // packet_size + 1
         packet_index = 0
         self.conn.sendall(self.getStatusMsg(0x00000043, f"Ready to send simulation data in {total_packets} packets with size {packet_size} bytes"))
+        self.conn.recv(4096) # ACK
+        print(f"Starting to send simulation data: total length {data_length}, total packets {total_packets}")
         for channel in channels:
-            channel_data = self.simview[channel].tobytes()
+            channel_data = self.simview[channel]
             for i in range(0, len(channel_data), packet_size):
-                packet_num += 1
+                packet_index += 1
                 packet_data = None
                 if i + packet_size > len(channel_data):
                     packet_data = channel_data[i:]
@@ -323,22 +333,19 @@ class ServerSimulator:
                     "channel": channel,
                     "total_packets": total_packets,
                     "packet_index": packet_index,
-                    "data": packet_data
+                    "data": packet_data.tobytes(),
+                    "data_length": len(packet_data)
                 }
+                print(f"Sending packet {packet_index}/{total_packets} for channel '{channel}' with data length {len(packet_data)}")
                 self.conn.sendall(msgpack.packb(packet_msg, use_bin_type=True))
-                rawdata = self.conn.recv(1024) # Wait for ACK
-                ack_data = msgpack.unpackb(rawdata, raw=False)
-                if ack_data["magic"] != self.magic or ack_data["cmd"] != 0x41 or ack_data["code"] != packet_index:
-                    print(f"Invalid ACK for packet {packet_index}")
-                    self.errCode = 0x00000045 # Invalid ACK
-                    self.conn.sendall(self.getErrorMsg(self.errCode, f"Invalid ACK for packet {packet_index}"))
-                    return False
+                self.conn.recv(4096) # Wait for ACK
         print("Simulation data sent successfully")
         self.conn.sendall(self.getStatusMsg(0x00000044, "All simulation data packets sent"))
         return True
     
     def clearEventList(self, data):
         self.events = []
+        self.time = 0
         self.conn.sendall(self.getStatusMsg(0x00000064, "Event list cleared"))
         return True
     
@@ -354,6 +361,6 @@ class ServerSimulator:
     
 server = ServerSimulator()
 
-while server.connect('127.0.0.1', 5003):
+while server.connect():
     while server.acceptCommand():
         pass