xyFC/src/arm/serial.cpp

/*
 * serial.c
 */

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-pedantic"
#include "mbed.h"
#pragma GCC diagnostic pop

#include "MODSERIAL.h"

#define UART_COUNT 1

static MODSERIAL serial(USBTX, USBRX, 2048, 32);

extern "C" {

#include "serial.h"

uint8_t serialAvailable(void) {
    return UART_COUNT;
}

void serialInit(uint8_t uart, uint32_t baud) {
    if (uart >= UART_COUNT)
        return;

    serial.baud(baud);
}

void serialClose(uint8_t uart) {
    if (uart >= UART_COUNT)
        return;

    // Nothing to do
}

uint8_t serialHasChar(uint8_t uart) {
    if (uart >= UART_COUNT)
        return 0;

    return serial.readable();
}

uint8_t serialGetBlocking(uint8_t uart) {
    if (uart >= UART_COUNT)
        return 0;

    if (!serial.readable()) {
        return 0;
    }

    return serial.getc();
}

uint8_t serialGet(uint8_t uart) {
    if (uart >= UART_COUNT)
        return 0;

    while (!serial.readable());

    return serial.getc();
}

uint8_t serialRxBufferFull(uint8_t uart) {
    if (uart >= UART_COUNT)
        return 0;

    return serial.readable();
}

void serialWrite(uint8_t uart, uint8_t data) {
    if (uart >= UART_COUNT)
        return;

    serial.putc(data);
}

void serialWriteString(uint8_t uart, const char *data) {
    if (data == 0) {
        serialWriteString(uart, "NULL");
    } else {
        while (*data != '\0') {
            serialWrite(uart, *data++);
        }
    }
}

void serialWriteHex(uint8_t uart, uint8_t value) {
    char buff[3] = { 0, 0, '\0' };

    if (value >= 16) {
        buff[0] = value / 16;
        value = value % 16;
    }
    buff[1] = value;

    if (buff[0] <= 9) {
        buff[0] += '0';
    } else {
        buff[0] -= 10;
        buff[0] += 'A';
    }

    if (buff[1] <= 9) {
        buff[1] += '0';
    } else {
        buff[1] -= 10;
        buff[1] += 'A';
    }

    serialWriteString(uart, buff);
}

void serialWriteUnsigned8(uint8_t uart, uint8_t value) {
    char buff[4] = { '0', '0', '0', '\0' };

    uint8_t pos = sizeof(buff) - 2;
    while (value > 0) {
        buff[pos--] = '0' + (value % 10);
        value /= 10;
    }

    uint8_t start = 0;
    while ((start < (sizeof(buff) - 2)) && (buff[start] == '0')) {
        start++;
    }

    serialWriteString(uart, buff + start);
}

void serialWriteUnsigned16(uint8_t uart, uint16_t value) {
    char buff[6] = { '0', '0', '0', '0', '0', '\0' };

    uint8_t pos = sizeof(buff) - 2;
    while (value > 0) {
        buff[pos--] = '0' + (value % 10);
        value /= 10;
    }

    uint8_t start = 0;
    while ((start < (sizeof(buff) - 2)) && (buff[start] == '0')) {
        start++;
    }

    serialWriteString(uart, buff + start);
}

void serialWriteUnsigned32(uint8_t uart, uint32_t value) {
    char buff[11] = { '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '\0' };

    uint8_t pos = sizeof(buff) - 2;
    while (value > 0) {
        buff[pos--] = '0' + (value % 10);
        value /= 10;
    }

    uint8_t start = 0;
    while ((start < (sizeof(buff) - 2)) && (buff[start] == '0')) {
        start++;
    }

    serialWriteString(uart, buff + start);
}

void serialWriteUnsigned64(uint8_t uart, uint64_t value) {
    char buff[21] = { '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
                      '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '\0' };

    uint8_t pos = sizeof(buff) - 2;
    while (value > 0) {
        buff[pos--] = '0' + (value % 10);
        value /= 10;
    }

    uint8_t start = 0;
    while ((start < (sizeof(buff) - 2)) && (buff[start] == '0')) {
        start++;
    }

    serialWriteString(uart, buff + start);
}

uint8_t serialTxBufferFull(uint8_t uart) {
    if (uart >= UART_COUNT)
        return 1;

    return !serial.writeable();
}

uint8_t serialTxBufferEmpty(uint8_t uart) {
    if (uart >= UART_COUNT)
        return 0;

    return serial.writeable();
}

}