/*
 * David Muller; Germán Alfaro
 * davehmuller@gmail.com; alfaro.germanevera@gmail.com
 * Thom Maughan, tm@mbari.org
 */





#include "system.h"
#include "ctd_base.h"
#include "ctd_aand5860.h"
#include "ctd_sbe37_microcat.h"
#include "uartstdio.h"
#include "user_io.h"
#include "board_util.h"

// driver model:
// base functions tied to hardware are named after silk screen, ex. ctd_base
// instrument specific functions are named for the manufacturer, ex. aanderaa_conductivity, shortened aand_cond.c and are built on hardware specific functions
// note, the hardware specific functions are built from TI Tivaware which is flexible to enable porting to different UARTs and peripheral mapping - this flex is left as is, but can be confusing if you don't know why the added flex is there


#ifdef SIMULATOR
//Timing
// ctd microcat serial analyzer, bytes and times  Ctrl-X to quit
//
//open (ctd power on)
//   time = 260 msec
//SBE 37-SI
//ts
//   time = 2630+160 msec
//  28.8567,  0.00008,   -0.141,   0.0132, 03 May 2021, 17:06:57
//<Executed/>


ctd OPTODE serial analyzer, bytes and times
open
RX: % [0x25]  time = 230 msec
TX: crlf
RX: ! [0x21]  time = 10 msec
TX: crlf do sample crlf
RX: 5 [0x35]  time = 1470 msec
RX: 8 [0x38]  time = 0 msec
RX: 6 [0x36]  time = 0 msec
RX: 0 [0x30]  time = 0 msec
RX:      [0x09]  time = 0 msec
RX: 2 [0x32]  time = 0 msec
RX: 9 [0x39]  time = 0 msec
RX:      [0x09]  time = 0 msec
RX: - [0x2d]  time = 10 msec
RX: 0 [0x30]  time = 0 msec
RX: . [0x2e]  time = 0 msec
RX: 0 [0x30]  time = 0 msec
RX: 0 [0x30]  time = 0 msec
RX: 3 [0x33]  time = 0 msec
RX:      [0x09]  time = 0 msec
RX: 1 [0x31]  time = 0 msec
RX: 7 [0x37]  time = 0 msec
RX: . [0x2e]  time = 0 msec
RX: 2 [0x32]  time = 10 msec
RX: 7 [0x37]  time = 0 msec
RX: 2 [0x32]  time = 0 msec
RX:      [0x09]  time = 0 msec
RX: 0 [0x30]  time = 0 msec
RX: . [0x2e]  time = 0 msec
RX: 0 [0x30]  time = 0 msec
RX: 0 [0x30]  time = 0 msec
RX: 9 [0x39]  time = 0 msec
RX:      [0x09]  time = 0 msec
RX: 9 [0x39]  time = 0 msec
RX: 9 [0x39]  time = 0 msec
RX: 8 [0x38]  time = 0 msec
RX: . [0x2e]  time = 0 msec
RX: 7 [0x37]  time = 0 msec
RX: 3 [0x33]  time = 0 msec
RX: 6 [0x36]  time = 0 msec
RX:      [0x09]  time = 0 msec
RX: 1 [0x31]  time = 10 msec
RX: 4 [0x34]  time = 0 msec
RX: 7 [0x37]  time = 0 msec
RX: 3 [0x33]  time = 0 msec
RX: . [0x2e]  time = 0 msec
RX: 6 [0x36]  time = 0 msec
RX: 9 [0x39]  time = 0 msec
RX: 4 [0x34]  time = 0 msec
 [0x0d]  time = 0 msec
RX:
 [0x0a]  time = 0 msec
RX: # [0x23]  time = 10 msec
 [0x0d]  time = 0 msec
RX:
 [0x0a]  time = 0 msec

#endif


extern unsigned long Timer_10ms(bool reset);

struct ctdDriver ctd;   // struct defd in ctd_base.h

//ctd (Conductivity Sensor) UART module
#define CTD_UART_BASE           UART4_BASE
#define CTD_UART_PERIPH         SYSCTL_PERIPH_UART4
#define CTD_GPIO_PORT_BASE      GPIO_PORTC_BASE
#define CTD_GPIO_PERIPH         SYSCTL_PERIPH_GPIOC
#define CTD_GPIO_PIN_NAME_RX    GPIO_PC4_U4RX
#define CTD_GPIO_PIN_NAME_TX    GPIO_PC5_U4TX
#define CTD_GPIO_PIN_NUMBER_RX  GPIO_PIN_4
#define CTD_GPIO_PIN_NUMBER_TX  GPIO_PIN_5
#define CTD_UART_INT            INT_UART4

#define CTD_UART_RX_BUFFER_SIZE     128
#define CTD_UART_TX_BUFFER_SIZE     128

/*
 * ASCII characters.
 */
#define SPACE 0x20
#define OPENBRACE 0x7b
#define TAB 0x09



// init backplane call, note hardcoded baud rate.
void ctd_init(void)
{
#if BOARD_MPHOX >= 1
    /*** Inititialize Conductivity sensor driver (ctd) on UART 4 ***/

    // Setup Power control GPIO CTDpwr and turn power off
    ROM_GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, GPIO_PIN_0); // CTDpwr (same connector as MicroCat/CTD) (PD0, pin 1)
    ROM_GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_0, 0x00);    // CTDpwr=off   silk: J8


    // set up UART4 for the conductivity sensor, aka ctd, NOTE: ISR needs to be updated in tm4c123gh6pge_startup_ccs.c
    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART4);
    ROM_GPIOPinConfigure(CTD_GPIO_PIN_NAME_RX);  // GPIO_PC4_U4RX  ROM_GPIOPinConfigure(GPIO_PC4_U4RX);
    ROM_GPIOPinConfigure(CTD_GPIO_PIN_NAME_TX);  // GPIO_PC5_U4TX  ROM_GPIOPinConfigure(GPIO_PC5_U4TX);
    ROM_GPIOPinTypeUART(CTD_GPIO_PORT_BASE, CTD_GPIO_PIN_NUMBER_RX | CTD_GPIO_PIN_NUMBER_TX);  //ROM_GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_4 | GPIO_PIN_5);

    // Use the internal 16MHz oscillator as the UART clock source.
    UARTClockSourceSet(CTD_UART_BASE, UART_CLOCK_PIOSC);  //UART4_BASE

    //#define CTD_BAUD     9600  defd in ctd_base.h, tm4c123gh6pge_startup_ccs.c needs UART3 isr plugged to match config
    ctd_config(4, CTD_BAUD, 16000000); // Configure Optode UART  (9600,N,8,1)
    ctd_echoSet(0);   // Disable echo to Conductivity sensor (ctd)
#endif

}


/*
 * Apply power to the Condo and prepare uart4 and driver state vars.
 * Assumes ctd_init is called.
 */
void ctd_open(void)
{

#if BOARD_MPHOX >= 1        // was BOARD_MFET >= 2  || BOARD_MPHOX >= 1
	// turn on Vbat supply on J8 MPHOX
    //ROM_GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_0, 0xFF);    // J8 CTDpwr PD0 Power on
    pwr_ctd_on();       //defd in board_util.c
#endif

    ctd.state = 0;
    ctd.bufIndx = 0;
    //ROM_SysCtlDelay(MILLISECOND*10);  // power stable for 10mec (TODO, this could be trimmed down)

    //ctd_flushRx();
    //ctd_flushTx(true);   // true says discard

}

