Revision 4:0e2980186bed, committed 2016-06-16

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

--- /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");
+}
+

--- /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;   
+}
+

--- 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();
+    }
+}
+
+
+

--- /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");
+
+}
+

--- /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);
+}
+