record adc values and send them to another uprocessor

Dependencies:   BufferedSerial SDFileSystem mbed

Fork of SDFileSystem_HelloWorld by mbed official

Files at this revision

API Documentation at this revision

Comitter:
patmcna
Date:
Thu Jun 16 21:17:30 2016 +0000
Parent:
3:dd18362fbfff
Commit message:
Organized into header files to keep main clean

Changed in this revision

ReadADC.h Show annotated file Show diff for this revision Revisions of this file
globals.h Show annotated file Show diff for this revision Revisions of this file
main.cpp Show annotated file Show diff for this revision Revisions of this file
sd_card.h Show annotated file Show diff for this revision Revisions of this file
serial_transfer.h Show annotated file Show diff for this revision Revisions of this file
diff -r dd18362fbfff -r 0e2980186bed ReadADC.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ReadADC.h	Thu Jun 16 21:17:30 2016 +0000
@@ -0,0 +1,21 @@
+#include "mbed.h"
+
+
+
+
+
+/************************************************************************
+* readADC will recieve an interrupt and store ADC data to an array
+*
+************************************************************************/
+void readADC()
+{
+    //pc.printf("Start reading ADC...");
+    for (int i = 0; i < ADCReadCount; i++)
+    {
+        squibCLT_array[i] = squibCLT_ADC.read();
+        arrayCount++;
+    }
+    //pc.printf("Done\r\n");
+}
+
diff -r dd18362fbfff -r 0e2980186bed globals.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/globals.h	Thu Jun 16 21:17:30 2016 +0000
@@ -0,0 +1,83 @@
+#include "mbed.h"
+
+
+
+/*========================================================================================
+                                  PROTOCOL SETUP/INSTANTIATE
+  ========================================================================================
+
+******************************************************************************************/
+SDFileSystem sd(SPI_MOSI, SPI_MISO, SPI_SCK, SPI_CS, "sd"); // mosi,miso,sclk,cs,name
+RawSerial pc(SERIAL_TX, SERIAL_RX);
+RawSerial uart1(PC_12, PD_2); // tx, rx
+RawSerial uart2(PC_10, PC_11); //tx, rx
+AnalogIn squibCLT_ADC(A0);
+
+
+
+/*========================================================================================
+                                  GLOBAL VARIABLES
+  ========================================================================================
+
+******************************************************************************************/
+
+
+
+//some global variables to pass data around
+
+
+float squibCLT_array2[256];
+char squibCLT_array3[256];
+
+int ADCReadCount = 32;
+int arrayCount = 0;
+float squibCLT_array[256];
+
+int sendCount, rxInterruptCount = 0;
+
+
+
+//serial interrupts transfer variables
+const int buffer_size = 255;
+char tx_buffer[buffer_size+1];
+char rx_buffer[buffer_size+1];
+volatile int tx_in = 0;
+volatile int tx_out = 0;
+volatile int rx_in = 0;
+volatile int rx_out = 0;
+volatile int receiveBuffer = 0;
+char tx_line[80];
+char rx_line[80];
+
+
+
+
+
+
+/*========================================================================================
+                                 FUNCTION
+  ========================================================================================
+
+******************************************************************************************/
+
+
+/************************************************************************
+* clean all the buffers
+************************************************************************/
+void cleanBuffers()
+{
+    memset(tx_buffer, 0, sizeof(tx_buffer));
+    memset(rx_buffer, 0, sizeof(rx_buffer));
+    tx_in = 0;
+    tx_out = 0;
+    rx_in = 0;
+    rx_out = 0;
+    receiveBuffer = 0;
+    memset(tx_line, 0, sizeof(tx_line));
+    memset(rx_line, 0, sizeof(rx_line)); 
+    arrayCount = 0;
+    memset(squibCLT_array, 0, sizeof(squibCLT_array));
+    memset(squibCLT_array3, 0, sizeof(squibCLT_array3));
+    rxInterruptCount = 0;   
+}
+
diff -r dd18362fbfff -r 0e2980186bed main.cpp
--- a/main.cpp	Wed Jun 15 01:47:13 2016 +0000
+++ b/main.cpp	Thu Jun 16 21:17:30 2016 +0000
@@ -1,452 +1,98 @@
-#include "mbed.h"
-#include "SDFileSystem.h"
-#include <string>
-#include <cstring>
-//#include "rtos.h"  This seems to cause compile errors and I haven't really structured 
-//                   the code to work with rtos ...
-
-/*========================================================================================
-                                           NOTES
-  ========================================================================================
-main is at the end of this file
-
-6/14/2016 - Everything is working!  115200 baud with array sizes of 32 bytes seems to be
-            what is working reliably.
-          - Keeping array sizes at 32 seems easy to send and receive over serial.  Trying
-            to figure out why serial receive hangs with more than 32 bytes of data
-            
-
-6/1/2016 - test to see if the recieve interrupt is handling the serial transfer and the
-           read_line() does not need to be called
-         - set up receive buffer to be stored into an array
-           ... this will depend on where serial data is being received
-
-
-Board:  STM Nucleo f303re
-Serial communciation: 
-    uart2 is connected to uart1 = 
-    PC_10 to D2, PC_11 to D8
-SPI communication to SD card:
-    MOSI, MISO, SCK, CS
-******************************************************************************************/
-
-
-
-/*========================================================================================
-                                  PROTOCOL SETUP/INSTANTIATE
-  ========================================================================================
-
-******************************************************************************************/
-SDFileSystem sd(SPI_MOSI, SPI_MISO, SPI_SCK, SPI_CS, "sd"); // mosi,miso,sclk,cs,name
-RawSerial pc(SERIAL_TX, SERIAL_RX);
-RawSerial uart1(PC_12, PD_2); // tx, rx
-RawSerial uart2(PC_10, PC_11); //tx, rx
-AnalogIn squibCLT_ADC(A0);
-
-
-
-/*========================================================================================
-                                  GLOBAL VARIABLES
-  ========================================================================================
-
-******************************************************************************************/
-
-
-
-//some global variables to pass data around
-int arrayCount = 0;
-float squibCLT_array[256];
-float squibCLT_array2[256];
-char squibCLT_array3[256];
-int sendCount, rxInterruptCount = 0;
-int ADCReadCount = 32;
-
-
-//serial interrupts transfer variables
-const int buffer_size = 255;
-char tx_buffer[buffer_size+1];
-char rx_buffer[buffer_size+1];
-volatile int tx_in = 0;
-volatile int tx_out = 0;
-volatile int rx_in = 0;
-volatile int rx_out = 0;
-volatile int receiveBuffer = 0;
-char tx_line[80];
-char rx_line[80];
-
-
-
-
-/*========================================================================================
-                              FUNCTION DEFINITIONS
-  ========================================================================================
-
-******************************************************************************************/
-
-
-/************************************************************************
-* clean all the buffers
-************************************************************************/
-void cleanBuffers()
-{
-    memset(tx_buffer, 0, sizeof(tx_buffer));
-    memset(rx_buffer, 0, sizeof(rx_buffer));
-    tx_in = 0;
-    tx_out = 0;
-    rx_in = 0;
-    rx_out = 0;
-    receiveBuffer = 0;
-    memset(tx_line, 0, sizeof(tx_line));
-    memset(rx_line, 0, sizeof(rx_line)); 
-    arrayCount = 0;
-    memset(squibCLT_array, 0, sizeof(squibCLT_array));
-    memset(squibCLT_array3, 0, sizeof(squibCLT_array3));
-    rxInterruptCount = 0;   
-}
-
-
-/************************************************************************
-*  Copy tx line buffer to large tx buffer for tx interrupt routine      *
-************************************************************************/
-void send_line() 
-{
-    int i = 0;
-    char temp_char;
-    bool empty;
-
-    __disable_irq();                                            //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] != '\n')) 
-    {
-        
-        if (((tx_in + 1) % buffer_size) == tx_out)          // Wait if buffer full
-        {        
-            __enable_irq();                                  //NVIC_EnableIRQ(UART1_IRQn);// End Critical Section - need to let interrupt routine empty buffer by sending
-            while (((tx_in + 1) % buffer_size) == tx_out) 
-            {
-            }
-          
-            __disable_irq();                                  //NVIC_DisableIRQ(UART1_IRQn);  // Start Critical Section - don't interrupt while changing global buffer variables
-        }
-
-        tx_buffer[tx_in] = tx_line[i];
-//        if (tx_buffer[tx_in] == '\r'){pc.printf("returnline");}
-        i++;
-        tx_in = (tx_in + 1) % buffer_size;
-    } 
-
-    if (uart1.writeable() && (empty)) 
-    {
-        temp_char = tx_buffer[tx_out];
-        tx_out = (tx_out + 1) % buffer_size;
-        
-        
-        uart1.putc(temp_char);                                // Send first character to start tx interrupts, if stopped
-
-//        pc.printf("send command. Value: %c\r\n", temp_char);
-    }
-    
-    __enable_irq();                                              //NVIC_EnableIRQ(UART1_IRQn);  // End Critical Section
-    return;
-}
- 
- 
- 
-/************************************************************************
-*  Read a line from the large rx buffer from rx interrupt routine       *
-************************************************************************/
-void read_line() 
-{
-    int i = 0;
-    
-    __disable_irq();                                        //NVIC_DisableIRQ(UART1_IRQn); // Start Critical Section - don't interrupt while changing global buffer variables
-    while ((i==0) || (rx_line[i-1] != '\r'))                // Loop reading rx buffer characters until end of line character
-    {
-        if (rx_in == rx_out)                                // Wait if buffer empty
-        {
-            __enable_irq();                                 //NVIC_EnableIRQ(UART1_IRQn); // End Critical Section - need to allow rx interrupt to get new characters for buffer
-            
-            while (rx_in == rx_out) 
-            {
-            }
-            __disable_irq();                                //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;
-    }
-
-    __enable_irq();                                         //NVIC_EnableIRQ(UART1_IRQn); // End Critical Section
-
-    strcat(squibCLT_array3,rx_line);
-    
-    rx_line[i-1] = 0;
-     
-    return;
-}
- 
- 
-
-/************************************************************************
-*  Interupt Routine to read in data from serial port                    *
-************************************************************************/
-void Rx_interrupt() 
-{
-            
-    while ((uart2.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] = uart2.getc();
-//          pc.putc(rx_buffer[rx_in]);                                              // Uncomment to Echo to USB serial to watch data flow
-            rx_in = (rx_in + 1) % buffer_size;
-            
-    }
-    
-    rxInterruptCount++;
-    return;
-}
- 
- 
-
-/************************************************************************
-*  Interupt Routine to write out data to serial port                    *
-************************************************************************/
-void Tx_interrupt() 
-{
-    while ((uart1.writeable()) && (tx_in != tx_out))                        // Loop to fill more than one character in UART's transmit FIFO buffer      // Stop if buffer empty
-    {
-
-        uart1.putc(tx_buffer[tx_out]);
-        tx_out = (tx_out + 1) % buffer_size;
-    }
-
-    return;
-}
- 
-
-
-/************************************************************************
-* This function will display the array that is being used 
-* to hold the ADC data collected by the uController
-************************************************************************/
-void printArray_debug(float* intArray)
-{    
-    for (int i = 0; i < arrayCount; i++)
-    {
-        pc.printf("%.6f\r\n", intArray[i]);
-    }    
-}
-
-
-
-/************************************************************************
-* handles creating an sd card object, opening the .txt file
-* then writes array c and closes file
-************************************************************************/
-void writeToSdCard()
-{
-    pc.printf("Begin write SD Card routine\r\n");
-    mkdir("/sd/mydir", 0777);
-
-    FILE *fp = fopen("/sd/mydir/sdtest.txt", "w");
-    
-    while(fp == NULL) 
-    {
-        error("Could not open file for write\r\n");
-    }
-
-    pc.printf("Start writing...");
-    
-    for (int i = 0; i < arrayCount; i++)
-    {    
-        fprintf(fp, "%f\r\n", squibCLT_array[i]);  
-    }
-
-    fclose(fp);         
-    pc.printf("Done\r\n");
-}
-
-
-
-/************************************************************************
-* handles opening the named .txt file and stores everything 
-* to the char array c and then closes the file.
-* 
-* 
-************************************************************************/
-void readFromSdCard()
-{
-    pc.printf("Begin read SD Card routine\r\n");
-    
-    FILE *fp = fopen("/sd/mydir/sdtest.txt", "r");
-    
-    while(fp == NULL) 
-    {
-        error("Could not open file for read\r\n");
-    }
-    
-    pc.printf("Starting read...");
-    
-    for (int i = 0; i < arrayCount; i++)
-    {
-        fscanf(fp, "%f", &squibCLT_array2[i]);
-    }           
-
-    fclose(fp);
-
-
-#if defined(__MICROLIB) && defined(__ARMCC_VERSION)                         // with microlib and ARM compiler  //possible sd card library bug.  Not sure if this helps
-    free(fp);
-#endif
-
-    pc.printf("Done.\r\n");
-
-}
-
-
-
-/************************************************************************
-* readADC will recieve an interrupt and store ADC data to an array
-*
-************************************************************************/
-void readADC()
-{
-    pc.printf("Start reading ADC...");
-    for (int i = 0; i < ADCReadCount; i++)
-    {
-        squibCLT_array[i] = squibCLT_ADC.read();
-        arrayCount++;
-    }
-    pc.printf("Done\r\n");
-}
-
-
-/************************************************************************
-* copies sd card array to serial buffer and sends it over buffer
-*
-************************************************************************/
-void sendSdCardDataOverSerial()
-{
-    Timer timer;
-    int begin, end;
-    
-    pc.printf("Sending over serial...");
-    
-    timer.start();
-    begin = timer.read_us();
-    
-    for (int i = 0; i < arrayCount; i++)
-    {
-        sprintf(tx_line, "%.6f\r\n]", squibCLT_array2[i]);
-        send_line(); 
-    }
-
-    end = timer.read_us();
-    
-    pc.printf("Done.\r\n");
-    
-    pc.printf("Transmit took %d microseconds to complete.\r\n", end - begin);
-}
-
-
-
-/************************************************************************
-* handles receiving data and storing it back into local memory
-*
-************************************************************************/    
-void receiveSdCardDataOverSerial()
-{
-    Timer timer;
-    int begin, end;
-
-    pc.printf("Receiving over serial...");
-        
-    timer.start();
-    begin = timer.read_us();
-    
-    for (int i = 0; i < arrayCount; i++)
-    {
-// for some reason you have to use this function to read in everything being sent instead of relying on the interrupt service exclusively
-        read_line();
-        //sprintf(squib_test, "%s", rx_line);
-    }
-    end = timer.read_us();
-    
-    pc.printf("Done.\r\n");
-    
-    pc.printf("Receive took %d microseconds to complete.\r\n", end - begin);
-}
-
-
-
-
-/****
-*   float to char array
-****/
-char floatToChar(float f)
-{
-    char charArray;
-    
-    return charArray;
-}
-
-
-/*========================================================================================
-                                              MAIN
-  ========================================================================================*/
-
-
-/************************************************************************
-* main handles:
-*       setting up serial ports, interrupts 
-*       reading ADC data into char array c
-*       then store it to an SD card, 
-*       then send it over serial
-*
-************************************************************************/
-int main() 
-{
-    pc.baud(128000);
-// 6/1/2016 sped up baud rate and need to compare with output to see if still the same
-// 6/14/2016 any baud rate over 115200 hangs up the serial recieve interrupt :/
-    uart1.baud(115200);
-    uart2.baud(115200); 
-    uart1.attach(&Tx_interrupt, Serial::TxIrq);                                         // Setup a serial interrupt function to transmit data
-    uart2.attach(&Rx_interrupt, Serial::RxIrq);                                         // Setup a serial interrupt function to receive data
-    
-    
-    for (int j = 0; j < 10; j++)
-    {
-        pc.printf("\r\nStarting SD card and serial test.\r\n\r\n");   
-  
-        readADC();  
-    
-        writeToSdCard();
-        readFromSdCard();
-
-        sendSdCardDataOverSerial();
-        receiveSdCardDataOverSerial();                                                    // Rx interrupt interferes with this since it reads from 2 places
-    
-
-    //debug code
-        for(int i = 0; i < arrayCount; i++)
-        {
-            pc.printf("     %f  -   %f   \r\n", squibCLT_array[i], squibCLT_array2[i]);   //, squib_test);
-        }
-                
-            pc.printf("%s", squibCLT_array3);
-            pc.printf("\r\n\r\n");
-        
-    
-        pc.printf("%d     %d\r\n", rxInterruptCount, sendCount);
-    
-        pc.printf("\r\nEND\r\n");
-        cleanBuffers();
-    }
-}
-
-
+#include "mbed.h"
+#include "SDFileSystem.h"
+#include "globals.h"
+#include <string>
+#include <cstring>
+#include "ReadADC.h"
+#include "serial_transfer.h"
+#include "sd_card.h"
+
+
+/*========================================================================================
+                                           NOTES
+  ========================================================================================
+
+
+6/14/2016 - Everything is working!  115200 baud with array sizes of 32 bytes seems to be
+            what is working reliably.
+          - Keeping array sizes at 32 seems easy to send and receive over serial.  Trying
+            to figure out why serial receive hangs with more than 32 bytes of data
+            
+
+6/1/2016 - test to see if the recieve interrupt is handling the serial transfer and the
+           read_line() does not need to be called
+         - set up receive buffer to be stored into an array
+           ... this will depend on where serial data is being received
+
+
+Board:  STM Nucleo f303re
+Serial communciation: 
+    uart2 is connected to uart1 = 
+    PC_10 to D2, PC_11 to D8
+SPI communication to SD card:
+    MOSI, MISO, SCK, CS
+******************************************************************************************/
+
+
+
+
+
+ 
+
+
+/*========================================================================================
+                                              MAIN
+  ========================================================================================*/
+
+
+/************************************************************************
+* main handles:
+*       setting up serial ports, interrupts 
+*       reading ADC data into char array c
+*       then store it to an SD card, 
+*       then send it over serial
+*
+************************************************************************/
+int main() 
+{
+    pc.baud(128000);
+// 6/1/2016 sped up baud rate and need to compare with output to see if still the same
+// 6/14/2016 any baud rate over 115200 hangs up the serial recieve interrupt :/
+    uart1.baud(115200);
+    uart2.baud(115200); 
+    uart1.attach(&Tx_interrupt, Serial::TxIrq);                                         // Setup a serial interrupt function to transmit data
+    uart2.attach(&Rx_interrupt, Serial::RxIrq);                                         // Setup a serial interrupt function to receive data
+    
+    
+    for (int j = 0; j < 10; j++)
+    {
+        pc.printf("\r\nStarting SD card and serial test.\r\n\r\n");   
+  
+        readADC();  
+    
+        writeToSdCard();
+        readFromSdCard();
+
+        sendSdCardDataOverSerial();
+        receiveSdCardDataOverSerial();                                                    // Rx interrupt interferes with this since it reads from 2 places
+    
+
+    //debug code
+        for(int i = 0; i < arrayCount; i++)
+        {
+            pc.printf("     %f  -   %f   \r\n", squibCLT_array[i], squibCLT_array2[i]);   //, squib_test);
+        }
+                
+            pc.printf("%s", squibCLT_array3);
+            pc.printf("\r\n\r\n");
+        
+    
+        pc.printf("%d     %d\r\n", rxInterruptCount, sendCount);
+    
+        pc.printf("\r\nEND\r\n");
+        cleanBuffers();
+    }
+}
+
+
+
diff -r dd18362fbfff -r 0e2980186bed sd_card.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sd_card.h	Thu Jun 16 21:17:30 2016 +0000
@@ -0,0 +1,68 @@
+#include "mbed.h"
+
+
+
+/************************************************************************
+* handles creating an sd card object, opening the .txt file
+* then writes array c and closes file
+************************************************************************/
+void writeToSdCard()
+{
+    pc.printf("Begin write SD Card routine\r\n");
+    mkdir("/sd/mydir", 0777);
+
+    FILE *fp = fopen("/sd/mydir/sdtest.txt", "w");
+    
+    while(fp == NULL) 
+    {
+        error("Could not open file for write\r\n");
+    }
+
+    pc.printf("Start writing...");
+    
+    for (int i = 0; i < arrayCount; i++)
+    {    
+        fprintf(fp, "%f\r\n", squibCLT_array[i]);  
+    }
+
+    fclose(fp);         
+    pc.printf("Done\r\n");
+}
+
+
+
+/************************************************************************
+* handles opening the named .txt file and stores everything 
+* to the char array c and then closes the file.
+* 
+* 
+************************************************************************/
+void readFromSdCard()
+{
+    pc.printf("Begin read SD Card routine\r\n");
+    
+    FILE *fp = fopen("/sd/mydir/sdtest.txt", "r");
+    
+    while(fp == NULL) 
+    {
+        error("Could not open file for read\r\n");
+    }
+    
+    pc.printf("Starting read...");
+    
+    for (int i = 0; i < arrayCount; i++)
+    {
+        fscanf(fp, "%f", &squibCLT_array2[i]);
+    }           
+
+    fclose(fp);
+
+
+#if defined(__MICROLIB) && defined(__ARMCC_VERSION)                         // with microlib and ARM compiler  //possible sd card library bug.  Not sure if this helps
+    free(fp);
+#endif
+
+    pc.printf("Done.\r\n");
+
+}
+
diff -r dd18362fbfff -r 0e2980186bed serial_transfer.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/serial_transfer.h	Thu Jun 16 21:17:30 2016 +0000
@@ -0,0 +1,188 @@
+#include "mbed.h"
+
+
+
+
+
+
+/************************************************************************
+*  Copy tx line buffer to large tx buffer for tx interrupt routine      *
+************************************************************************/
+void send_line() 
+{
+    int i = 0;
+    char temp_char;
+    bool empty;
+
+    __disable_irq();                                            //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] != '\n')) 
+    {
+        
+        if (((tx_in + 1) % buffer_size) == tx_out)          // Wait if buffer full
+        {        
+            __enable_irq();                                  //NVIC_EnableIRQ(UART1_IRQn);// End Critical Section - need to let interrupt routine empty buffer by sending
+            while (((tx_in + 1) % buffer_size) == tx_out) 
+            {
+            }
+          
+            __disable_irq();                                  //NVIC_DisableIRQ(UART1_IRQn);  // Start Critical Section - don't interrupt while changing global buffer variables
+        }
+
+        tx_buffer[tx_in] = tx_line[i];
+//        if (tx_buffer[tx_in] == '\r'){pc.printf("returnline");}
+        i++;
+        tx_in = (tx_in + 1) % buffer_size;
+    } 
+
+    if (uart1.writeable() && (empty)) 
+    {
+        temp_char = tx_buffer[tx_out];
+        tx_out = (tx_out + 1) % buffer_size;
+        
+        
+        uart1.putc(temp_char);                                // Send first character to start tx interrupts, if stopped
+
+//        pc.printf("send command. Value: %c\r\n", temp_char);
+    }
+    
+    __enable_irq();                                              //NVIC_EnableIRQ(UART1_IRQn);  // End Critical Section
+    return;
+}
+ 
+ 
+ 
+/************************************************************************
+*  Read a line from the large rx buffer from rx interrupt routine       *
+************************************************************************/
+void read_line() 
+{
+    int i = 0;
+    
+    __disable_irq();                                        //NVIC_DisableIRQ(UART1_IRQn); // Start Critical Section - don't interrupt while changing global buffer variables
+    while ((i==0) || (rx_line[i-1] != '\r'))                // Loop reading rx buffer characters until end of line character
+    {
+        if (rx_in == rx_out)                                // Wait if buffer empty
+        {
+            __enable_irq();                                 //NVIC_EnableIRQ(UART1_IRQn); // End Critical Section - need to allow rx interrupt to get new characters for buffer
+            
+            while (rx_in == rx_out) 
+            {
+            }
+            __disable_irq();                                //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;
+    }
+
+    __enable_irq();                                         //NVIC_EnableIRQ(UART1_IRQn); // End Critical Section
+
+    strcat(squibCLT_array3,rx_line);
+    
+    rx_line[i-1] = 0;
+     
+    return;
+}
+ 
+ 
+
+/************************************************************************
+*  Interupt Routine to read in data from serial port                    *
+************************************************************************/
+void Rx_interrupt() 
+{
+            
+    while ((uart2.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] = uart2.getc();
+//          pc.putc(rx_buffer[rx_in]);                                              // Uncomment to Echo to USB serial to watch data flow
+            rx_in = (rx_in + 1) % buffer_size;
+            
+    }
+    
+    rxInterruptCount++;
+    return;
+}
+ 
+ 
+
+/************************************************************************
+*  Interupt Routine to write out data to serial port                    *
+************************************************************************/
+void Tx_interrupt() 
+{
+    while ((uart1.writeable()) && (tx_in != tx_out))                        // Loop to fill more than one character in UART's transmit FIFO buffer      // Stop if buffer empty
+    {
+
+        uart1.putc(tx_buffer[tx_out]);
+        tx_out = (tx_out + 1) % buffer_size;
+    }
+
+    return;
+}
+
+
+
+
+/************************************************************************
+* copies sd card array to serial buffer and sends it over buffer
+*
+************************************************************************/
+void sendSdCardDataOverSerial()
+{
+    Timer timer;
+    int begin, end;
+    
+    pc.printf("Sending over serial...");
+    
+    timer.start();
+    begin = timer.read_us();
+    
+    for (int i = 0; i < arrayCount; i++)
+    {
+        sprintf(tx_line, "%.6f\r\n]", squibCLT_array2[i]);
+        send_line(); 
+    }
+
+    end = timer.read_us();
+    
+    pc.printf("Done.\r\n");
+    
+    pc.printf("Transmit took %d microseconds to complete.\r\n", end - begin);
+}
+
+
+
+/************************************************************************
+* handles receiving data and storing it back into local memory
+*
+************************************************************************/    
+void receiveSdCardDataOverSerial()
+{
+    Timer timer;
+    int begin, end;
+
+    pc.printf("Receiving over serial...");
+        
+    timer.start();
+    begin = timer.read_us();
+    
+    for (int i = 0; i < arrayCount; i++)
+    {
+// for some reason you have to use this function to read in everything being sent instead of relying on the interrupt service exclusively
+        read_line();
+        //sprintf(squib_test, "%s", rx_line);
+    }
+    end = timer.read_us();
+    
+    pc.printf("Done.\r\n");
+    
+    pc.printf("Receive took %d microseconds to complete.\r\n", end - begin);
+}
+