Preston Ernst
-data logging revision
Diff: sw_fifo.cpp
- Revision:
- 1:25a2b47ca291
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/sw_fifo.cpp Thu Aug 05 08:27:51 2021 +0000
@@ -0,0 +1,285 @@
+////////////////////////////////////////////////////////////////////////////////////////
+/* enter necessary header files for proper interrupt vector and UART/USART visibility */
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <sw_fifo.h>
+#include "uart_comm_thread.h"
+
+typedef struct {
+ uint8_t data_buf[FIFO_BUFFER_SIZE]; // FIFO buffer
+ uint16_t i_first; // index of oldest data byte in buffer
+ uint16_t i_last; // index of newest data byte in buffer
+ uint16_t num_bytes; // number of bytes currently in buffer
+}sw_fifo_typedef;
+
+sw_fifo_typedef rx_fifo = { {0}, 0, 0, 0 }; // declare a receive software buffer
+sw_fifo_typedef tx_fifo = { {0}, 0, 0, 0 }; // declare a transmit software buffer
+
+
+/***************************************************************************************************************/
+// UART receive interrupt sub-routine
+// - interrupts when valid data exists in rx hardware buffer
+// - checks if there's room in the rx software buffer
+// - if there's room, it transfers the received data into the sw buffer
+// - automatically handles "uart_rx_buffer_full_flag"
+// - sets overflow flag upon software buffer overflow (doesn't overwrite existing data)
+//////////////////////////////////////////////
+/* enter name of UART RX IRQ Handler here */ {
+//////////////////////////////////////////////
+
+ /* Explicitly clear the source of interrupt if necessary */
+
+ if(rx_fifo.num_bytes == FIFO_BUFFER_SIZE) { // if the sw buffer is full
+ uart_rx_fifo_ovf_flag = 1; // set the overflow flag
+ }else if(rx_fifo.num_bytes < FIFO_BUFFER_SIZE) { // if there's room in the sw buffer
+
+ ///////////////////////////////////////////////////
+ /* read error/status reg here if desired */
+ /* handle any hardware RX errors here if desired */
+ ///////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ rx_fifo.data_buf[rx_fifo.i_last] = /* enter pointer to UART rx hardware buffer here */ // store the received data as the newest data element in the sw buffer
+ /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ rx_fifo.i_last++; // increment the index of the most recently added element
+ rx_fifo.num_bytes++; // increment the bytes counter
+ }
+ if(rx_fifo.num_bytes == FIFO_BUFFER_SIZE) { // if sw buffer just filled up
+ uart_rx_fifo_full_flag = 1; // set the RX FIFO full flag
+ }
+ if(rx_fifo.i_last == FIFO_BUFFER_SIZE) { // if the index has reached the end of the buffer,
+ rx_fifo.i_last = 0; // roll over the index counter
+ }
+ uart_rx_fifo_not_empty_flag = 1; // set received-data flag
+} // end UART RX IRQ handler
+/***************************************************************************************************************/
+
+
+/***************************************************************************************************************/
+// UART transmit interrupt sub-routine
+// - interrupts when the tx hardware buffer is empty
+// - checks if data exists in the tx software buffer
+// - if data exists, it places the oldest element of the sw buffer into the tx hardware buffer
+// - if the sw buffer is emptied, it disables the "hw buffer empty" interrupt
+// - automatically handles "uart_tx_buffer_full_flag"
+//////////////////////////////////////////////
+/* enter name of UART TX IRQ Handler here */ {
+//////////////////////////////////////////////
+
+ /* Explicitly clear the source of interrupt if necessary */
+
+ if(tx_fifo.num_bytes == FIFO_BUFFER_SIZE) { // if the sw buffer is full
+ uart_tx_fifo_full_flag = 0; // clear the buffer full flag because we are about to make room
+ }
+ if(tx_fifo.num_bytes > 0) { // if data exists in the sw buffer
+
+ ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ /* enter pointer to UART tx hardware buffer here */ = tx_fifo.data_buf[tx_fifo.i_first]; // place oldest data element in the TX hardware buffer
+ ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ tx_fifo.i_first++; // increment the index of the oldest element
+ tx_fifo.num_bytes--; // decrement the bytes counter
+ }
+ if(tx_fifo.i_first == FIFO_BUFFER_SIZE) { // if the index has reached the end of the buffer,
+ tx_fifo.i_first = 0; // roll over the index counter
+ }
+ if(tx_fifo.num_bytes == 0) { // if no more data exists
+
+ uart_tx_fifo_not_empty_flag = 0; // clear flag
+
+ //////////////////////////////////////////////////////////////////////////
+ /* disable UART "TX hw buffer empty" interrupt here */
+ /* if using shared RX/TX hardware buffer, enable RX data interrupt here */
+ //////////////////////////////////////////////////////////////////////////
+
+ }
+}// end UART TX IRQ handler
+/***************************************************************************************************************/
+
+
+/***************************************************************************************************************/
+// UART data transmit function
+// - checks if there's room in the transmit sw buffer
+// - if there's room, it transfers data byte to sw buffer
+// - automatically handles "uart_tx_buffer_full_flag"
+// - sets the overflow flag upon software buffer overflow (doesn't overwrite existing data)
+// - if this is the first data byte in the buffer, it enables the "hw buffer empty" interrupt
+void uart_send_byte(uint8_t byte) {
+
+ ///////////////////////////////////////////////////////////
+ /* disable interrupts while manipulating buffer pointers */
+ ///////////////////////////////////////////////////////////
+
+ if(tx_fifo.num_bytes == FIFO_BUFFER_SIZE) { // no room in the sw buffer
+ uart_tx_fifo_ovf_flag = 1; // set the overflow flag
+ }else if(tx_fifo.num_bytes < FIFO_BUFFER_SIZE) { // if there's room in the sw buffer
+ tx_fifo.data_buf[tx_fifo.i_last] = byte; // transfer data byte to sw buffer
+ tx_fifo.i_last++; // increment the index of the most recently added element
+ tx_fifo.num_bytes++; // increment the bytes counter
+ }
+ if(tx_fifo.num_bytes == FIFO_BUFFER_SIZE) { // if sw buffer is full
+ uart_tx_fifo_full_flag = 1; // set the TX FIFO full flag
+ }
+ if(tx_fifo.i_last == FIFO_BUFFER_SIZE) { // if the "new data" index has reached the end of the buffer,
+ tx_fifo.i_last = 0; // roll over the index counter
+ }
+
+ ///////////////////////
+ /* enable interrupts */
+ ///////////////////////
+
+ if(tx_fifo.num_bytes > 0) { // if there is data in the buffer
+
+ uart_tx_fifo_not_empty_flag = 1; // set flag
+
+ ///////////////////////////////////////////////////////////////////////////
+ /* if using shared RX/TX hardware buffer, disable RX data interrupt here */
+ /* enable UART "TX hw buffer empty" interrupt here */
+ ///////////////////////////////////////////////////////////////////////////
+
+ }
+}
+/***************************************************************************************************************/
+
+
+/***************************************************************************************************************/
+// UART data receive function
+// - checks if data exists in the receive sw buffer
+// - if data exists, it returns the oldest element contained in the buffer
+// - automatically handles "uart_rx_buffer_full_flag"
+// - if no data exists, it clears the uart_rx_flag
+uint8_t uart_get_byte(void) {
+
+ ///////////////////////////////////////////////////////////
+ /* disable interrupts while manipulating buffer pointers */
+ ///////////////////////////////////////////////////////////
+
+ uint8_t byte = 0;
+ if(rx_fifo.num_bytes == FIFO_BUFFER_SIZE) { // if the sw buffer is full
+ uart_rx_fifo_full_flag = 0; // clear the buffer full flag because we are about to make room
+ }
+ if(rx_fifo.num_bytes > 0) { // if data exists in the sw buffer
+ byte = rx_fifo.data_buf[rx_fifo.i_first]; // grab the oldest element in the buffer
+ rx_fifo.i_first++; // increment the index of the oldest element
+ rx_fifo.num_bytes--; // decrement the bytes counter
+ }else{ // RX sw buffer is empty
+ uart_rx_fifo_not_empty_flag = 0; // clear the rx flag
+ }
+ if(rx_fifo.i_first == FIFO_BUFFER_SIZE) { // if the index has reached the end of the buffer,
+ rx_fifo.i_first = 0; // roll over the index counter
+ }
+
+ ///////////////////////
+ /* enable interrupts */
+ ///////////////////////
+
+ return byte; // return the data byte
+}
+/***************************************************************************************************************/
+sw_fifo.h
+sw_fifo.h (1.5 KB)
+#define FIFO_BUFFER_SIZE 128 // software buffer size (in bytes)
+
+// UART data transmit function
+// - checks if there's room in the transmit sw buffer
+// - if there's room, it transfers data byte to sw buffer
+// - automatically handles "uart_tx_buffer_full_flag"
+// - sets the overflow flag upon software buffer overflow (doesn't overwrite existing data)
+// - if this is the first data byte in the buffer, it enables the "hw buffer empty" interrupt
+void uart_send_byte(uint8_t byte);
+
+
+// UART data receive function
+// - checks if data exists in the receive sw buffer
+// - if data exists, it returns the oldest element contained in the buffer
+// - automatically handles "uart_rx_buffer_full_flag"
+// - if no data exists, it clears the uart_rx_flag
+uint8_t uart_get_byte(void);
+
+volatile extern uint8_t uart_rx_fifo_not_empty_flag; // this flag is automatically set and cleared by the software buffer
+volatile extern uint8_t uart_rx_fifo_full_flag; // this flag is automatically set and cleared by the software buffer
+volatile extern uint8_t uart_rx_fifo_ovf_flag; // this flag is not automatically cleared by the software buffer
+volatile extern uint8_t uart_tx_fifo_full_flag; // this flag is automatically set and cleared by the software buffer
+volatile extern uint8_t uart_tx_fifo_ovf_flag; // this flag is not automatically cleared by the software buffer
+volatile extern uint8_t uart_tx_fifo_not_empty_flag; // this flag is automatically set and cleared by the software buffer
+
+// What I should post into the main:
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+
+/*
+#include <sw_fifo.h> // make software buffer visible to this file
+
+volatile uint8_t uart_rx_fifo_not_empty_flag = 0;
+volatile uint8_t uart_rx_fifo_full_flag = 0;
+volatile uint8_t uart_rx_fifo_ovf_flag = 0;
+volatile uint8_t uart_tx_fifo_full_flag = 0;
+volatile uint8_t uart_tx_fifo_ovf_flag = 0;
+volatile uint8_t uart_tx_fifo_not_empty_flag = 0;
+
+int main (void) {
+ uint8_t i = 0;
+ uint8_t rx_data = 0;
+
+ // initialize clocks
+ // disable global interrupts
+ // initialize gpio
+ // initialize uart/usart
+
+ // enable "UART RX" interrupt and "TX hardware buffer empty" interrupt
+ // enable global interrupts
+
+ while(uart_tx_fifo_full_flag); // wait for room to open up in the software buffer
+ uart_send_byte('A'); // transmit ASCII character 'A'
+ while(uart_tx_fifo_full_flag);
+ uart_send_byte(0x41); // transmit ASCII character 'A'
+
+ // transmit ASCII characters 1-5
+ for(i=0; i<5; i++) {
+ while(uart_tx_fifo_full_flag);
+ uart_send_byte(i+48);
+ }
+
+ while(1) {
+ // enter sleep mode if supported (wake from UART Rx)
+
+ while(uart_rx_fifo_not_empty_flag) { // if data exists in software buffer
+ rx_data = uart_get_byte(); // grab first data byte from software buffer
+
+ /* handle received byte as desired */
+
+
+ uart_send_byte(rx_data); // example of how to echo received ASCII characters
+ }
+
+ // check for rx overflow condition
+ if(uart_rx_fifo_ovf_flag) {
+
+ /* handle rx overflow condition as desired */
+
+ uart_rx_fifo_ovf_flag = 0; // clear the rx overflow flag
+ }
+
+ // check for tx overflow condition
+ if(uart_tx_fifo_ovf_flag) {
+
+ /* handle tx overflow condition as desired */
+
+ uart_tx_fifo_ovf_flag = 0; // clear the tx overflow flag
+ }
+
+ // if you need to disable global interrupts, you should wait until the tx fifo is empty
+ while(uart_tx_fifo_not_empty_flag);
+ /* Disable global interrupts */
+
+ /* Do something */
+
+ /* Re-enable global interrupts */
+ } // end while
+} // end main
+*/
+
+
+
+