void ctd_close(void)
{

#if BOARD_MPHOX >= 1
    //ROM_GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_0, 0x00);    // J8 CTDpowr PD0 Power off
    pwr_ctd_off();
#endif

}



#ifdef CAPTUREDFROMTERATERM
SBE 37-SI
ts
  23.3971,  0.00007,    0.127,   0.0113, 29 Apr 2021, 15:51:19
<Executed/>
#endif


/*
 * ctd_stateMachine
 *
 * pass in state=1 to start it, check for finish when returned state value is 0
 *
 * the statemachine determines which instrument (MicroCat or Aanderaa 5860 is connected)
 *
 */
int ctd_stateMachine(int ctdState)
{

    //int nextState = 0;
    unsigned int indx;
    //unsigned int tick1, tick2;
    unsigned char inChar;
    int debugFlag = 0;
    uint32_t wait_ms;

#define ST_NADA             0
#define ST_POWERON_OPEN     1
#define ST_RX_INSTRUMENT    2
    // example usage:
    //ctdState = 1;
    //ctdState = ctd_stateMachine(ctdState);     //pass in 1 to start the state machine, hereafter pass retVal
    //call statemachine repeatedly until ctdState == 0

    //open (ctd power on)
    //   time = 260 msec
    //SBE 37-SI
    //ts
    //   time = 2630+160 msec
    //  28.8567,  0.00008,   -0.141,   0.0132, 03 May 2021, 17:06:57
    //<Executed/>


    ctd.state = ctdState;    // for debugging, ctd.state not used at this time.

#define COMMA 0x2C
#define TAB   '\t'  //0x09   //CTRL-I

    switch(ctdState)
    {
        case 0:
            // do nothing, caller needs to pass in state=1 to start things
            return(0);

        case 1:
            ctd_open();   // power on ctd Vbat supply
            ROM_SysCtlDelay(MILLISECOND*20);  // power stable for 20mec (TODO, this could be trimmed down)

            ctd_flushRx();
            ctd_flushTx(true);   // true says discard

            ctd.old_tick10ms = Timer_10ms(false);
            ctd.state = 2;
            ctd.type = 0;       // instrument driver not yet identified, this happens in state=2
            return(2);


        case 2:   // looking for a response from instrument after power up, either % from Aanderaa or S from MicroCat
            if( ctd_rxBytesAvail() )
            {
                inChar = ctd_getc();
                //if(debugFlag == 1) uprintf( "st2[%02x] %c ", inChar,inChar );   // DEBUG

                if(inChar == 'S')  //SBE 37-SI
                {
                    ctd.old_tick10ms = Timer_10ms(false);
                    if(debugFlag == 1) uprintf("[GO6]");   //DEBUG

                    if(debugFlag == 1) uprintf("[GO6]");   //DEBUG
                    ctd.state = 6;
                    return(6);

                }
                if(inChar == '%')  //Aanderaa 5860 (type=2)
                {

                    ctd.old_tick10ms = Timer_10ms(false);
                    ctd_putc(0x0d);  // CR=13
                    ctd_putc(0x0a);  // LF=10
                    //uprintf("[GO3]");

                    // TODO - add a time out here
                    inChar = ctd_getc();
                    //uprintf( "(%02x)", inChar );
                    if(inChar == '!')
                    {
                        ctd_write("do sample\r\n",12 );
                        ctd.old_tick10ms = Timer_10ms(false);
                        ctd.state = 4;
                        return(4);
                    }
                    else
                    {
                        //WHat happens if ! is not received?
                        if(sys_data.diag > 0) uprintf("CTD Err: did not receive ! after crlf following %%\n");
                        wait_consoleTx();
                        ctd.state = -1;
                        return(0);
                    }

                }
            }

            ctd.new_tick10ms = Timer_10ms(false);
            if((ctd.new_tick10ms - ctd.old_tick10ms) >= 250)  // wait at least 2500msec for slow statemachine pumping.   600msec = 60*10msec
            {

                if(sys_data.diag > 0) uprintf("\nNo CTD response in 2.5sec, statemachine pumping too slow or instrument not connected\n");   // DEBUG
                sprintf((char *)&ctd.buf[0], "CTD not responding with SBE 37-SI after power up");
                wait_consoleTx();
                ctd.state = -1;
                return(0);

            }
            //ctd.state = 2;
            return(2);



        case 4:

            if( ctd_rxBytesAvail() )      // if 1st char is available, get the entire do sample response string upto 1200msec
            {
                ctd.old_tick10ms = Timer_10ms(false);  // reset timer
                while(1)       // expect no more than 100 chars
                {
#define WAIT10MSTICKVAL  5
                    wait_ms = wait_ctdRx(WAIT10MSTICKVAL);   // 50msec ought to be enough
                    if(wait_ms == WAIT10MSTICKVAL)
                    {
                        if(sys_data.diag > 0) uprintf("\nDEBUG: inter-character delay exceeded 50msec receiving do_sample string\n");
                        sprintf((char *)&ctd.buf[0], "CTD driver Err: inter-character delay exceeded 50msec receiving do_sample string");
                        wait_consoleTx();
                        ctd_close();  // Close ctd, power off
                        ctd.state = -1;  // future, do something about error checking
                        return(0);
                    }
                    // check timeout (all chars should be received within 120msec (10msec per char * 91 chars + crlf + #) + pad)
                    inChar = ctd_getc();

                    if(inChar == 0x0d)
                    {
                        inChar = 0;     //zero terminate ctd.buf
                    }
                    if(inChar == '#')  // end of data
                    {
                        ctd_Aand5860_parseData();       // ctd.buf is parsed into ctd.condo, ctd.tempC and ctd.salt
                        ctd_close();  // Close ctd, power off
                        ctd.type = TYPE_AANDERAA_5860;
                        if(ctd.type != sys_data.data_cfg[CFG_CTD])
                        {
                            uprintf("\nERROR: CTD type %u, does not match data config type %u. Correcting data config to %u, Aanderaa 5860\n", ctd.type, sys_data.data_cfg[CFG_CTD], ctd.type);
                            sys_data.data_cfg[CFG_CTD] = ctd.type;
                            // TODO: should we call storeSysDataVariables() or wait til sleep does a store  27 Jul 2021
                        }
                        ctd.state = 0;
                        return(0);
                    }

                    // put the data into ctd_buff[indx]
                    //ctd.new_tick10ms = Timer_10ms(false);  // DEBUG
                    //tick2 = ctd.new_tick10ms - ctd.old_tick10ms;  // DEBUG
                    //uprintf(" %c", inChar );  // DEBUG
                    //uprintf("[%02x](%ums) ", inChar, tick2); //DEBUG

                    ctd.buf[ctd.bufIndx] = inChar;
                    ctd.bufIndx++;
                    if(ctd.bufIndx >= CTD_BUFFER_SIZE)
                    {
                        ctd.bufIndx = CTD_BUFFER_SIZE-1;
                        if(sys_data.diag > 0) uprintf("\nDEBUG: error in ctd driver bufIndx exceeds buf size, ctd_base.c\n");
                        ctd_close();  // Close CTD, power off
                        ctd.state = -1;
                        return(0);
                    }


                }

            } // if rxByte

            ctd.new_tick10ms = Timer_10ms(false);
            if((ctd.new_tick10ms - ctd.old_tick10ms) >= 500)  // 5000msec = 500*10msec
            {
                sprintf((char *)&ctd.buf[0], "CTD not responding with sample string after do sample");
                ctd_close();  // Close Optode, power off
                ctd.state = -1;
                return(0);
            }
            return(4);

        case 6:
            // S was received above in case 2, finish receiving BE 37-SI[0d][0a]

            for(indx=0; indx<1000; indx++)   //100msec to receive SBE 37-SI, transmit ts and receive echo
            {
                ROM_SysCtlDelay(MICROSECOND * 100);
                if( ctd_rxBytesAvail() )      // get the terminating cr or cr-lf
                {

                    inChar = ctd_getc();
                    //if(debugFlag == 1) uprintf( "st6[%02x] %c ", inChar,inChar );   // DEBUG

                    // note frontline async shows 0x0d, bad frame, 0x0a
                    //if(inChar == 0x0d || inChar == 0x0a)
                    if(inChar == 0x0a)
                    {
                        ctd_putc('t');
                        ctd_putc('s');
                        ctd_putc(0x0d);

                        ctd.old_tick10ms = Timer_10ms(false);
                        while(1)  // get the echo of ts crlf
                        {
                            inChar = ctd_getc();
                            //if(debugFlag == 1) uprintf( "st6[%02x] ", inChar );   // DEBUG
                            if(inChar == 0x0a)
                                break;
                            ctd.new_tick10ms = Timer_10ms(false);
                            if((ctd.new_tick10ms - ctd.old_tick10ms) >= 50) // 500msec
                            {
                                if(sys_data.diag > 0) uprintf("\nCTD ST6, no echo of 'ts' command, ret ST0\n");
                                sprintf((char *)&ctd.buf[0], "CTD ST6, no echo of 'ts' command, ret ST0");
                                wait_consoleTx();
                                ctd.type = 0;
                                ctd_close();
                                ctd.state = -1;
                                return(0);

                            }

                        }

                        ctd.old_tick10ms = Timer_10ms(false);
                        //if(debugFlag == 1) uprintf("\n[GO7]\n");
                        ctd.state = 7;
                        return(7);
                    }

                } // if rx byte

                ctd.new_tick10ms = Timer_10ms(false);
                if((ctd.new_tick10ms - ctd.old_tick10ms) >= 150)  // 1500msec = 150*10msec (should be less than 300mec, but want resilience with slow calling frequency (1Hz) in fast_sample
                {
                    if(sys_data.diag > 0) uprintf("\nNot receiving BE 37-SI[0d][0a] in 1500msec after power up\n");
                    sprintf((char *)&ctd.buf[0], "Not receiving BE 37-SI[0d][0a] in 1500msec");
                    wait_consoleTx();
                    ctd.type = 0;
                    ctd.state = -1;
                    ctd_close();  // Close CTD, power off
                    return(0);
                }

            }  //indx

            //ctd.type = 1;  // SBE37 MicroCat

            if(sys_data.diag > 0) uprintf("\nNot receiving BE 37-SI[0d][0a] and ts echo in 110msec after receiving 'S' after power up\n");
            sprintf((char *)&ctd.buf[0], "Not receiving BE 37-SI[0d][0a] and ts echo in 110msec after receiving 'S' after power up");
            wait_consoleTx();
            ctd.type = 0;
            ctd_close();  // Close CTD, power off
            ctd.state = -1;
            return(0);


        case 7:
            // wait for 2.6 to 3 seconds for microcat to respond
            if( ctd_rxBytesAvail() )      // bytes from CTD
            {
                ctd.state = 8;
                return(8);
            }

            ctd.new_tick10ms = Timer_10ms(false);
            if((ctd.new_tick10ms - ctd.old_tick10ms) >= 500)  // 5000msec = 500*10msec
            {
                if(sys_data.diag > 0) uprintf("\nSBE37 not responding in 5sec after ts\n");
                sprintf((char *)&ctd.buf[0], "SBE37 not responding in 5sec after ts");
                ctd_close();  // Close CTD, power off
                wait_consoleTx();
                ctd.type = 0;
                ctd.state = -1;
                return(0);
            }
            ctd.state = 7;
            return(7);

        case 8:
            for(indx=0; indx<3000; indx++)  //300msec
            {
                ROM_SysCtlDelay(MICROSECOND * 100); // pace the loop
                //  23.5074,  0.00006,   -0.157,   0.0113, 03 May 2021, 12:34:29
                if( ctd_rxBytesAvail() )      // bytes from CTD
                {
                    inChar = ctd_getc();
                    //if(debugFlag == 1) uprintf( "st7[%02x] %c ", inChar,inChar );   // DEBUG

                    if(inChar == COMMA)  //',')   // COMMA substituted with TAB (0x09)
                    {
                        inChar = TAB;
                    }
                    if(inChar == 0x0d)
                    {
                        inChar = 0;     // CR-LF, terminate at CR char
                    }
                    if((inChar == '<') || (inChar == 0x0a))  //<Executed/>
                    {
                        // ctd.buf contains 0 terminated sample string, response to ts
                        //if(debugFlag == 1) uprintf("st7: ctd.buf is %s\n", ctd.buf);  //DEBUG

                        ctd_close();  // Close CTD, power off
                        ctd_microCat_parseData();

                        wait_consoleTx();

                        ctd.type = TYPE_SBE37_MICROCAT;       // type = Microcat = 1
                        if(ctd.type != sys_data.data_cfg[CFG_CTD])
                        {
                            uprintf("\nERROR: CTD type %u, does not match data config type %u. Correcting to %u, SBE37 MicroCat\n", ctd.type, sys_data.data_cfg[CFG_CTD], ctd.type);
                            sys_data.data_cfg[CFG_CTD] = ctd.type;
                            // TODO: should we call storeSysDataVariables() or wait til sleep does a store  27 Jul 2021
                        }
                        ctd.state = 0;
                        return(0);  // Success, driver is done

                    }
                    ctd.buf[ctd.bufIndx] = inChar;

                    ctd.bufIndx++;
                    if(ctd.bufIndx >= CTD_BUFFER_SIZE)
                    {
                        ctd.bufIndx = CTD_BUFFER_SIZE-1;
                        if(sys_data.diag > 0) uprintf("\nST7: error in ctd driver bufIndx exceeds buf size, ctd.c\n");
                        sprintf((char *)&ctd.buf[0], "ST7: error in ctd driver bufIndx exceeds buf size, ctd.c");
                        wait_consoleTx();
                        ctd_close();  // Close CTD, power off

                        ctd.type = 0;
                        ctd.state = -1;
                        return(0);
                    }

                }

            }// indx

            ctd_close();  // Close CTD, power off
            wait_consoleTx();
            ctd.type = 0;
            ctd.state = 0;
            return(0);

        default:
            ctd.type = 0;
            ctd.state = -1;
            return(0);


    }

    return(0);
}



