File content as of revision 70:8cd7a8a2c153:

#include "mbed.h"

// Sampling
#include "DMA_sampling/adc.h"
#include "DMA_sampling/dac.h"
#include "DMA_sampling/pdb.h"

// DSP
#include "dsp.h"

#define PRINT_BUFFER_LENGTH 2000


// for debug purposes
Serial pc(USBTX, USBRX);
DigitalOut led_red(LED_RED);
DigitalOut led_green(LED_GREEN);
DigitalOut led_blue(LED_BLUE);
DigitalOut status_0(D0);
DigitalOut status_1(D1);
DigitalIn sw2(SW2);
DigitalIn sw3(SW3);

// defined in dma.cpp
extern int len;
extern uint16_t static_input_array0[];
extern uint16_t static_input_array1[];
extern uint16_t static_output_array0[];
extern uint16_t sampling_status;

// To set up FIR filtering
#define TOTAL_TAPS 16
#define STATE_LENGTH  79
#define BUFFER_LENGTH 64
uint16_t numTaps = TOTAL_TAPS;
float State[STATE_LENGTH]= {0};
float Coeffs[TOTAL_TAPS] = {0.0351885543264657, 0.0326718041339497, 0.0447859388579763, 0.0571840193174261, 0.0688188647212066, 0.0786841934234295, 0.0858044659079242, 0.0895870376972757, 0.0895870376972757, 0.0858044659079242, 0.0786841934234295, 0.0688188647212066, 0.0571840193174261, 0.0447859388579763, 0.0326718041339497, 0.0351885543264657};
arm_fir_instance_f32 S = {numTaps, State, Coeffs};

float filter_input_array[BUFFER_LENGTH] = {0};
float filter_output_array[BUFFER_LENGTH] = {0};



#define pre_compute_length 500
#define CarrierFrequency 200
#define SAMPLEFREQUENCY 100000
//float i_mod_pre[pre_compute_length];
//float q_mod_pre[pre_compute_length];
uint16_t out_val_pre[pre_compute_length]; 
float twopi = 3.14159265359 * 2;


void pre_compute_tables() {
  // This function will precompute the cos and sin tables used in the rest of the program
  for(int precompute_counter = 0; precompute_counter < pre_compute_length; precompute_counter++){
    out_val_pre[precompute_counter] = (int) (cos(twopi * CarrierFrequency /SAMPLEFREQUENCY * precompute_counter) * 2046.0 + 2048.0);
    //printf("%d\n\r",out_val_pre[precompute_counter]);
    //i_mod_pre[precompute_counter] = (cos(twopi * CarrierFrequency * TimerInterruptInMicroSeconds * 1e-6 * precompute_counter));
    //q_mod_pre[precompute_counter] = (-sin(twopi * CarrierFrequency * TimerInterruptInMicroSeconds * 1e-6 * precompute_counter));

  }
}


int main() {
    led_blue = 1;
    led_green = 1;
    led_red = 1;
    
    int DAC_COUNTER = 0;
    //bool is_magnified_sample = true;
    pre_compute_tables();
    
    
    pc.baud(230400);
    pc.printf("Starting\r\n");
    
    
    uint16_t output_print_buffer[PRINT_BUFFER_LENGTH];
    uint16_t output_print_buffer2[PRINT_BUFFER_LENGTH];
    int print_buffer_count = 0;
    
    pdb_init(); // Initalize PDB   
    dac_init(); // initializes DAC   
    adc_init(); // always initialize adc before dma
    pc.printf("ADC Initialized\r\n");
    dma_init(); // initializes DMAs
    dma_reset(); // This clears any DMA triggers that may have gotten things into a different state
    pc.printf("Buffer Size: %i\r\n", len);
    
    led_green = 1;
    
    pc.printf("\r\n\r\n\r\n");
    
    pdb_start();
    //while(print_buffer_count<PRINT_BUFFER_LENGTH) 
    while(1)
        {
            while(sampling_status == 0)
            {   
                status_0 = 1;
            }
            /*
            if (is_magnified_sample)
            {
                ADC0_SC1A = 0x0D;
            }
            else
            {
                ADC0_SC1A = 0x0C;
            }
            is_magnified_sample = !is_magnified_sample;
            */
            sampling_status = 0;
            status_0 = 0;

            if(sw2)
                {
                    if(sw3)
                        {
                        //Default PASSTHROUGH Condition
                        status_1 = 1;
                        //printf("%d\n\r",static_input_array0[0]);
                        for(int i = 0; i < len; i++) 
                        {
                            static_output_array0[i] = static_input_array0[i] >> 4;  
                            
                            //printf("%d\n\r",static_input_array0[i]);
                            output_print_buffer[print_buffer_count+i] = static_input_array0[i];
                            output_print_buffer2[print_buffer_count+i] = static_input_array1[i];
                            
                            if (i>4&&static_input_array0[i]==static_input_array0[i-1]&&static_input_array0[i]==static_input_array0[i-2])
                                printf("Y");
                            //if (print_buffer_count+i>=PRINT_BUFFER_LENGTH)
                            //{
                           //     break;
                           // }
                                                    
                        }
                        //print_buffer_count+=len;
                        status_1 = 0;
                        }
                    else                    
                        {        
                        // Can show that buttons are active - Serial link working
                        status_1 = 1;
                        pc.printf("DSP: %d\r\n",out_val_pre[DAC_COUNTER]);
                        //pc.printf("DSP: %d\r\n",out_val_pre[DAC_COUNTER]);
                        for(int i = 0; i < len; i++) 
                        {
                            static_output_array0[i] = static_input_array0[i] >> 4;
                        }                    
                        status_1 = 0;
                        }
                }   
            else 
                {   
                    // Here we can really put our DSP blocks     
                    status_1 = 1;
                    for(int i = 0; i < len; i++) 
                    {
                        //static_output_array0[i] = static_input_array0[i] >> 4;                        
                        //filter_input_array[i] = (float) (((int) static_input_array0[i]) - 0x8000);
                        filter_input_array[i] = (float) (((int)static_input_array0[i]) - 0x8000);
                    }
                    
                    //filter_input_array[0] = (float) static_input_array0[0];
                    
                    arm_fir_f32(&S, filter_input_array, filter_output_array, len);
                    
                    
                    // Scale for output
                    /*
                    for(int i = 0; i < len; i++) 
                    {
                        //static_output_array0[i] = static_input_array0[i] >> 4;                        
                        //filter_output_array[i] = 0.25 * filter_input_array[i];
                        filter_output_array[i] = 0.0625 * filter_output_array[i];
                    }
                    */
                    
                    for(int i = 0; i < len; i++) 
                    {
                        //static_output_array0[i] = static_input_array0[i] >> 4;                        
                        //static_output_array0[i] = (uint16_t) (( (int) filter_output_array[i] ) + 0x800);
                        //static_output_array0[i] = (uint16_t) (filter_output_array[i] + 0x8000) >> 4;
                        //static_output_array0[i] = (uint16_t) filter_input_array[i];
                        //static_output_array0[i] = static_input_array0[i] >> 4;
                        
                        
                        static_output_array0[i] = out_val_pre[DAC_COUNTER];
                        DAC_COUNTER++;
                        if (DAC_COUNTER>=pre_compute_length)
                        {
                            DAC_COUNTER = 0;
                        }
                    }
                    
                   
                    status_1 = 0;
                }
           
        }
        
        for(int i = 0; i<PRINT_BUFFER_LENGTH; i++)
        {
            printf("%d %d\n\r",output_print_buffer[i],output_print_buffer2[i]);
        }
        
        
}