//=====================================================================
// Sean Finn, FYP 2006
// Embedded C control program for the ARM microcroller used
//        as core of the ETU
//
//---------------------------------------------------------------------
// Operation:
// Samples EKG & stethoscope signals (attached to ADC channels 0 & 1,
//        respectively), at 2.5 kHz & 500 Hz      (respectively).
// These 12 bit samples are then sent, a nibble at a time, to
//        Server PC thorough UART at 115200 baud (no parity, 2 stop bits)
//=====================================================================

#include <ADuC7024.h>  //include definitions specific to eval board used

// function prototypes: definintions in seperate source file
extern int write (int file, char * ptr, int len);    // outputs a string on UART (for debug)    
extern int put_byte(int);                             // outputs a byte via UART
extern void send_pak(unsigned char* buffer, int buff_size);          //sends the entrire Tx buffer
extern void initialise(void);                          // performs ARM initialisation (peripherals etc)
extern void IRQ_func(void);                            // ADC interrupt servive routine

//global variables

// variables associated with ADC conversions
unsigned short xn = 0;
unsigned short xn2 =0;
unsigned short samp_ctr = 0;
unsigned short pak_ctr = 0;
unsigned short dwnsmpl_ctr = 0;
static unsigned short dwnsmpl_ratio = 5; // 500 Hz EKG sampling frequency

// buffer variables
unsigned int buffer_size = 6012;
unsigned char send_buff1[6012] = {0};     // circular transmitt buffer
unsigned char buffer_full = 0;             // buffer full flag
unsigned char buff_send_margin = 99;     // send margin, to avoid buffer overrun (must be multiple of 3)
unsigned char* UART_ptr;                  // pointer to address the transmit buffer

//filtering variables, redundant here (see note below)
// filter co-efficients
//unsigned short co_efs[21] = {46637,49888,52926,55711,58208,60382,62202,63644,64689,
//                            65322,65535,65322,64689,63644,62202,60382,58208,55711,52926,
//                            49888,46637};  //20th order LPF  
//static unsigned char FILT_ORD = 20;           //order of the digital LPF implemented
//unsigned short mem[20] = {0};               //filters memory elements, of size FILT_ORD
//unsigned short filtered_smpl;

int main (void)  {
    //char output1[13] = "Hello World!\n";      // debugging UART test

    // pefore ADC is enabled, set up buffer, point pointer to first element of buffer array
    UART_ptr = &send_buff1[0];

    initialise();    //initialise peripherals: UART, ADC, etc

    // Set up the IRQ
    FIQ = IRQ_func;             //    Specify (Fast) Interrupt Service Rountine
    FIQEN = 0x8;                // enable timer 1 IRQ mask
    GP4DAT ^= 0x00040000;        // Complement P4.2 (LED), to indicate program is started

    // Main functionality handled by ADC ISR
    // Infinite loop, poll for full buffer flag, calling send_pak function when detected
    while(1)
    {                      
        if( buffer_full == 1) {    
            GP4DAT ^= 0x00040000;                // Complement P4.2 (LED)
            send_pak(UART_ptr, buffer_size);    // send the packet
            UART_ptr = &send_buff1[0];            // reset send pointer
            buffer_full = 0;                     // reset eand flag
        }
    }
}

//=============ADC interrupt servive routine=========================
// Medodology: Timer 1 triggers a conversions at 2.5 kHz, and a
//    sthethoscope  sample is read & stored in buffer.
//  Upon every 5th such conversion (ie at 500 Hz), a software
//    triggeredconversion of EKG channel is performed.
//
//    In prevoius versions, both were sampled at higher rate, and the
//    EKG was low pass filtered, and then downsampled. In this version
//  filtering code is commented (no downsampling => no filtering required).
//====================================================================


