ExcessiveMotion_controller-software/controller-firmware/python/src/sandbox/test1.py

import pandas as pd
import numpy as np

def process_rs485_signal(input_csv, 
                         output_csv, 
                         edge_threshold, 
                         low_threshold, 
                         high_threshold, 
                         window_size=6, 
                         samples_to_average=10, 
                         refractory_samples=15):
    """
    Processes an analog RS485 capture CSV to detect signal edges and assign levels.

    Parameters:
      input_csv (str): Path to the input CSV file. The CSV should have at least two columns: 'time' and 'voltage'.
      output_csv (str): Path to the output CSV file that will contain the detected edges.
      edge_threshold (float): Minimum voltage change (over the past window_size samples) required to detect an edge.
      low_threshold (float): Upper bound for the averaged voltage to be considered "low".
      high_threshold (float): Lower bound for the averaged voltage to be considered "high".
      window_size (int): Number of previous samples to compare against for detecting a change (default: 5).
      samples_to_average (int): Number of samples to average after an edge is detected to determine the new level (default: 20).
      refractory_samples (int): Number of samples to skip after detecting an edge to avoid multiple triggers (default: 20).

    The function writes a CSV with two columns: 'time' (the time at which the edge was detected)
    and 'level' (the new state: "low", "high", or "floating").
    """
    # Load the CSV into a DataFrame.
    data = pd.read_csv(input_csv)
    
    # Ensure that the required columns are present.
    if not {"time", "voltage"}.issubset(data.columns):
        raise ValueError("Input CSV must contain 'time' and 'voltage' columns.")
    
    times = data['time'].values
    voltages = data['voltage'].values
    N = len(voltages)
    
    edges = []  # List to store detected edges as [time, level]
    i = window_size  # Start after the initial window

    # Loop until we have enough remaining samples for the averaging window.
    while i < N - samples_to_average:
        # Compare the current voltage with the voltage from 'window_size' samples ago.
        voltage_change = voltages[i] - voltages[i - window_size]
        if abs(voltage_change) >= edge_threshold:
            # Average the next 'samples_to_average' samples to determine the new level.
            avg_voltage = np.mean(voltages[i:i + samples_to_average])
            
            if avg_voltage < low_threshold:
                level = "low"
            elif avg_voltage > high_threshold:
                level = "high"
            else:
                level = "floating"
            
            # Record the time of the detected edge and its new level.
            edges.append([times[i], level])
            
            # Skip ahead by a refractory period to avoid multiple detections of the same edge.
            i += refractory_samples
        else:
            i += 1

    # Convert the list of edges to a DataFrame and write it to CSV.
    edges_df = pd.DataFrame(edges, columns=['time', 'level'])
    edges_df.to_csv(output_csv, index=False)