uint32_t wait_ctdRx(uint32_t maxWait_10msTick)
{
    uint32_t start_10msTick;
    //uint32_t end_10msTick;
    uint32_t now_10msTick;

    // maxWaitMsec = 0, wait indefinitely
    // return wait in msec
    start_10msTick = Timer_10ms(false);
    while(1)
    {
        if( ctd_rxBytesAvail() )
        {
            now_10msTick = Timer_10ms(false);
            return(now_10msTick-start_10msTick);
        }
        ROM_SysCtlDelay(MICROSECOND*500);       // throttle the loop
        now_10msTick = Timer_10ms(false);
        if(maxWait_10msTick > 0)
        {
            if((now_10msTick - start_10msTick) >= maxWait_10msTick)
            {
                return(maxWait_10msTick);
            }
        }
        if(start_10msTick > now_10msTick)
        {
            uprintf("DEBUG: wait_ctdRx 10msTick timer rolled over\n");
            return(0);
        }
    }

}

uint32_t ctd_qa_test(void)
{
    //uint32_t timeout;
    //uint32_t ticks, tickDelta;

    int ctdState;

    //start the ctd driver by passing 1, when complete, the statemachine returns 0
    ctdState = 1;
    ctdState = ctd_stateMachine(ctdState);     //pass in 1 to start the state machine, hereafter pass retVal

    //tickDelta = Timer_1ms(false) - tickDelta;
    //ticks = (Timer_1ms(false) - tickStart);
    //if(sys_data.app_cfg[APPCFG_SAMPLING_DIAG] == 1) uprintf("\nCondo  St8Ma = %5u,   %5u", tickDelta, ticks);
    //tickDelta = ticks;

    while(1)
    {
        if(ctdState == 0)            // makes sure ctd statemachine is finished
        {
            if(ctd.state == -1)
                return(0);      // fail
            else
                return(1);      // success

        }
        ctdState = ctd_stateMachine(ctdState);

    }

    return(0);      // fail (never gets here)
}


