mbed_usbserial.cpp

Go to the documentation of this file.

 
#include <algorithm>
 
#include "mbed.h"
#include "USBSerial.h"
#include "Serial.hxx"
#include "os/os.h"
#include "utils/macros.h"
#include "portmacro.h"
 
#ifdef TARGET_LPC2368
#endif
 
#define TX_DATA_SIZE 64
#define RX_DATA_SIZE 64
 
#include <stdlib.h>
 
void* operator new(size_t size);
void* operator new[](size_t size);
void operator delete(void* ptr);
void operator delete[](void* ptr);
 
__extension__ typedef int __guard __attribute__((mode(__DI__)));
 
extern "C" int __cxa_guard_acquire(__guard*);
extern "C" void __cxa_guard_release(__guard*);
extern "C" void __cxa_guard_abort(__guard*);
extern "C" void __cxa_pure_virtual(void);
 
class MbedRawUSBSerial : public USBCDC, public ::Serial
{
public:
    MbedRawUSBSerial(const char* name, uint16_t vendor_id = 0x1f00,
                     uint16_t product_id = 0x2012,
                     uint16_t product_release = 0x0001)
        : USBCDC(vendor_id, product_id, product_release),
          Serial(name),
          txPending(false)
    {
        os_sem_init(&rxSem, 0);
        os_thread_t thread;
        os_thread_create(&thread, "usbserial.rx", 3, 1024, &_RxThread, this);
    }
 
    ~MbedRawUSBSerial()
    {
        os_sem_destroy(&rxSem);
    }
 
protected:
    bool EP2_OUT_callback() override
    {
        //HASSERT(IsEpPending());
        // and wake up the RX thread.
        int woken;
        os_sem_post_from_isr(&rxSem, &woken);
        return false;
    }
 
    bool EP2_IN_callback() override
    {
        configASSERT(txPending);
        int woken = 0;
        if (TxHelper()) {
          txBuf->signal_condition_from_isr();
        }
        if (woken)
        {
#ifdef TARGET_LPC1768
            portYIELD();
#elif defined(TARGET_LPC2368)
#else
#error define how to yield on your CPU.
#endif
        }
        return true;
    }
 
private:
    void enable() override
    {
    } 
    void disable() override
    {
    } 
    void tx_char() override
    {
        // Without this critical section there were cases when we deadlocked
        // with txPending == true but no interrupt coming in to clear it.
        taskENTER_CRITICAL();
        if (txPending)
        {
            taskEXIT_CRITICAL();
            return;
        }
        txPending = true;
        if (TxHelper()) {
            txBuf->signal_condition();
        }
        taskEXIT_CRITICAL();
    }
 
    static const unsigned MAX_TX_PACKET_LENGTH = 64;
    static const unsigned MAX_RX_PACKET_LENGTH = 64;
 
    bool TxHelper()
    {
        size_t count;
        bool signal = false;
        for (count = 0; count < MAX_TX_PACKET_LENGTH;)
        {
            uint8_t *data;
            size_t max_count = std::min(txBuf->data_read_pointer(&data),
                                        MAX_TX_PACKET_LENGTH - count);
            if (max_count)
            {
                memcpy(&txData[count], data, max_count);
                count += max_count;
                txBuf->consume(max_count);
                signal = true;
            }
            else
            {
                break;
            }
        }
        if (!count)
        {
            txPending = false;
            return signal;
        }
        if (!configured())
        {
            // An error occured, data was lost.
            txPending = false;
            overrunCount += count;
            return signal;
        }
        txPending = true;
        sendNB(txData, count);
        return signal;
    }
 
    void RxThread()
    {
        while (1)
        {
            os_sem_wait(&rxSem);
            portENTER_CRITICAL();
            // we read the packet received to our assembly buffer
            bool result = readEP_NB(rxData, &rxSize);
            portEXIT_CRITICAL();
            if (!result)
            {
                diewith(0x80000CCC);
            }
            for (uint32_t i = 0; i < rxSize; i++)
            {
              //os_mq_send(rxQ, rxData + i);
            }
            rxSize = 0;
            // We reactivate the endpoint to receive next characters
            // readStart(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);
        }
    }
 
    static void* _RxThread(void* arg)
    {
        ((MbedRawUSBSerial*)arg)->RxThread();
        return NULL;
    }
 
    uint8_t txData[MAX_TX_PACKET_LENGTH]; 
    uint32_t rxSize; 
    uint8_t rxData
        [MAX_RX_PACKET_LENGTH]; 
    bool txPending;             
    os_sem_t rxSem;
};
 
void* operator new(size_t size)
{
    return malloc(size);
}
 
void* operator new [](size_t size)
{ return malloc(size); } void
operator delete(void* ptr) noexcept(true)
{
    free(ptr);
}
 
void operator delete [](void* ptr) noexcept(true)
{ free(ptr); } int __cxa_guard_acquire(__guard* g)
{
    return !*(char*)(g);
};
void __cxa_guard_release(__guard* g)
{
    *(char*)g = 1;
};
void __cxa_guard_abort(__guard*) {};
 
void __cxa_pure_virtual(void) {};
 
 
MbedRawUSBSerial g_mbed_usb_serial("/dev/serUSB0");