def decode_rs485_packets(edges_csv, packet_gap_threshold, bit_interval):
    """
    Decodes RS485 packets from an edges CSV file into a list of (tx_data, rx_data) pairs.
    
    Parameters:
      edges_csv (str): Path to the CSV file containing edges. The CSV should have two columns:
                       'time' (timestamps) and 'level' (string: "low", "high", or "floating").
      packet_gap_threshold (float): Time gap (in the same units as 'time') that indicates a new packet.
      bit_interval (float): Expected time duration of one bit period.
      
    Returns:
      List[Tuple[str, str]]: A list of tuples where each tuple is (tx_data, rx_data). 
                             Each is a binary string representing the data from that transfer.
    
    Assumptions:
      - The CSV rows are in chronological order.
      - Each packet consists of two transfers:
            * TX transfer: starts with a start bit (first edge) and then the TX data bits.
            * RX transfer: starts after a floating level is detected; its first edge is a start bit (and not a data bit).
      - Signal levels are interpreted as: "low" -> '0' and "high" -> '1'.
      - Edges occur on bit boundaries, but if the time between consecutive edges is greater than one bit_interval,
        we assume that the previous bit was held for the missing bit periods.
    """
    # Read the CSV file into a DataFrame.
    df = pd.read_csv(edges_csv)
    if not {"time", "level"}.issubset(df.columns):
        raise ValueError("CSV must contain 'time' and 'level' columns.")
    
    # Create a list of (time, level) tuples.
    edges = list(zip(df['time'], df['level']))
    
    # Partition the entire stream into packets based on a time gap threshold.
    packets = []
    current_packet = [edges[0]]
    for i in range(1, len(edges)):
        current_edge = edges[i]
        prev_edge = edges[i - 1]
        if (current_edge[0] - prev_edge[0]) > packet_gap_threshold:
            # A large time gap indicates a new packet.
            packets.append(current_packet)
            current_packet = [current_edge]
        else:
            current_packet.append(current_edge)
    if current_packet:
        packets.append(current_packet)
    
    def decode_segment(segment_edges, bit_interval):
        """
        Decodes a transfer segment (list of (time, level)) into a binary string.
        The first edge is assumed to be a start bit and is skipped.
        Uses timing differences to determine if a bit is held for multiple bit periods.
        
        Parameters:
          segment_edges (List[Tuple[float, str]]): Edges for one transfer (either TX or RX).
          bit_interval (float): The expected duration of one bit period.
          
        Returns:
          A binary string (e.g., "101010") representing the data bits.
          Returns an empty string if there are insufficient edges to decode.
        """
        if len(segment_edges) < 2:
            # Not enough edges to have a start bit and at least one data bit.
            return ""
        
        bits = []
        # Start with the second edge (first edge after the start bit).
        prev_time, prev_level = segment_edges[1]
        if prev_level.lower() == "floating":
            # If the first data edge is floating, we cannot decode a valid bit.
            return ""
        prev_bit = "0" if prev_level.lower() == "low" else "1"
        bits.append(prev_bit)
        last_time = prev_time

        # Process remaining edges.
        for (t, level) in segment_edges[2:]:
            # Skip any floating edges that might appear within the transfer.
            if level.lower() == "floating":
                continue
            dt = t - last_time
            # Determine how many bit periods have passed.
            # We use rounding to account for slight drift.
            n_intervals = max(1, int(round(dt / bit_interval)))
            # If more than one bit period elapsed, assume the previous bit was held.
            if n_intervals > 1:
                bits.extend([prev_bit] * (n_intervals - 1))
            # Append the new bit.
            current_bit = "0" if level.lower() == "low" else "1"
            bits.append(current_bit)
            last_time = t
            prev_bit = current_bit
        
        return "".join(bits)
    
    packets_data = []  # List to hold the decoded (tx_data, rx_data) pairs.
    
    # Process each packet.
    for packet in packets:
        # Look for the first occurrence of a floating edge.
        # This edge marks the boundary between TX and RX.
        floating_index = None
        for i, (t, level) in enumerate(packet):
            if level.lower() == "floating":
                floating_index = i
                break
        if floating_index is None:
            # No floating edge found in this packet; skip or handle as needed.
            continue
        
        # The TX segment is assumed to be all edges before the floating transition.
        tx_edges = packet[:floating_index]
        # The RX segment starts after the floating edge.
        rx_edges = packet[floating_index + 1:]
        
        # Decode each segment.
        tx_data = decode_segment(tx_edges, bit_interval)
        rx_data = decode_segment(rx_edges, bit_interval)
        
        packets_data.append((tx_data, rx_data))
    
    return packets_data

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

