High-Speed Serial

def calculate_throughput(baudrate, data_bits=8, parity=0, stop_bits=1):
    """Calculate real-world serial throughput."""
    bits_per_byte = 1 + data_bits + parity + stop_bits  # start + data + parity + stop
    max_bytes_per_sec = baudrate / bits_per_byte
    # Real-world efficiency is typically 80-95%
    practical = max_bytes_per_sec * 0.85
    overhead_pct = (bits_per_byte - data_bits) / bits_per_byte * 100
    return max_bytes_per_sec, practical, overhead_pct

for baud in [115200, 460800, 921600, 1000000]:
    theoretical, practical, overhead = calculate_throughput(baud)
    print(f"{baud:>8} baud: ~{practical:>7,.0f} bytes/sec usable ({overhead:.0f}% overhead)")

import serial
import time

def test_baud_rates(port, bauds=None):
    """Test which baud rates work reliably with loopback."""
    if bauds is None:
        bauds = [115200, 230400, 460800, 921600, 1000000]

    test_data = b'A' * 1000
    results = {}

    for baud in bauds:
        try:
            ser = serial.Serial(port, baud, timeout=1)
            ser.reset_input_buffer()
            errors = 0

            for _ in range(10):
                ser.write(test_data)
                ser.flush()
                received = ser.read(len(test_data))
                if received != test_data:
                    errors += 1

            ser.close()

            reliable = errors == 0
            results[baud] = reliable
            status = "OK" if reliable else f"{errors}/10 failed"
            print(f"  {baud:>8} baud: {status}")

        except Exception as e:
            results[baud] = False
            print(f"  {baud:>8} baud: FAILED ({e})")

    best = max((b for b, ok in results.items() if ok), default=None)
    if best:
        print(f"\nBest reliable rate: {best} baud")
    return results

test_baud_rates('/dev/ttyUSB0')

import serial

def configure_high_speed(port, baudrate):
    """Open a port with buffers sized for the baud rate."""
    bytes_per_sec = baudrate / 10  # 8N1 = 10 bits per byte
    rx_buffer = max(4096, int(bytes_per_sec * 0.5))  # 500ms of data
    tx_buffer = max(2048, int(bytes_per_sec * 0.1))   # 100ms of data

    ser = serial.Serial(port, baudrate, timeout=0.01)

    try:
        ser.set_buffer_size(rx_size=rx_buffer, tx_size=tx_buffer)
    except AttributeError:
        pass  # Not supported on all platforms

    print(f"Opened {port} at {baudrate} baud")
    print(f"RX buffer: {rx_buffer} bytes ({rx_buffer / bytes_per_sec * 1000:.0f}ms)")
    return ser

ser = configure_high_speed('/dev/ttyUSB0', 921600)
ser.close()

import serial
import time

ser = serial.Serial('/dev/ttyUSB0', 921600, timeout=0.001)
total_bytes = 0
start = time.time()

try:
    while True:
        waiting = ser.in_waiting
        if waiting:
            data = ser.read(waiting)
            total_bytes += len(data)
            # Process data here (or hand off to another thread)
        else:
            time.sleep(0.0005)  # 500us idle sleep

        elapsed = time.time() - start
        if elapsed >= 5.0:
            rate = total_bytes / elapsed
            print(f"{rate:,.0f} bytes/sec ({total_bytes:,} total in {elapsed:.1f}s)")
            total_bytes = 0
            start = time.time()
except KeyboardInterrupt:
    ser.close()