void IRQ_func(void) {
    //unsigned short j;            // local counter declaration (filtering)
    GP1DAT ^= 0x00800000;        // Complement P1.7     (debug - ADC freq probing)
       T1CLRI = 0;                    // clear timer 1 interrupt flag
    xn = (ADCDAT >> 16) & 0xFFF;        // read ADC sample
   
    // nibble by nibble sample stroage. MS nibble of each byte is a counter,
    // used for decoding data stream at PC server                                                                                                                                                                        
    //store steth sample in byte-wide buffer: MSNibble, MiddleNibble LSNibble
    send_buff1[samp_ctr] = 0x40 | (xn >> 8);
    samp_ctr++;
    send_buff1[samp_ctr] = 0x20 |  ((xn >> 4) & 0xF);
    samp_ctr++;
    send_buff1[samp_ctr] = 0x10 | (xn & 0xF);
    samp_ctr++;

    if(dwnsmpl_ctr == dwnsmpl_ratio -1) { // every 5th sample
        GP1DAT ^= 0x00010000;        // Complement P1.0    (debug - ADC freq probing)        
        //perform a signle sofware driven ADC conversion from chan 1
        ADCCP = 0x01;                //switch ADC channel
        ADCCON = 0xE3;                // config for a software conversion      
        while (!ADCSTA){}            // wait for end of conversion
        xn = (ADCDAT >> 16);        // read ADC sample
        ADCCP = 0x07;                // select steth channel (1) again
        ADCCON=0xE1;                //return ADC config to timer 1 driven conversions

        // Digital filtering, now redundant.
        //--------EKG sample now read, perform filtering------------//
        //filtered_smpl = co_efs[0]*xn;
        //for(j=1;j<FILT_ORD;j++) {
        //    filtered_smpl += co_efs[j]*mem[j-1];
        //}
        //update memory elements
        //for(j=FILT_ORD;j>0;j--){
        //    mem[j] = mem[j-1];
        //}
        //mem[0] = xn;
        //------Digital Filtering Complete-----------------------//

        //store the sample, samp method as for steth samples
        xn = (ADCDAT >> 16)& 0xFFF;
        send_buff1[samp_ctr] = 0xC0 | (xn >> 8);
        samp_ctr++;
        send_buff1[samp_ctr] = 0xB0 |  ((xn >> 4) & 0xF);
        samp_ctr++;
        send_buff1[samp_ctr] = 0xA0 | (xn & 0xF);
        samp_ctr++;

        dwnsmpl_ctr = 0;        //reset counter
    } else {
           dwnsmpl_ctr++;            //increment counter
    }

    // watch for buffer almost full
    if (samp_ctr == buffer_size - buff_send_margin) {
         buffer_full = 1;    // set the buffer full flag, main() will begin transmission
    } else if (samp_ctr == buffer_size) { //at the end of buffer, start filling from start again
        samp_ctr = 0;        //reset sample counter
        pak_ctr++;
       
    }
}
//=====================================================================
// Final Year Project ARM functions
// Sean Finn, 2006
//=====================================================================
#include <aduc7024.H>      //include definitions specific to eval board used              

#define CR     0x0D      //define ASCII code for carrige return, for string Tx

// standard delay routine
void delay(int length)
{
    while (length >=0)
        length--;
}

// outputs a byte via UART
int put_byte(unsigned int ch)  {                

    if (ch == '\n')  {       // handle sending of newline
        while(!(0x020==(COMSTA0 & 0x020)))    //wait for UART not busy
        {}
        COMTX = CR;                          
        }
    while(!(0x020==(COMSTA0 & 0x020)))        //wait for UART not busy
    {}

    return (COMTX = ch);
}

//sends the entrire Tx buffer
void send_pak(unsigned char* buffer, int buff_size)
{
        unsigned int i;
        delay(1000);
        for(i=0;i<buff_size;i++) {    // loop through Tx buffer
            put_byte(*(buffer+i));    // send current byte using pointer arithmetic
        }
}

// outputs a string on UART (for debug)
int write (int file, char * ptr, int len) {
  int i;

  for (i = 0; i < len; i++) put_byte (*ptr++);
  return len;
}

// performs ARM initialisation (peripherals etc)
void initialise(void) {
   
    // UART configuration for 115200 baud
    GP1CON = 0x011;        // Setup tx & rx pins on P1.0 and P1.1
    COMCON0 = 0x80;        // Setting DLAB
       COMDIV0 = 0x0C;        // Setting DIV0 and DIV1 to DL calculated
       COMDIV1 = 0x00;
       COMCON0 = 0x07;        // Clearing DLAB
    COMDIV2 = 0x884F;

    //ADC configuration
    ADCCON=0x20;    //power-on the ADC
    delay(80000);    //wait for ADC poweron time
    ADCCP=0x00;        //Select ADC channel 0 by default
    ADCCON=0xE1;    //single-ended, start conversion on timer1
    REFCON=0x01;    //connect internal 2.5V reference to VREFpin

    // timer1 configuration                    
    T1LD = 0x467;                       // Counter Value (for 2.5 kHz)
    T1CON = 0xC4;                        // Enabled,Periodic,Binary
     
    // IO ports initialisation
    GP1DAT = 0xFF000000;      
    GP3DAT = 0xFFFF0000;
    GP4DAT = 0x04000000;            // P4.2 configured as an output. LED is turned on
}