# Monitor system messages in real-time
sudo tail -f /var/log/syslog

# Alternative: Use dmesg for recent messages
dmesg --follow

# Monitor kernel messages specifically
sudo journalctl -f -k

# List all USB devices
lsusb

# Detailed USB device information
lsusb -v | grep -A 10 -B 10 "Serial\|UART\|RS232"

# List serial devices
ls -la /dev/tty*

# Show USB serial devices specifically
ls -la /dev/ttyUSB*

# Get device information
udevadm info -a -n /dev/ttyUSB0

# Check which driver is loaded
lsmod | grep -E "(ftdi|pl2303|cp210x|ch341)"

# Update package database
sudo apt update

# Install serial communication tools
sudo apt install -y screen minicom cu setserial

# Install additional utilities
sudo apt install -y picocom socat

# For development work
sudo apt install -y python3-serial

# Load FTDI driver
sudo modprobe ftdi_sio

# Load Prolific driver
sudo modprobe pl2303

# Load Silicon Labs driver
sudo modprobe cp210x

# Load CH341 driver
sudo modprobe ch341-uart

# Verify driver loading
dmesg | tail -10

# Connect to serial device
screen /dev/ttyUSB0 115200

# Common baud rates
screen /dev/ttyUSB0 9600    # Standard rate
screen /dev/ttyUSB0 19200   # Legacy equipment
screen /dev/ttyUSB0 38400   # Some network gear
screen /dev/ttyUSB0 57600   # Faster rate
screen /dev/ttyUSB0 115200  # Most common modern rate

# Connect with specific parameters
screen /dev/ttyUSB0 115200,cs8,-parenb,-cstopb

# Create named session
screen -S router-console /dev/ttyUSB0 115200

# List active sessions
screen -ls

# Reconnect to detached session
screen -r router-console

# Detach from session (keep running)
# Press: Ctrl+A, then D

# Terminate session
# Press: Ctrl+A, then K, then Y

# Create ~/.screenrc for persistent settings
cat > ~/.screenrc << 'EOF'
# Disable startup message
startup_message off

# Increase scrollback buffer
defscrollback 10000

# Enable mouse scrolling
termcapinfo xterm* ti@:te@

# UTF-8 support
defutf8 on

# Status line
hardstatus alwayslastline
hardstatus string '%{= kG}%-Lw%{= kW}%50> %n%f* %t%{= kG}%+Lw%< %{= kG}%-=%D %M %d %Y %c:%s%{-}'

# Bind keys for easier navigation
bind j focus down
bind k focus up
bind h focus left
bind l focus right
EOF

# Initial configuration (run as root for system-wide settings)
sudo minicom -s

# User-specific configuration
minicom -s

# Connect to device with specific settings
minicom -D /dev/ttyUSB0 -b 115200

# Connect without initialization
minicom -D /dev/ttyUSB0 -o

# Create minicom configuration
sudo tee /etc/minicom/minirc.dfl << 'EOF'
# Machine-generated file - use setup menu in minicom to change parameters.
pu port             /dev/ttyUSB0
pu baudrate         115200
pu bits             8
pu parity           N
pu stopbits         1
pu rtscts           No
pu xonxoff          No
pu linewrap         Yes
pu addcarriagereturn Yes
EOF

# Basic connection
picocom -b 115200 /dev/ttyUSB0

# With flow control disabled
picocom -b 115200 -f n /dev/ttyUSB0

# With specific settings
picocom -b 9600 -d 8 -p n -s 1 -f n /dev/ttyUSB0

# Exit picocom: Ctrl+A, Ctrl+X

# View current port settings
stty -F /dev/ttyUSB0

# Configure port parameters
stty -F /dev/ttyUSB0 115200 cs8 -cstopb -parenb -crtscts -ixon -ixoff

# Break down of settings:
# 115200: Baud rate
# cs8: 8 data bits
# -cstopb: 1 stop bit (- means disable 2 stop bits)
# -parenb: No parity (- means disable parity)
# -crtscts: No hardware flow control
# -ixon -ixoff: No software flow control

# Install setserial if not available
sudo apt install setserial

# View serial port information
setserial -g /dev/ttyUSB*

# Configure UART settings
sudo setserial /dev/ttyUSB0 uart 16550A

# Set low latency mode (for real-time applications)
sudo setserial /dev/ttyUSB0 low_latency

# View detailed port information
setserial -a /dev/ttyUSB0

# Add current user to dialout group
sudo usermod -a -G dialout $USER

# Verify group membership
groups $USER

# Apply changes (logout/login or use newgrp)
newgrp dialout