def visualize_single_packet(analog_csv, edges_csv, decoded_packets, packet_index, packet_gap_threshold):
    """
    Visualizes a single packet by plotting the analog waveform (with edge markers)
    and displaying the decoded binary TX/RX data for that packet.
    
    Parameters:
      analog_csv (str): Path to the analog capture CSV file. Should contain "time" and "voltage" columns.
      edges_csv (str): Path to the edges CSV file. Should contain "time" and "level" columns.
      decoded_packets (List[Tuple[str, str]]): A list of (tx_data, rx_data) tuples, one per packet.
      packet_index (int): Index (0-indexed) of the packet to visualize.
      packet_gap_threshold (float): Time gap (in same units as 'time') that indicates a new packet.
      
    The function partitions the edges into packets, selects the specified packet, determines the
    time window covering that packet (with a margin), and plots:
        - The analog waveform (restricted to that window)
        - Vertical dashed lines at each edge (color-coded by level)
        - A text box below showing the TX and RX binary strings for that packet.
    """
    # Load the analog signal.
    analog_df = pd.read_csv(analog_csv)
    time_data = analog_df['time'].values
    voltage = analog_df['voltage'].values

    # Load the edges.
    edges_df = pd.read_csv(edges_csv)
    edges = list(zip(edges_df['time'].values, edges_df['level'].values))
    
    # Partition the edges into packets.
    packets = []
    current_packet = [edges[0]]
    for i in range(1, len(edges)):
        # If the gap is larger than the threshold, start a new packet.
        if (edges[i][0] - edges[i-1][0]) > packet_gap_threshold:
            packets.append(current_packet)
            current_packet = [edges[i]]
        else:
            current_packet.append(edges[i])
    if current_packet:
        packets.append(current_packet)
    
    # Check if packet_index is valid.
    if packet_index < 0 or packet_index >= len(packets):
        raise ValueError(f"Packet index {packet_index} is out of range. There are only {len(packets)} packets.")
    
    # Select the packet.
    packet_edges = packets[packet_index]
    
    # Determine time window for this packet.
    packet_start = packet_edges[0][0]
    packet_end = packet_edges[-1][0]
    # Use 5% of the packet duration as margin on each side (or a minimum margin if duration is 0)
    margin = max((packet_end - packet_start) * 0.05, 0.000001)
    window_start = packet_start - margin
    window_end = packet_end + margin
    
    # Filter analog data to this time window.
    window_mask = (time_data >= window_start) & (time_data <= window_end)
    time_window = time_data[window_mask]
    voltage_window = voltage[window_mask]
    
    # Get the decoded data for this packet.
    tx_data, rx_data = decoded_packets[packet_index] if packet_index < len(decoded_packets) else ("", "")
    
    # Create the figure with two subplots.
    fig, (ax_waveform, ax_text) = plt.subplots(2, 1, figsize=(14, 8),
                                               gridspec_kw={'height_ratios': [3, 1]},
                                               sharex=True)
    
    # Plot the analog waveform.
    ax_waveform.plot(time_window, voltage_window, label="Analog Signal", color='black')
    ax_waveform.set_ylabel("Voltage")
    ax_waveform.set_title(f"Analog Signal & Edges for Packet {packet_index + 1}")
    
    # Overlay edge markers for this packet.
    for t, level in packet_edges:
        if level.lower() == "low":
            col = 'blue'
        elif level.lower() == "high":
            col = 'red'
        elif level.lower() == "floating":
            col = 'green'
        else:
            col = 'gray'
        ax_waveform.axvline(x=t, color=col, linestyle="--", alpha=0.7)
        ax_waveform.text(t, np.max(voltage_window), level, rotation=90,
                         verticalalignment='bottom', fontsize=8, color=col)
    
    ax_waveform.grid(True)
    ax_waveform.legend()
    
    # Bottom subplot: display the decoded TX/RX binary data.
    ax_text.axis("off")  # Turn off axis lines/ticks.
    text_str = f"Packet {packet_index + 1}:\n  TX: {tx_data}\n  RX: {rx_data}"
    ax_text.text(0.01, 0.5, text_str, fontsize=14, verticalalignment="center",
                 transform=ax_text.transAxes)
    ax_text.set_title("Decoded Binary Data (TX / RX)")
    
    plt.xlabel("Time")
    plt.tight_layout()
    plt.show()

if(0):
    process_rs485_signal('controller-firmware/python/src/sandbox/analog.csv',
                        'controller-firmware/python/src/sandbox/fanuc_rs485_detected_edges.csv',
                        edge_threshold=0.5,   # adjust as needed
                        low_threshold=1.6,      # adjust as needed
                        high_threshold=2.5)     # adjust as needed


# =============================================================================
# Example usage:
#
# decoded_packets = decode_rs485_packets(
#     edges_csv = 'controller-firmware/python/src/sandbox/fanuc_rs485_detected_edges.csv',
#     packet_gap_threshold = 50e-6,  # Adjust this threshold (in seconds) based on your capture
#     bit_interval = 1/2.72727272e6          # Adjust the bit_interval (in seconds) to your protocol's timing
# )

# for idx, (tx, rx) in enumerate(decoded_packets):
#     print(f"Packet {idx}: TX = {tx}, RX = {rx}")
# =============================================================================


# =============================================================================
# Example usage:
#
# Assuming you have:
#   - 'analog_capture.csv' with columns "time", "voltage"
#   - 'detected_edges.csv' with columns "time", "level"
#   - decoded_packets: a list of (tx_data, rx_data) tuples obtained from your decoder
#
decoded_packets = decode_rs485_packets(
    edges_csv = 'controller-firmware/python/src/sandbox/fanuc_rs485_detected_edges.csv',
    packet_gap_threshold = 50e-6,
    bit_interval = 1/2.7272727e6
)

# remove empty packets
decoded_packets = [p for p in decoded_packets if p[0] and p[1]]

# ensure packet is correct length by repeating the last bit as needed
for idx, (tx, rx) in enumerate(decoded_packets):
    if len(rx) == 0:
        continue
    
    l = 101
    if len(rx) < l:
        rx += rx[-1] * (l - len(rx))

    decoded_packets[idx] = (tx, rx)

for idx, (tx, rx) in enumerate(decoded_packets):
    print(f"Packet {idx}: TX = {tx}, RX = {rx}")

    # visualize_single_packet('controller-firmware/python/src/sandbox/analog.csv',
    #                         'controller-firmware/python/src/sandbox/fanuc_rs485_detected_edges.csv',
    #                         decoded_packets,
    #                         packet_index=888,
    #                         packet_gap_threshold=50e-6)
# =============================================================================