void ctd_aanderaa_serial_analyzer(void)
{
    //int nextState = 0;
    //unsigned int indx;
    unsigned int tick1, tick2;
    unsigned char inChar;

    uprintf("ctd serial analyzer, bytes and times  Ctrl-X to quit\n");
#ifdef NOCODE
    set passkey(1)
    set mode(smart sensor terminal)
    set enable polled mode(yes)
    save

    To set the output mode:
    do sample
    set passkey(1)
    set enable text(no)
    save
    do sample

    // ctrl-q and ctrl-s will be sent from optode and conductivity, this can be removed by changing flow control to none
    set passkey(1000)
    #
    set Flow Control(none)
    #
    save

    get flow control
    Flow Control    4831    856     None
#endif

    while(1)
    {
        uprintf("open\n");
        ctd_open();   // power on ctd Vbat supply
        ctd.old_tick10ms = Timer_10ms(false);
        while(1)
        {
        // look for !, then send do_sample and crlf
            if( ctd_rxBytesAvail() )
            {
               // [0x11]  time = 220 msec
               //% [0x25]  time = 0 msec
               //! [0x21]  time = 10 msec
               // [0x11]  time = 940 msec


#ifdef NOCODE
                ctd serial analyzer, bytes and times
                open
                RX:  [0x11]  time = 230 msec
                RX: % [0x25]  time = 0 msec
                TX: crlf
                RX: ! [0x21]  time = 10 msec
                TX: crlf do sample crlf
                RX:  [0x11]  time = 940 msec
                RX:  [0x13]  time = 0 msec
                RX:  [0x11]  time = 940 msec
                RX: 4 [0x34]  time = 0 msec
                RX: 8 [0x38]  time = 0 msec
                RX: 3 [0x33]  time = 0 msec
                RX: 1 [0x31]  time = 10 msec

#endif

                ctd.new_tick10ms = Timer_10ms(false);
                inChar = ctd_getc();
                uprintf("RX: %c [0x%02x] ", inChar, inChar );
                tick1 = (ctd.new_tick10ms - ctd.old_tick10ms)*10;
                uprintf(" time = %u msec\n", tick1);
                ctd.old_tick10ms = Timer_10ms(false);

                if(inChar == '%')
                {
                    uprintf("TX: crlf \n");
                    ctd_putc(0x0d);  // CR=13
                    ctd_putc(0x0a);  // LF=10

                }
                if(inChar == '!')
                {
                    uprintf("TX: crlf do sample crlf \n");
                    ctd_putc(0x0d);  // CR=13
                    ctd_putc(0x0a);  // LF=10
                    ctd_write("do sample\r\n",12 );
                }
            }
            if(UARTRxBytesAvail())
            {
                inChar = UARTgetc();


                if(inChar == 24) // ctrl-x to exit loop
                {
                    ctd_close();
                    ms_delay(500);
                    break;
                }


            }

        } // while(1)

        if(UARTRxBytesAvail())
        {
            inChar = UARTgetc();

            if(inChar == 24) // ctrl-x to exit loop
                break;

        }

    }


}


void ctd_microcat_serial_analyzer(void)
{
    //int nextState = 0;
    //unsigned int indx;
    unsigned int tick1, tick2;
    unsigned char inChar;
    uint32_t essFlg = 0;

    uprintf("ctd microcat serial analyzer, bytes and times  Ctrl-X to quit\n");

    while(1)
    {
        uprintf("open\n");
        ctd_open();   // power on ctd Vbat supply
        ctd.old_tick10ms = Timer_10ms(false);
        while(1)
        {
        // look for !, then send do_sample and crlf
            if( ctd_rxBytesAvail() )
            {


                ctd.new_tick10ms = Timer_10ms(false);
                inChar = ctd_getc();
                uprintf("RX: %c [0x%02x] ", inChar, inChar );
                tick1 = (ctd.new_tick10ms - ctd.old_tick10ms)*10;
                uprintf(" time = %u msec\n", tick1);
                ctd.old_tick10ms = Timer_10ms(false);

                if(inChar == 'S')
                {
                    essFlg = 1;
                    uprintf("TX: crlf \n");
                    ctd_putc(0x0d);  // CR=13
                    ctd_putc(0x0a);  // LF=10

                }
                if((inChar == 0x0a) && (essFlg == 1))
                {
                    essFlg = 0;
                    uprintf("TX: ts cr \n");
                    ctd_putc('t');
                    ctd_putc('s');
                    ctd_putc(0x0d);  // CR=13
                    //ctd_putc(0x0a);  // LF=10
                }
            }
            if(UARTRxBytesAvail())
            {
                inChar = UARTgetc();


                if(inChar == 24) // ctrl-x to exit loop
                {
                    ctd_close();
                    ms_delay(500);
                    break;
                }


            }

        } // while(1)

        if(UARTRxBytesAvail())
        {
            inChar = UARTgetc();

            if(inChar == 24) // ctrl-x to exit loop
                break;

        }

    }


}


void ctd_print_buf(void)
{
    uprintf("%s", ctd.buf);
}