# Create custom udev rule
sudo tee /etc/udev/rules.d/99-usb-serial.rules << 'EOF'
# FTDI devices
SUBSYSTEM=="tty", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6001", ATTRS{serial}=="A12345678", SYMLINK+="cisco-console"

# Prolific devices
SUBSYSTEM=="tty", ATTRS{idVendor}=="067b", ATTRS{idProduct}=="2303", SYMLINK+="legacy-serial"

# Silicon Labs devices
SUBSYSTEM=="tty", ATTRS{idVendor}=="10c4", ATTRS{idProduct}=="ea60", SYMLINK+="embedded-dev"
EOF

# Reload udev rules
sudo udevadm control --reload-rules
sudo udevadm trigger

# Verify persistent names
ls -la /dev/cisco-console /dev/legacy-serial /dev/embedded-dev

# Standard Cisco console connection
screen /dev/ttyUSB0 9600

# Modern Cisco equipment
screen /dev/ttyUSB0 115200

# HP switches typically use 115200
screen /dev/ttyUSB0 115200

# Some older HP equipment
screen /dev/ttyUSB0 9600

# Juniper equipment standard settings
screen /dev/ttyUSB0 9600

# SRX series and newer equipment
screen /dev/ttyUSB0 115200

# Connect to iDRAC virtual console
screen /dev/ttyUSB0 115200

# Enable SOL (Serial Over LAN) redirection in iDRAC
# racadm config -g cfgSerial -o cfgSerialConsoleEnable 1
# racadm config -g cfgSerial -o cfgSerialBaudRate 115200

# HP iLO console access
screen /dev/ttyUSB0 115200

# Configure iLO VSP (Virtual Serial Port)
# hpilo_cli: set serial_cli_status enabled
# hpilo_cli: set serial_cli_speed 115200

# Check if device is connected
lsusb | grep -i "serial\|uart\|ftdi\|prolific"

# Verify USB subsystem
dmesg | grep -i usb | tail -20

# Check for driver conflicts
lsmod | grep -E "(ftdi|pl2303|cp210x|ch341)"

# Force driver reload
sudo rmmod ftdi_sio
sudo modprobe ftdi_sio

# Check device permissions
ls -la /dev/ttyUSB*

# Fix permissions temporarily
sudo chmod 666 /dev/ttyUSB0

# Permanent fix: add user to dialout group
sudo usermod -a -G dialout $USER

# Test basic connectivity
echo "test" > /dev/ttyUSB0

# Monitor for incoming data
cat /dev/ttyUSB0

# Test with different baud rates
for rate in 9600 19200 38400 57600 115200; do
    echo "Testing $rate baud"
    screen /dev/ttyUSB0 $rate
    sleep 2
done

# Disable hardware flow control
stty -F /dev/ttyUSB0 -crtscts

# Connect without flow control
picocom -b 115200 -f n /dev/ttyUSB0

# For problematic devices, try null modem settings
stty -F /dev/ttyUSB0 115200 cs8 -cstopb -parenb -crtscts -hupcl

# Create test script
cat > serial_test.py << 'EOF'
#!/usr/bin/env python3
import serial
import time

# Open serial port
try:
    ser = serial.Serial('/dev/ttyUSB0', 115200, timeout=1)
    print(f"Connected to {ser.name}")
    
    # Send test data
    ser.write(b'test\r\n')
    
    # Read response
    time.sleep(1)
    response = ser.read_all()
    print(f"Received: {response}")
    
    ser.close()
    
except serial.SerialException as e:
    print(f"Error: {e}")
EOF

chmod +x serial_test.py
python3 serial_test.py

# Install interceptty for traffic monitoring
sudo apt install interceptty

# Intercept serial communication
interceptty /dev/ttyUSB0 /tmp/virtual_serial

# In another terminal, connect to virtual port
screen /tmp/virtual_serial 115200

# Monitor traffic in real-time
tail -f /var/log/interceptty

#!/bin/bash
# Cisco console automation script

DEVICE="/dev/ttyUSB0"
BAUD="9600"
USERNAME="admin"
PASSWORD="password"
ENABLE_PASSWORD="enable_pass"

# Function to send commands to device
send_command() {
    local command="$1"
    echo "$command" > "$DEVICE"
    sleep 1
}

# Connect and configure
{
    echo "$USERNAME"
    sleep 2
    echo "$PASSWORD"
    sleep 2
    echo "enable"
    sleep 1
    echo "$ENABLE_PASSWORD"
    sleep 1
    echo "terminal length 0"
    sleep 1
    echo "show version"
    sleep 3
    echo "exit"
} > "$DEVICE" &

