cdc.cpp

Go to the documentation of this file.

/*
 * cdc.cpp - USB CDC Serial implementation
 *
 * Wraps TinyUSB CDC functions with SBL API.
 */
 
#include "cdc.hpp"
#include "tusb.h"
#include <cstring>
 
// Connection tracking for just_connected()
// Fires on: (1) first USB enumeration (boot), (2) DTR rising edge (terminal open)
static bool s_last_ready = false;
static volatile bool s_dtr_rose = false;
 
extern "C" void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts) {
    (void)itf;
    (void)rts;
    if (dtr) {
        s_dtr_rose = true;
    }
}
 
namespace sbl::usb {
 
size_t CdcSerial::write(const uint8_t* data, size_t len) {
    if (!tud_ready()) {
        return 0;
    }
 
    size_t written = 0;
    while (written < len) {
        size_t avail = tud_cdc_write_available();
        if (avail == 0) {
            // Buffer full, flush and retry
            tud_cdc_write_flush();
            tud_task();  // Process USB to make room
            avail = tud_cdc_write_available();
            if (avail == 0) {
                break;  // Still full, return what we wrote
            }
        }
 
        size_t to_write = (len - written) < avail ? (len - written) : avail;
        size_t n = tud_cdc_write(data + written, to_write);
        written += n;
 
        if (n == 0) {
            break;  // Write failed
        }
    }
 
    tud_cdc_write_flush();
    return written;
}
 
size_t CdcSerial::puts(const char* str) {
    if (!str) return 0;
    return write(reinterpret_cast<const uint8_t*>(str), strlen(str));
}
 
bool CdcSerial::write_byte(uint8_t byte) {
    if (!tud_ready()) {
        return false;
    }
 
    if (tud_cdc_write_available() == 0) {
        tud_cdc_write_flush();
        tud_task();
        if (tud_cdc_write_available() == 0) {
            return false;
        }
    }
 
    return tud_cdc_write_char(byte) == 1;
}
 
size_t CdcSerial::read(uint8_t* data, size_t max_len) {
    if (!tud_cdc_available()) {
        return 0;
    }
    return tud_cdc_read(data, max_len);
}
 
int CdcSerial::read_byte() {
    if (!tud_cdc_available()) {
        return -1;
    }
    return tud_cdc_read_char();
}
 
size_t CdcSerial::available() {
    return tud_cdc_available();
}
 
bool CdcSerial::connected() {
    return tud_cdc_connected();
}
 
bool CdcSerial::just_connected() {
    bool ready = tud_ready();
 
    // Boot: detect first USB enumeration
    if (ready && !s_last_ready) {
        s_last_ready = true;
        return true;
    }
    s_last_ready = ready;
 
    // Reconnect: detect DTR rising edge (terminal open)
    if (s_dtr_rose) {
        s_dtr_rose = false;
        return true;
    }
 
    return false;
}
 
void CdcSerial::flush() {
    tud_cdc_write_flush();
 
    // Wait for TX complete with timeout
    for (int i = 0; i < 1000; i++) {
        tud_task();
        if (tud_cdc_write_available() == CFG_TUD_CDC_TX_BUFSIZE) {
            break;  // Buffer empty, all sent
        }
        // Small delay - could use Timer::delay_us() but keep it simple
        for (volatile int j = 0; j < 1000; j++) {}
    }
}
 
} // namespace sbl::usb