#ifdef MOVDEDTOINTDRIVER
void ctd_Aand5860_comm_test(void)
{
    unsigned char inChar;


    // Tested with Aanderaa Oxygen 5730 https://www.aanderaa.com/media/pdfs/d419_aanderaa_oxygen_sensor_5730.pdf
    uprintf("\nNote: smart sensor mode, disable data descriptor text, set flow control to none \n\n");
    uprintf("\n\nCommand procedure to setup Optode for numeric output:\n\n");
    uprintf("set passkey(1)\n");
    uprintf("set mode(smart sensor terminal)\n");
    uprintf("set enable polled mode(yes)\n");
    uprintf("save\n");
    uprintf("\n");
    uprintf("set passkey(1)\n");
    uprintf("set enable text(no)\n");
    uprintf("save\n");
    uprintf("\n");
    uprintf("set passkey(1000)\n");       // response: #
    uprintf("set flow control(none)\n");  // response: #
    uprintf("save\n");
    uprintf("\n");

    uprintf("do sample\n");
    uprintf("\nThis should return a sample: \t4831\t856\t286.196\t94.284\t16.728\t28.200\t30.491\t38.573\t8.082\t621.1\t720.0\t300.0\t\n\n");
    //uprintf("                               \t5860\t29\t-0.003\t16.892\t0.009\t998.802\t1472.435\t\n");
    uprintf("\n\n*Press CTRL-X to stop communicating with the Optode.*\n\n");

    //set up the ctd
    ctd_open();               // power on ctd
    ROM_SysCtlDelay(500);       //500 is a guess
    //Optode_UARTwrite("do sample\r\n",12 );
    //ROM_SysCtlDelay(MILLISECOND*2000);

    while(1)
    {
        //if Optode sent anything, print it out on UART1 (the desktop)
        if( ctd_rxBytesAvail() )      // Optode
        {
            uprintf( "%c", ctd_getc() );
        }

        //if user types anything, send it to the Optode--exit on CTRL-X
        if(UARTRxBytesAvail())
        {
            inChar = UARTgetc();

            if(inChar == 13)     // If user hit carriage return, add a line feed
            {
                ctd_putc(13);  // CR
                ctd_putc(10);     // LF
            }
            else if(inChar == 24)
            {
                break;
            }
            else
            {
                ctd_putc(inChar);
            }
        }
    }

    ctd_close();  // Close up the Optode
}

#endif


//------------------------------------------------------------------------



//*****************************************************************************
//
// This global controls whether or not we are echoing characters back to the
// transmitter.  By default, echo is enabled but if using this module as a
// convenient method of implementing a buffered serial interface over which
// you will be running an application protocol, you are likely to want to
// disable echo by calling UARTEchoSet(false).
//
//*****************************************************************************
static bool g_bDisableEcho;

//*****************************************************************************
//
// Output ring buffer.  Buffer is full if g_ui32UARTTxReadIndex is one ahead of
// g_ui32UARTTxWriteIndex.  Buffer is empty if the two indices are the same.
//
//*****************************************************************************
// static is used to set scope to this file (uart drivers have same var names scoped to file)
static unsigned char g_pcUARTTxBuffer[CTD_UART_TX_BUFFER_SIZE];
static volatile uint32_t g_ui32UARTTxWriteIndex = 0;
static volatile uint32_t g_ui32UARTTxReadIndex = 0;

//*****************************************************************************
//
// Input ring buffer.  Buffer is full if g_ui32UARTTxReadIndex is one ahead of
// g_ui32UARTTxWriteIndex.  Buffer is empty if the two indices are the same.
//
//*****************************************************************************
static unsigned char g_pcUARTRxBuffer[CTD_UART_RX_BUFFER_SIZE];
static volatile uint32_t g_ui32UARTRxWriteIndex = 0;
static volatile uint32_t g_ui32UARTRxReadIndex = 0;

//*****************************************************************************
//
// Macros to determine number of free and used bytes in the transmit buffer.
//
//*****************************************************************************
#define TX_BUFFER_USED          (GetBufferCount(&g_ui32UARTTxReadIndex,  \
                                                &g_ui32UARTTxWriteIndex, \
                                                CTD_UART_TX_BUFFER_SIZE))
#define TX_BUFFER_FREE          (CTD_UART_TX_BUFFER_SIZE - TX_BUFFER_USED)
#define TX_BUFFER_EMPTY         (IsBufferEmpty(&g_ui32UARTTxReadIndex,   \
                                               &g_ui32UARTTxWriteIndex))
#define TX_BUFFER_FULL          (IsBufferFull(&g_ui32UARTTxReadIndex,  \
                                              &g_ui32UARTTxWriteIndex, \
                                              CTD_UART_TX_BUFFER_SIZE))
#define ADVANCE_TX_BUFFER_INDEX(Index) \
                                (Index) = ((Index) + 1) % CTD_UART_TX_BUFFER_SIZE

//*****************************************************************************
//
// Macros to determine number of free and used bytes in the receive buffer.
//
//*****************************************************************************
#define RX_BUFFER_USED          (GetBufferCount(&g_ui32UARTRxReadIndex,  \
                                                &g_ui32UARTRxWriteIndex, \
                                                CTD_UART_RX_BUFFER_SIZE))
#define RX_BUFFER_FREE          (CTD_UART_RX_BUFFER_SIZE - RX_BUFFER_USED)
#define RX_BUFFER_EMPTY         (IsBufferEmpty(&g_ui32UARTRxReadIndex,   \
                                               &g_ui32UARTRxWriteIndex))
#define RX_BUFFER_FULL          (IsBufferFull(&g_ui32UARTRxReadIndex,  \
                                              &g_ui32UARTRxWriteIndex, \
                                              CTD_UART_RX_BUFFER_SIZE))
#define ADVANCE_RX_BUFFER_INDEX(Index) \
                                (Index) = ((Index) + 1) % CTD_UART_RX_BUFFER_SIZE

//*****************************************************************************
//
// The base address of the chosen UART.
//
//*****************************************************************************
static uint32_t g_ui32Base = 0;

//*****************************************************************************
//
// The list of possible base addresses for the console UART.
//
//*****************************************************************************
static const uint32_t g_ui32UARTBase[6] =
{
    UART0_BASE, UART1_BASE, UART2_BASE, UART3_BASE, UART4_BASE, UART5_BASE
};

//*****************************************************************************
//
// The list of possible interrupts for the console UART.
//
//*****************************************************************************
static const uint32_t g_ui32UARTInt[6] =
{
    INT_UART0, INT_UART1, INT_UART2, INT_UART3, INT_UART4, INT_UART5
};

//*****************************************************************************
//
// The port number in use.
//
//*****************************************************************************
static uint32_t g_ui32PortNum;

//*****************************************************************************
//
// The list of UART peripherals.
//
//*****************************************************************************
static const uint32_t g_ui32UARTPeriph[6] =
{
    SYSCTL_PERIPH_UART0, SYSCTL_PERIPH_UART1, SYSCTL_PERIPH_UART2, SYSCTL_PERIPH_UART3, SYSCTL_PERIPH_UART4, SYSCTL_PERIPH_UART5
};

//------------------------------------------------------------------------



//*****************************************************************************
//
//! Determines whether the ring buffer whose pointers and size are provided
//! is full or not.
//!
//! \param pui32Read points to the read index for the buffer.
//! \param pui32Write points to the write index for the buffer.
//! \param ui32Size is the size of the buffer in bytes.
//!
//! This function is used to determine whether or not a given ring buffer is
//! full.  The structure of the code is specifically to ensure that we do not
//! see warnings from the compiler related to the order of volatile accesses
//! being undefined.
//!
//! \return Returns \b true if the buffer is full or \b false otherwise.
//
//*****************************************************************************
static bool
IsBufferFull(volatile uint32_t *pui32Read,
             volatile uint32_t *pui32Write, uint32_t ui32Size)
{
    uint32_t ui32Write;
    uint32_t ui32Read;

    ui32Write = *pui32Write;
    ui32Read = *pui32Read;

    return((((ui32Write + 1) % ui32Size) == ui32Read) ? true : false);
}

