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>
 
namespace sbl::usb {
 
size_t CdcSerial::write(const uint8_t* data, size_t len) {
    if (!tud_cdc_connected()) {
        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_cdc_connected()) {
        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();
}
 
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