#include <mega32.h> 
#include <stdio.h> 
#include <math.h>

//I like these definitions
#define begin {
#define end   } 

#define int2fix(a)   (((int)(a))<<8) 
#define fix2int(a)   ((signed char)((a)>>8))
#define float2fix(a) ((int)((a)*256.0)) 
#define fix2float(a) ((float)(a)/256.0)  

#define N_WAVE          16    /* size of FWT */
#define LOG2_N_WAVE     4     /* log2(N_WAVE) */
int fwt_t1, fwt_t2; 

int ain1[N_WAVE], ain0[N_WAVE] ;       //double buffer inputs
char countISR, Nbuffer;   //Nbuffer keeps track of which buffer is in use

//reordering tables
flash char reorder16[16] = {0,15,7,8,3,12,4,11,1,14,6,9,2,13,5,10};
                 
//======================================================== 

void FWTfix(int x[])
// This routine does foward transform only
//output is in dyadic order -- see web links
//use FWTreorder() to put the transform in sequency order 
begin
    unsigned char ii, k, j, i, bb, st;
    
    bb = N_WAVE/2; st = N_WAVE; 
    //
    for (i=1; i<LOG2_N_WAVE+1; i++)
    begin
        for (j=0; j<N_WAVE; j+=st)
        begin
            for (k=0; k<bb; k++)
            begin
                ii=j+k;
                fwt_t1 = x[ii] >>1 ;         //scale to keep fixed pt in range
                fwt_t2 = x[ii+bb] >>1 ;
                x[ii] = fwt_t1 + fwt_t2 ;    //
                x[ii+bb] = fwt_t1 - fwt_t2 ;
            end
        end
        bb = bb>>1 ; st = st>>1 ;
    end
end

//========================================================  
void FWTreorder(int x[], flash char r[]) 
//converts from dyadic order to sequency order -- see references
begin
    char i,j;
    int xp[N_WAVE];
    for (i=0; i<N_WAVE; i++)
    begin
        j = r[i];
        xp[j] = x[i];
    end
    for (i=0; i<N_WAVE; i++)
    begin
        x[i] = xp[i];
    end    
end 
//========================================================
interrupt [TIM0_OVF] void getAD(void)
begin 
    //read a/d converter and update appropriate buffer 
    if (countISR < N_WAVE)
    begin 
        if (Nbuffer) ain1[countISR] = ADCH ; 
        else ain0[countISR] = (int)ADCH ;
        //start a/d converter
        ADCSR.6 = 1;  
        //update ISR counter
        countISR++; 
        //PORTB = ~PORTB; 
    end
end

//========================================================        
//read A/D converter
// transform
// PWM LEDs to make 8 channel analyser

void main(void)
begin
    unsigned char CurBuf, i, m ; 
    int compare[8], th;
       
    //serial setup for debugging using printf, etc.     
    UCSRB = 0x18 ;
    UBRRL = 103 ;
    putsf("\r\nStarting...\r\n");  
    
    //set up timer0 to sample a/d at about 7800 Hz
    //turn on timer with period= 256*8 cycles  = 2048 cycles 
    //which implies 7812 samples/sec 
    TCCR0 = 0b00000010; 
    TIMSK = 0b00000001 ;
         
    //set up a/d for external Vref, channel 0
    //channel zero/ left adj /EXTERNAL Aref
   //!!!CONNECT Aref jumper!!!!
   ADMUX = 0b00100000;   
   //enable ADC and set prescaler to 1/128*16MHz=125,000
   //and clear interupt enable
   //and start a conversion
   ADCSR = 0b11000111; 
   
    //set up PORTB for output
    DDRB=0xff; 
    
   //and start the show
    #asm("sei")
    
    //start with buffer 0
    Nbuffer = 0;
    
    //led threshold
    th=50; 
    
    while(1)
    begin
        //when there are 16 points in buffer
        if (countISR == N_WAVE)
        begin
            
            //critical section
            #asm("cli")
            CurBuf = Nbuffer;
            //switch input buffers
            Nbuffer ^= 0x01;
            //reset the counter
            countISR = 0;
            #asm("sei")
            //end critical section
            
            //update the FWT 
            if (CurBuf) FWTfix(ain1);
            else FWTfix(ain0);
            // sequency order
            if (CurBuf) FWTreorder(ain1,reorder16);
            else FWTreorder(ain0,reorder16); 
            // combine sal and cal
            if (CurBuf)
            begin
                //omit DC in ain1[0]
                compare[0] = (abs(ain1[1])+abs(ain1[2])) ;
                compare[1] = (abs(ain1[3])+abs(ain1[4])) ;
                compare[2] = (abs(ain1[5])+abs(ain1[6])) ;
                compare[3] = (abs(ain1[7])+abs(ain1[8])) ;
                compare[4] = (abs(ain1[9])+abs(ain1[10])) ;
                compare[5] = (abs(ain1[11])+abs(ain1[12])) ;
                compare[6] = (abs(ain1[13])+abs(ain1[14])) ;
                compare[7] = (abs(ain1[15]));  //highest sequency 
                //printf("%u\r\n",compare[7]);
            end
            else
            begin
                //omit DC
                compare[0] = (abs(ain0[1])+abs(ain0[2])) ;
                compare[1] = (abs(ain0[3])+abs(ain0[4])) ;
                compare[2] = (abs(ain0[5])+abs(ain0[6])) ;
                compare[3] = (abs(ain0[7])+abs(ain0[8])) ;
                compare[4] = (abs(ain0[9])+abs(ain0[10])) ;
                compare[5] = (abs(ain0[11])+abs(ain0[12])) ;
                compare[6] = (abs(ain0[13])+abs(ain0[14])) ;
                compare[7] = (abs(ain0[15]));  //highest sequency 
            end
            
            //find the maximum element
            m = 0;
            for (i=1; i<8; i++)
            begin
                if (compare[i]>compare[i-1]) m = i;    
            end
            
            //combine threshold and max and light leds
            if((m == 7) && (compare[7]>th)) PORTB.0 = 0; else PORTB.0 = 1;
            if((m == 6) && (compare[6]>th)) PORTB.1 = 0; else PORTB.1 = 1;
            if((m == 5) && (compare[5]>th)) PORTB.2 = 0; else PORTB.2 = 1;
            if((m == 4) && (compare[4]>th)) PORTB.3 = 0; else PORTB.3 = 1;
            if((m == 3) && (compare[3]>th)) PORTB.4 = 0; else PORTB.4 = 1;
            if((m == 2) && (compare[2]>th)) PORTB.5 = 0; else PORTB.5 = 1;
            if((m == 1) && (compare[1]>th)) PORTB.6 = 0; else PORTB.6 = 1;
            if((m == 0) && (compare[0]>th)) PORTB.7 = 0; else PORTB.7 = 1; 
        end       
    end   
end