//*****************************************************************************
//
//! Determines whether the ring buffer whose pointers and size are provided
//! is empty or not.
//!
//! \param pui32Read points to the read index for the buffer.
//! \param pui32Write points to the write index for the buffer.
//!
//! This function is used to determine whether or not a given ring buffer is
//! empty.  The structure of the code is specifically to ensure that we do not
//! see warnings from the compiler related to the order of volatile accesses
//! being undefined.
//!
//! \return Returns \b true if the buffer is empty or \b false otherwise.
//
//*****************************************************************************
static bool
IsBufferEmpty(volatile uint32_t *pui32Read,
              volatile uint32_t *pui32Write)
{
    uint32_t ui32Write;
    uint32_t ui32Read;

    ui32Write = *pui32Write;
    ui32Read = *pui32Read;

    return((ui32Write == ui32Read) ? true : false);
}

//*****************************************************************************
//
//! Determines the number of bytes of data contained in a ring buffer.
//!
//! \param pui32Read points to the read index for the buffer.
//! \param pui32Write points to the write index for the buffer.
//! \param ui32Size is the size of the buffer in bytes.
//!
//! This function is used to determine how many bytes of data a given ring
//! buffer currently contains.  The structure of the code is specifically to
//! ensure that we do not see warnings from the compiler related to the order
//! of volatile accesses being undefined.
//!
//! \return Returns the number of bytes of data currently in the buffer.
//
//*****************************************************************************
static uint32_t
GetBufferCount(volatile uint32_t *pui32Read,
               volatile uint32_t *pui32Write, uint32_t ui32Size)
{
    uint32_t ui32Write;
    uint32_t ui32Read;

    ui32Write = *pui32Write;
    ui32Read = *pui32Read;

    return((ui32Write >= ui32Read) ? (ui32Write - ui32Read) :
           (ui32Size - (ui32Read - ui32Write)));
}

//*****************************************************************************
//
// Take as many bytes from the transmit buffer as we have space for and move
// them into the UART transmit FIFO.
//
//*****************************************************************************
static void
UARTPrimeTransmit(uint32_t ui32Base)
{
    //
    // Do we have any data to transmit?
    //
    if(!TX_BUFFER_EMPTY)
    {
        //
        // Disable the UART interrupt.  If we don't do this there is a race
        // condition which can cause the read index to be corrupted.
        //
        MAP_IntDisable(g_ui32UARTInt[g_ui32PortNum]);

        //
        // Yes - take some characters out of the transmit buffer and feed
        // them to the UART transmit FIFO.
        //
        while(MAP_UARTSpaceAvail(ui32Base) && !TX_BUFFER_EMPTY)
        {
            MAP_UARTCharPutNonBlocking(ui32Base,
                                      g_pcUARTTxBuffer[g_ui32UARTTxReadIndex]);
            ADVANCE_TX_BUFFER_INDEX(g_ui32UARTTxReadIndex);
        }

        //
        // Reenable the UART interrupt.
        //
        MAP_IntEnable(g_ui32UARTInt[g_ui32PortNum]);
    }
}

//*****************************************************************************
//
//! Configures the MicroCAT UART console.
//!
//! \param ui32PortNum is the number of UART port to use for the serial console
//! (0-2)
//! \param ui32Baud is the bit rate that the UART is to be configured to use.
//! \param ui32SrcClock is the frequency of the source clock for the UART
//! module.
//!
//! This function will configure the specified serial port to be used as a
//! serial console.  The serial parameters are set to the baud rate
//! specified by the \e ui32Baud parameter and use 8 bit, no parity, and 1 stop
//! bit.
//!
//! This function must be called prior to using any of the other UART console
//! functions: uprintf() or UARTgets().  This function assumes that the
//! caller has previously configured the relevant UART pins for operation as a
//! UART rather than as GPIOs.
//!
//! \return None.
//
//*****************************************************************************
void
ctd_config(uint32_t ui32PortNum, uint32_t ui32Baud, uint32_t ui32SrcClock)
{
    //
    // Check to make sure the UART peripheral is present.
    //
    if(!MAP_SysCtlPeripheralPresent(g_ui32UARTPeriph[ui32PortNum]))
    {
        return;
    }

    //
    // Select the base address of the UART.
    //
    g_ui32Base = g_ui32UARTBase[ui32PortNum];

    //
    // Enable the UART peripheral for use.
    //
    MAP_SysCtlPeripheralEnable(g_ui32UARTPeriph[ui32PortNum]);

    //
    // Configure the UART for Baud, n, 8, 1
    //
    MAP_UARTConfigSetExpClk(g_ui32Base, ui32SrcClock, ui32Baud,
                            (UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_ONE |
                             UART_CONFIG_WLEN_8));

    //
    // Set the UART to interrupt whenever the TX FIFO is almost empty or
    // when any character is received.
    //
    MAP_UARTFIFOLevelSet(g_ui32Base, UART_FIFO_TX1_8, UART_FIFO_RX1_8);

    //
    // Flush both the buffers.
    //
    ctd_flushRx();
    ctd_flushTx(true);

    //
    // Remember which interrupt we are dealing with.
    //
    g_ui32PortNum = ui32PortNum;

    //
    // We are configured for buffered output so enable the master interrupt
    // for this UART and the receive interrupts.  We don't actually enable the
    // transmit interrupt in the UART itself until some data has been placed
    // in the transmit buffer.
    //
    MAP_UARTIntDisable(g_ui32Base, 0xFFFFFFFF);
    MAP_UARTIntEnable(g_ui32Base, UART_INT_RX | UART_INT_RT);
    MAP_IntEnable(g_ui32UARTInt[ui32PortNum]);

    //
    // Enable the UART operation.
    //
    MAP_UARTEnable(g_ui32Base);
}

//*****************************************************************************
//
//! Writes a string of characters to the UART output.
//!
//! \param pcBuf points to a buffer containing the string to transmit.
//! \param ui32Len is the length of the string to transmit.
//!
//! This function will transmit the string to the UART output.  The number of
//! characters transmitted is determined by the \e ui32Len parameter.  This
//! function does no interpretation or translation of any characters.  Since
//! the output is sent to a UART, any LF (/n) characters encountered will be
//! replaced with a CRLF pair.
//!
//! Besides using the \e ui32Len parameter to stop transmitting the string, if
//! a null character (0) is encountered, then no more characters will be
//! transmitted and the function will return.
//!
//! In non-buffered mode, this function is blocking and will not return until
//! all the characters have been written to the output FIFO.  In buffered mode,
//! the characters are written to the UART transmit buffer and the call returns
//! immediately.  If insufficient space remains in the transmit buffer,
//! additional characters are discarded.
//!
//! \return Returns the count of characters written.
//
//*****************************************************************************
int
ctd_write(const char *pcBuf, uint32_t ui32Len)
{
    unsigned int uIdx;

    //
    // Send the characters
    //
    for(uIdx = 0; uIdx < ui32Len; uIdx++)
    {
        //
        // If the character to the UART is \n, then add a \r before it so that
        // \n is translated to \n\r in the output.
        //
        if(pcBuf[uIdx] == '\n')
        {
            if(!TX_BUFFER_FULL)
            {
                g_pcUARTTxBuffer[g_ui32UARTTxWriteIndex] = '\r';
                ADVANCE_TX_BUFFER_INDEX(g_ui32UARTTxWriteIndex);
            }
            else
            {
                //
                // Buffer is full - discard remaining characters and return.
                //
                break;
            }
        }

        //
        // Send the character to the UART output.
        //
        if(!TX_BUFFER_FULL)
        {
            g_pcUARTTxBuffer[g_ui32UARTTxWriteIndex] = pcBuf[uIdx];
            ADVANCE_TX_BUFFER_INDEX(g_ui32UARTTxWriteIndex);
        }
        else
        {
            //
            // Buffer is full - discard remaining characters and return.
            //
            break;
        }
    }

    //
    // If we have anything in the buffer, make sure that the UART is set
    // up to transmit it.
    //
    if(!TX_BUFFER_EMPTY)
    {
        UARTPrimeTransmit(g_ui32Base);
        MAP_UARTIntEnable(g_ui32Base, UART_INT_TX);
    }

    //
    // Return the number of characters written.
    //
    return(uIdx);
}

