USB3.cpp - master - electronic_modules/USB

USB3.cpp
175 строк5 KB
electronic_modules
USB
21 окт 2025, 12:31
21 окт 2025, 12:31d349ad5
#include "USB3.h"

USB3::USB3(int USB3_DATA_IN_P, int USB3_DATA_IN_M, int USB3_DATA_OUT_P, int USB3_DATA_OUT_M) {
    _USB3_DATA_IN_P = USB3_DATA_IN_P;
    _USB3_DATA_IN_M = USB3_DATA_IN_M;
    _USB3_DATA_OUT_P = USB3_DATA_OUT_P;
    _USB3_DATA_OUT_M = USB3_DATA_OUT_M;
    _deviceConnected = false;
    _initialized = false;
    _superSpeedMode = false;
    _powerDelivery = false;
}

void USB3::initial() {
    // Initialize USB 3.0 pins
    pinMode(_USB3_DATA_IN_P, INPUT_PULLUP);
    pinMode(_USB3_DATA_IN_M, INPUT_PULLUP);
    pinMode(_USB3_DATA_OUT_P, OUTPUT);
    pinMode(_USB3_DATA_OUT_M, OUTPUT);
    
    // USB 3.0 initialization sequence
    delay(100);
    usb3Reset();
    
    // Perform training sequence
    trainingSequence();
    
    // Negotiate SuperSpeed mode
    _superSpeedMode = negotiateSuperSpeed();
    
    _initialized = true;
    Serial.println(F("USB 3.0 Initialized"));
    Serial.print(F("Mode: "));
    Serial.println(_superSpeedMode ? F("SuperSpeed") : F("Fallback to USB 2.0"));
}

bool USB3::deviceDetect() {
    if (!_initialized) return false;
    
    // USB 3.0 device detection with LFPS (Low Frequency Periodic Signaling)
    bool inPState = digitalRead(_USB3_DATA_IN_P);
    bool inMState = digitalRead(_USB3_DATA_IN_M);
    
    // More sophisticated detection for USB 3.0
    _deviceConnected = (inPState == LOW && inMState == HIGH) || 
                      (inPState == HIGH && inMState == LOW);
    
    if (_deviceConnected) {
        Serial.println(F("USB 3.0 Device Detected"));
    }
    
    return _deviceConnected;
}

bool USB3::isConnected() {
    return _deviceConnected;
}

bool USB3::dataAvailable() {
    if (!_deviceConnected) return false;
    
    // Check for data availability with faster response
    return (digitalRead(_USB3_DATA_IN_P) != digitalRead(_USB3_DATA_IN_M));
}

uint8_t USB3::readData() {
    if (!_deviceConnected) return 0;
    
    // USB 3.0 data reading with faster sampling
    uint8_t data = 0;
    // This would involve high-speed differential signaling
    
    return data;
}

void USB3::writeData(uint8_t data) {
    if (!_deviceConnected) return;
    
    // USB 3.0 data writing with SuperSpeed capabilities
    if (_superSpeedMode) {
        // High-speed differential signaling
        digitalWrite(_USB3_DATA_OUT_P, (data & 0x01) ? HIGH : LOW);
        digitalWrite(_USB3_DATA_OUT_M, (data & 0x01) ? LOW : HIGH);
    } else {
        // Fallback to USB 2.0 signaling
        digitalWrite(_USB3_DATA_OUT_P, (data & 0x01) ? HIGH : LOW);
        digitalWrite(_USB3_DATA_OUT_M, (data & 0x01) ? LOW : HIGH);
    }
    
    Serial.print(F("USB3 Write: 0x"));
    Serial.println(data, HEX);
}

void USB3::superSpeedTransfer(uint8_t* data, size_t length) {
    if (!_deviceConnected || !_superSpeedMode) return;
    
    // High-speed bulk transfer for USB 3.0
    for (size_t i = 0; i < length; i++) {
        writeData(data[i]);
        delayMicroseconds(1); // SuperSpeed timing
    }
    
    Serial.print(F("USB3 SuperSpeed Transfer: "));
    Serial.print(length);
    Serial.println(F(" bytes"));
}

bool USB3::isSuperSpeed() {
    return _superSpeedMode;
}

void USB3::setPowerDelivery(bool enabled) {
    _powerDelivery = enabled;
    powerManagement(enabled);
    
    Serial.print(F("USB Power Delivery: "));
    Serial.println(enabled ? F("Enabled") : F("Disabled"));
}

void USB3::finish() {
    _deviceConnected = false;
    _initialized = false;
    _superSpeedMode = false;
    _powerDelivery = false;
    
    // Reset all pins to safe state
    pinMode(_USB3_DATA_IN_P, INPUT);
    pinMode(_USB3_DATA_IN_M, INPUT);
    pinMode(_USB3_DATA_OUT_P, INPUT);
    pinMode(_USB3_DATA_OUT_M, INPUT);
    
    Serial.println(F("USB 3.0 Finished"));
}

void USB3::usb3Reset() {
    // USB 3.0 reset sequence
    digitalWrite(_USB3_DATA_OUT_P, LOW);
    digitalWrite(_USB3_DATA_OUT_M, LOW);
    delay(50); // Longer reset for USB 3.0
    
    pinMode(_USB3_DATA_OUT_P, INPUT_PULLUP);
    pinMode(_USB3_DATA_OUT_M, INPUT_PULLUP);
}

bool USB3::negotiateSuperSpeed() {
    // SuperSpeed negotiation sequence
    // Simplified implementation
    return digitalRead(_USB3_DATA_IN_P) == LOW && digitalRead(_USB3_DATA_IN_M) == HIGH;
}

void USB3::trainingSequence() {
    // USB 3.0 training sequence for link establishment
    for (int i = 0; i < 3; i++) {
        digitalWrite(_USB3_DATA_OUT_P, HIGH);
        digitalWrite(_USB3_DATA_OUT_M, LOW);
        delayMicroseconds(10);
        digitalWrite(_USB3_DATA_OUT_P, LOW);
        digitalWrite(_USB3_DATA_OUT_M, HIGH);
        delayMicroseconds(10);
    }
    digitalWrite(_USB3_DATA_OUT_P, LOW);
    digitalWrite(_USB3_DATA_OUT_M, LOW);
}

void USB3::powerManagement(bool enable) {
    // Power management for USB 3.0
    if (enable) {
        // Enable higher power delivery
        // This would control power management IC in real implementation
        Serial.println(F("USB Power Delivery Enabled"));
    } else {
        // Disable power delivery
        Serial.println(F("USB Power Delivery Disabled"));
    }
}