main.cpp

#include "mbed.h"
// Example that prints to the screen and recieves input string from the PC via UART
// use SPRINTF(tx_line,'message') to input a string to the buffer, send line function then sends the buffer over UART
// readline will wait (for interrupts) until enter has been input, then it copys it to 'rx_line'.

Serial device(USBTX, USBRX);

DigitalOut led1(LED1);
DigitalOut led2(LED2);
DigitalOut led3(LED3);
DigitalOut led4(LED4);
 
 
void Tx_interrupt();            // prototypes
void Rx_interrupt();
void send_line();
void read_line();
 

const int buffer_size = 255;    // Circular buffers for serial TX and RX data - used by interrupt routines
char tx_buffer[buffer_size+1];  // Circular buffer pointers
char rx_buffer[buffer_size+1];

volatile int tx_in=0;           // volatile makes read-modify-write atomic 
volatile int tx_out=0;
volatile int rx_in=0;
volatile int rx_out=0;

char tx_line[80];               // Line buffers for sprintf and sscanf
char rx_line[80];
 
 
int main() {
    device.baud(9600);
    device.attach(&Rx_interrupt, Serial::RxIrq);    // Setup a serial interrupt function to receive data
    device.attach(&Tx_interrupt, Serial::TxIrq);    // Setup a serial interrupt function to transmit data
 
    while (1) 
    {
        sprintf(tx_line,"This text is copied into txline \n\r");    //Txline is used by 'send line' 
        send_line();                                                // Copy tx line buffer to large tx buffer for tx interrupt routine
        read_line();                                                // Read line filles the RXBuffer (upto an enter) and copies to rx line
        device.printf("\n\r '%s' \n\r ",rx_line);
    }
}

 

void read_line() // Read a line from the large rx buffer from rx interrupt routine
{
    int i = 0;
    NVIC_DisableIRQ(UART1_IRQn);                // Start Critical Section - don't interrupt while changing global buffer variables
    while ((i==0) || (rx_line[i-1] != 0x0d))    // Loop reading rx buffer characters until end of line character 
    {
        if (rx_in == rx_out)                    // Wait if buffer empty
        {
            NVIC_EnableIRQ(UART1_IRQn);         // End Critical Section - need to allow rx interrupt to get new characters for buffer
            while (rx_in == rx_out) 
            {
            }

            NVIC_DisableIRQ(UART1_IRQn);        // Start Critical Section - don't interrupt while changing global buffer variables
        }
        rx_line[i] = rx_buffer[rx_out];
        i++;
        rx_out = (rx_out + 1); //% buffer_size;
    }
    NVIC_EnableIRQ(UART1_IRQn);                 // End Critical Section
    rx_line[i-1] = 0;
    return;
}
 
 

void Rx_interrupt() 
{
    led1=1;

    while ((device.readable()) && (((rx_in + 1) % buffer_size) != rx_out)) // Loop just in case more than one character is in UART's receive FIFO buffer,Stop if buffer full
    {
        rx_buffer[rx_in] = device.getc();
        device.putc(rx_buffer[rx_in]);
        rx_in = (rx_in + 1); //% buffer_size;
    }
    led1=0;

    return;
}
 
 

void send_line() // Copy tx line buffer to large tx buffer for tx interrupt routine
{
    int i = 0;
    char temp_char;
    bool empty;

    NVIC_DisableIRQ(UART1_IRQn);                    // Start Critical Section - don't interrupt while changing global buffer variables
    empty = (tx_in == tx_out);
    while ((i==0) || (tx_line[i-1] != 0x0d))        // do  atleast once and while carage return is not detected) Wait if buffer full
    {
        if (((tx_in + 1) % buffer_size) == tx_out) // End Critical Section - need to let interrupt routine empty buffer by sending
        {
            NVIC_EnableIRQ(UART1_IRQn);
            while (((tx_in + 1) % buffer_size) == tx_out) 
            {
            
            }
            NVIC_DisableIRQ(UART1_IRQn);            // Start Critical Section - don't interrupt while changing global buffer variables
        }
        tx_buffer[tx_in] = tx_line[i];              //copy the characters from txline to tx buffer
        i++;                                        // increment line counter
        tx_in = (tx_in + 1) % buffer_size;          // increment buffer counter
    }
    if (device.writeable() && (empty)) 
    {
        temp_char = tx_buffer[tx_out];              //take current character into a temp
        tx_out = (tx_out + 1) % buffer_size;        //increment 'out' pointer
        device.putc(temp_char);                     //send character
    }
    NVIC_EnableIRQ(UART1_IRQn); // End Critical Section
    return;
}
 
 
 void Tx_interrupt() {
    led2=1;

    while ((device.writeable()) && (tx_in != tx_out)) // Loop to fill more than one character in UART's transmit FIFO buffer,Stop if buffer empty
    {
        device.putc(tx_buffer[tx_out]);
        tx_out = (tx_out + 1) % buffer_size;
    }
    led2=0;
    return;
}