/*****************************************************************************
 * ctd_putc()
 ******************************************************************************/

int ctd_putc(const char c)
{

    // Send the character to the UART output.
	if(!TX_BUFFER_FULL)
	{
		g_pcUARTTxBuffer[g_ui32UARTTxWriteIndex] = c;
		ADVANCE_TX_BUFFER_INDEX(g_ui32UARTTxWriteIndex);
	}
	else return 0;	// Buffer full. No character written

	// Flush the TX buffer
	if(!TX_BUFFER_EMPTY)
    {
        UARTPrimeTransmit(g_ui32Base);
        MAP_UARTIntEnable(g_ui32Base, UART_INT_TX);
    }

    return 1; // Success
}

//*****************************************************************************
//
//! A simple UART based get string function, with some line processing.
//!
//! \param pcBuf points to a buffer for the incoming string from the UART.
//! \param ui32Len is the length of the buffer for storage of the string,
//! including the trailing 0.
//!
//! This function will receive a string from the UART input and store the
//! characters in the buffer pointed to by \e pcBuf.  The characters will
//! continue to be stored until a termination character is received.  The
//! termination characters are CR, LF, or ESC.  A CRLF pair is treated as a
//! single termination character.  The termination characters are not stored in
//! the string.  The string will be terminated with a 0 and the function will
//! return.
//!
//! In both buffered and unbuffered modes, this function will block until
//! a termination character is received.  If non-blocking operation is required
//! in buffered mode, a call to UARTPeek() may be made to determine whether
//! a termination character already exists in the receive buffer prior to
//! calling UARTgets().
//!
//! Since the string will be null terminated, the user must ensure that the
//! buffer is sized to allow for the additional null character.
//!
//! \return Returns the count of characters that were stored, not including
//! the trailing 0.
//
//*****************************************************************************
int
ctd_gets(char *pcBuf, uint32_t ui32Len)
{
    uint32_t ui32Count = 0;
    int8_t cChar;
    //int i;

    //
    // Adjust the length back by 1 to leave space for the trailing
    // null terminator.
    //
    ui32Len--;

    //
    // Process characters until a newline is received.
    //
    while(1)
    {
        //
        // Read the next character from the receive buffer.
        //
        if(!RX_BUFFER_EMPTY)
        {
            cChar = g_pcUARTRxBuffer[g_ui32UARTRxReadIndex];
            ADVANCE_RX_BUFFER_INDEX(g_ui32UARTRxReadIndex);

            //
            // See if a newline or escape character was received.
            //
            if((cChar == '\r') || (cChar == '\n') || (cChar == 0x1b))
            {
                //
                // Stop processing the input and end the line.
                //
                break;
            }

            //
            // Process the received character as long as we are not at the end
            // of the buffer.  If the end of the buffer has been reached then
            // all additional characters are ignored until a newline is
            // received.
            //
            if(ui32Count < ui32Len)
            {
                //
                // Store the character in the caller supplied buffer.
                //
                pcBuf[ui32Count] = cChar;

                //
                // Increment the count of characters received.
                //
                ui32Count++;
            }
        }
    }

    //
    // Add a null termination to the string.
    //
    pcBuf[ui32Count] = 0;

    //
    // Return the count of int8_ts in the buffer, not counting the trailing 0.
    //
    return(ui32Count);
}

//*****************************************************************************
//
//! Read a single character from the UART, blocking if necessary.
//!
//! This function will receive a single character from the UART and store it at
//! the supplied address.
//!
//! In both buffered and unbuffered modes, this function will block until a
//! character is received.  If non-blocking operation is required in buffered
//! mode, a call to UARTRxAvail() may be made to determine whether any
//! characters are currently available for reading.
//!
//! \return Returns the character read.
//
//*****************************************************************************
unsigned char
ctd_getc(void)
{
    unsigned char cChar;

    //
    // Wait for a character to be received.
    //
    while(RX_BUFFER_EMPTY)
    {
        //
        // Block waiting for a character to be received (if the buffer is
        // currently empty).
        //
    }

    //
    // Read a character from the buffer.
    //
    cChar = g_pcUARTRxBuffer[g_ui32UARTRxReadIndex];
    ADVANCE_RX_BUFFER_INDEX(g_ui32UARTRxReadIndex);

    //
    // Return the character to the caller.
    //
    return(cChar);
}

//*****************************************************************************
//
//! Returns the number of bytes available in the receive buffer.
//!
//! This function, available only when the module is built to operate in
//! buffered mode using \b UART_BUFFERED, may be used to determine the number
//! of bytes of data currently available in the receive buffer.
//!
//! \return Returns the number of available bytes.
//
//*****************************************************************************
#if defined(UART_BUFFERED) || defined(DOXYGEN)
int
ctd_rxBytesAvail(void)
{
    return(RX_BUFFER_USED);
}
#endif

//*****************************************************************************
//
//! Returns the number of bytes free in the transmit buffer.
//!
//! This function, available only when the module is built to operate in
//! buffered mode using \b UART_BUFFERED, may be used to determine the amount
//! of space currently available in the transmit buffer.
//!
//! \return Returns the number of free bytes.
//
//*****************************************************************************
int
ctd_txBytesFree(void)
{
    return(TX_BUFFER_FREE);
}

//*****************************************************************************
//
//! Looks ahead in the receive buffer for a particular character.
//!
//! \param ucChar is the character that is to be searched for.
//!
//! This function, available only when the module is built to operate in
//! buffered mode using \b UART_BUFFERED, may be used to look ahead in the
//! receive buffer for a particular character and report its position if found.
//! It is typically used to determine whether a complete line of user input is
//! available, in which case ucChar should be set to CR ('\\r') which is used
//! as the line end marker in the receive buffer.
//!
//! \return Returns -1 to indicate that the requested character does not exist
//! in the receive buffer.  Returns a non-negative number if the character was
//! found in which case the value represents the position of the first instance
//! of \e ucChar relative to the receive buffer read pointer.
//
//*****************************************************************************
int
ctd_peek(unsigned char ucChar)
{
    int iCount;
    int iAvail;
    uint32_t ui32ReadIndex;

    //
    // How many characters are there in the receive buffer?
    //
    iAvail = (int)RX_BUFFER_USED;
    ui32ReadIndex = g_ui32UARTRxReadIndex;

    //
    // Check all the unread characters looking for the one passed.
    //
    for(iCount = 0; iCount < iAvail; iCount++)
    {
        if(g_pcUARTRxBuffer[ui32ReadIndex] == ucChar)
        {
            //
            // We found it so return the index
            //
            return(iCount);
        }
        else
        {
            //
            // This one didn't match so move on to the next character.
            //
            ADVANCE_RX_BUFFER_INDEX(ui32ReadIndex);
        }
    }

    //
    // If we drop out of the loop, we didn't find the character in the receive
    // buffer.
    //
    return(-1);
}