# Monitor output
timeout 30 cat "$DEVICE"

#!/bin/bash
# Multi-device console manager

declare -A DEVICES=(
    ["router1"]="/dev/ttyUSB0:9600"
    ["switch1"]="/dev/ttyUSB1:115200"
    ["server1"]="/dev/ttyUSB2:115200"
)

connect_device() {
    local name="$1"
    local device_info="${DEVICES[$name]}"
    local device="${device_info%:*}"
    local baud="${device_info#*:}"
    
    echo "Connecting to $name ($device at $baud baud)"
    screen -S "$name" "$device" "$baud"
}

list_devices() {
    echo "Available devices:"
    for device in "${!DEVICES[@]}"; do
        echo "  $device: ${DEVICES[$device]}"
    done
}

case "$1" in
    "connect")
        connect_device "$2"
        ;;
    "list")
        list_devices
        ;;
    *)
        echo "Usage: $0 {connect|list} [device_name]"
        list_devices
        ;;
esac

#!/usr/bin/env python3
"""
Advanced serial communication example
"""

import serial
import threading
import time
import queue

class SerialManager:
    def __init__(self, port, baudrate=115200):
        self.port = port
        self.baudrate = baudrate
        self.serial_connection = None
        self.rx_queue = queue.Queue()
        self.running = False
        
    def connect(self):
        """Establish serial connection"""
        try:
            self.serial_connection = serial.Serial(
                port=self.port,
                baudrate=self.baudrate,
                bytesize=serial.EIGHTBITS,
                parity=serial.PARITY_NONE,
                stopbits=serial.STOPBITS_ONE,
                timeout=1,
                xonxoff=False,
                rtscts=False,
                dsrdtr=False
            )
            print(f"Connected to {self.port} at {self.baudrate} baud")
            return True
        except serial.SerialException as e:
            print(f"Connection failed: {e}")
            return False
    
    def start_monitoring(self):
        """Start background thread for reading data"""
        if not self.serial_connection:
            return False
            
        self.running = True
        self.monitor_thread = threading.Thread(target=self._monitor_serial)
        self.monitor_thread.daemon = True
        self.monitor_thread.start()
        return True
    
    def _monitor_serial(self):
        """Background thread function for monitoring serial data"""
        while self.running:
            try:
                if self.serial_connection.in_waiting:
                    data = self.serial_connection.read_all()
                    self.rx_queue.put(data.decode('utf-8', errors='ignore'))
                time.sleep(0.1)
            except Exception as e:
                print(f"Monitor error: {e}")
                break
    
    def send_command(self, command):
        """Send command to serial device"""
        if self.serial_connection:
            self.serial_connection.write(f"{command}\r\n".encode())
            self.serial_connection.flush()
    
    def read_response(self, timeout=5):
        """Read response from device"""
        response = ""
        start_time = time.time()
        
        while time.time() - start_time < timeout:
            try:
                data = self.rx_queue.get(timeout=0.1)
                response += data
            except queue.Empty:
                continue
                
        return response
    
    def disconnect(self):
        """Close serial connection"""
        self.running = False
        if self.serial_connection:
            self.serial_connection.close()
            print("Disconnected")

# Example usage
if __name__ == "__main__":
    # Create serial manager
    sm = SerialManager("/dev/ttyUSB0", 115200)
    
    if sm.connect():
        sm.start_monitoring()
        
        # Send commands and read responses
        sm.send_command("show version")
        response = sm.read_response()
        print(f"Response: {response}")
        
        # Interactive mode
        try:
            while True:
                command = input("Enter command (or 'quit'): ")
                if command.lower() == 'quit':
                    break
                sm.send_command(command)
                response = sm.read_response()
                print(f"Response: {response}")
        except KeyboardInterrupt:
            pass
        
        sm.disconnect()

# Create logging directory
mkdir -p ~/console-logs

# Log screen sessions automatically
cat >> ~/.screenrc << 'EOF'
# Enable logging
logfile ~/console-logs/screen-%Y%m%d-%c.log
deflog on
EOF

# Log with timestamp
script -a ~/console-logs/console-$(date +%Y%m%d-%H%M%S).log screen /dev/ttyUSB0 115200

# Restrict device access to specific users
sudo chown root:console /dev/ttyUSB0
sudo chmod 660 /dev/ttyUSB0

# Create console group
sudo groupadd console
sudo usermod -a -G console $USER

# Monitor console access
sudo auditctl -w /dev/ttyUSB0 -p rwxa -k console_access

# View audit logs
sudo ausearch -k console_access