//*****************************************************************************
//
//! Flushes the receive buffer.
//!
//! This function, available only when the module is built to operate in
//! buffered mode using \b UART_BUFFERED, may be used to discard any data
//! received from the UART but not yet read using UARTgets().
//!
//! \return None.
//
//*****************************************************************************
void
ctd_flushRx(void)
{
    uint32_t ui32Int;

    //
    // Temporarily turn off interrupts.
    //
    ui32Int = MAP_IntMasterDisable();

    //
    // Flush the receive buffer.
    //
    g_ui32UARTRxReadIndex = 0;
    g_ui32UARTRxWriteIndex = 0;

    //
    // If interrupts were enabled when we turned them off, turn them
    // back on again.
    //
    if(!ui32Int)
    {
        MAP_IntMasterEnable();
    }
}

//*****************************************************************************
//
//! Flushes the transmit buffer.
//!
//! \param bDiscard indicates whether any remaining data in the buffer should
//! be discarded (\b true) or transmitted (\b false).
//!
//! This function, available only when the module is built to operate in
//! buffered mode using \b UART_BUFFERED, may be used to flush the transmit
//! buffer, either discarding or transmitting any data received via calls to
//! uprintf() that is waiting to be transmitted.  On return, the transmit
//! buffer will be empty.
//!
//! \return None.
//
//*****************************************************************************
void
ctd_flushTx(bool bDiscard)
{
    uint32_t ui32Int;

    //
    // Should the remaining data be discarded or transmitted?
    //
    if(bDiscard)
    {
        //
        // The remaining data should be discarded, so temporarily turn off
        // interrupts.
        //
        ui32Int = MAP_IntMasterDisable();

        //
        // Flush the transmit buffer.
        //
        g_ui32UARTTxReadIndex = 0;
        g_ui32UARTTxWriteIndex = 0;

        //
        // If interrupts were enabled when we turned them off, turn them
        // back on again.
        //
        if(!ui32Int)
        {
            MAP_IntMasterEnable();
        }
    }
    else
    {
        //
        // Wait for all remaining data to be transmitted before returning.
        //
        while(!TX_BUFFER_EMPTY)
        {
        }
    }
}

//*****************************************************************************
//
//! Enables or disables echoing of received characters to the transmitter.
//!
//! \param bEnable must be set to \b true to enable echo or \b false to
//! disable it.
//!
//! This function, available only when the module is built to operate in
//! buffered mode using \b UART_BUFFERED, may be used to control whether or not
//! received characters are automatically echoed back to the transmitter.  By
//! default, echo is enabled and this is typically the desired behavior if
//! the module is being used to support a serial command line.  In applications
//! where this module is being used to provide a convenient, buffered serial
//! interface over which application-specific binary protocols are being run,
//! however, echo may be undesirable and this function can be used to disable
//! it.
//!
//! \return None.
//
//*****************************************************************************
void
ctd_echoSet(bool bEnable)
{
    g_bDisableEcho = !bEnable;
}

//*****************************************************************************
//
//! Handles UART interrupts.
//!
//! This function handles interrupts from the UART.  It will copy data from the
//! transmit buffer to the UART transmit FIFO if space is available, and it
//! will copy data from the UART receive FIFO to the receive buffer if data is
//! available.
//!
//! \return None.
//
//*****************************************************************************
void
ctd_IntHandler(void)
{
    uint32_t ui32Ints;
    int8_t cChar;
    int32_t i32Char;
    static bool bLastWasCR = false;

    //
    // Get and clear the current interrupt source(s)
    //
    ui32Ints = MAP_UARTIntStatus(g_ui32Base, true);
    MAP_UARTIntClear(g_ui32Base, ui32Ints);

    //
    // Are we being interrupted because the TX FIFO has space available?
    //
    if(ui32Ints & UART_INT_TX)
    {
        //
        // Move as many bytes as we can into the transmit FIFO.
        //
        UARTPrimeTransmit(g_ui32Base);

        //
        // If the output buffer is empty, turn off the transmit interrupt.
        //
        if(TX_BUFFER_EMPTY)
        {
            MAP_UARTIntDisable(g_ui32Base, UART_INT_TX);
        }
    }

    //
    // Are we being interrupted due to a received character?
    //
    if(ui32Ints & (UART_INT_RX | UART_INT_RT))
    {
        //
        // Get all the available characters from the UART.
        //
        while(MAP_UARTCharsAvail(g_ui32Base))
        {
            //
            // Read a character
            //
            i32Char = MAP_UARTCharGetNonBlocking(g_ui32Base);
            cChar = (unsigned char)(i32Char & 0xFF);

            //
            // If echo is disabled, we skip the various text filtering
            // operations that would typically be required when supporting a
            // command line.
            //
            if(!g_bDisableEcho)
            {
                //
                // Handle backspace by erasing the last character in the
                // buffer.
                //
                if(cChar == '\b')
                {
                    //
                    // If there are any characters already in the buffer, then
                    // delete the last.
                    //
                    if(!RX_BUFFER_EMPTY)
                    {
                        //
                        // Rub out the previous character on the users
                        // terminal.
                        //
                    	ctd_write("\b \b", 3);

                        //
                        // Decrement the number of characters in the buffer.
                        //
                        if(g_ui32UARTRxWriteIndex == 0)
                        {
                            g_ui32UARTRxWriteIndex = UART_RX_BUFFER_SIZE - 1;
                        }
                        else
                        {
                            g_ui32UARTRxWriteIndex--;
                        }
                    }

                    //
                    // Skip ahead to read the next character.
                    //
                    continue;
                }

                //
                // If this character is LF and last was CR, then just gobble up
                // the character since we already echoed the previous CR and we
                // don't want to store 2 characters in the buffer if we don't
                // need to.
                //
                if((cChar == '\n') && bLastWasCR)
                {
                    bLastWasCR = false;
                    continue;
                }

                //
                // See if a newline or escape character was received.
                //
                if((cChar == '\r') || (cChar == '\n') || (cChar == 0x1b))
                {
                    //
                    // If the character is a CR, then it may be followed by an
                    // LF which should be paired with the CR.  So remember that
                    // a CR was received.
                    //
                    if(cChar == '\r')
                    {
                        bLastWasCR = 1;
                    }

                    //
                    // Regardless of the line termination character received,
                    // put a CR in the receive buffer as a marker telling
                    // UARTgets() where the line ends.  We also send an
                    // additional LF to ensure that the local terminal echo
                    // receives both CR and LF.
                    //
                    cChar = '\r';
                    ctd_write("\n", 1);
                }
            }

            //
            // If there is space in the receive buffer, put the character
            // there, otherwise throw it away.
            //
            if(!RX_BUFFER_FULL)
            {
                //
                // Store the new character in the receive buffer
                //
                g_pcUARTRxBuffer[g_ui32UARTRxWriteIndex] =
                    (unsigned char)(i32Char & 0xFF);
                ADVANCE_RX_BUFFER_INDEX(g_ui32UARTRxWriteIndex);

                //
                // If echo is enabled, write the character to the transmit
                // buffer so that the user gets some immediate feedback.
                //
                if(!g_bDisableEcho)
                {
                	ctd_write((const char *)&cChar, 1);
                }
            }
        }

        //
        // If we wrote anything to the transmit buffer, make sure it actually
        // gets transmitted.
        //
        UARTPrimeTransmit(g_ui32Base);
        MAP_UARTIntEnable(g_ui32Base, UART_INT_TX);
    }
}


