AVR Freaks

Thanks for the response again @mikech.

I did not realise you have replied till I came checking the site again (I usually do receive email alerts).

Your response has given me a good understanding of configuring the ADC. I was thinking the 2.4MHz was the sampling rate before, not realising there was need to be a timer-interrupt. I will get to fix this timer-interrupt and hopefully i will achieve my target sampling frequency of 250Hz. That I plan to do with: cpu_delay_us(4000, 3*BOARD_OSC0_HZ);

A side question is- is the ADC clock of 2.4Mhz sufficient? What guides the setting/configuration of this clock?

Thanks for the clarification @mikech.

I am still in some troubles as it seems my ADC is not performing as expected. I am sampling on 2 channels (tagged I and Q in the code below) at the (supposedly) rate of 250Hz. In 60 seconds, I was expecting 250*60*2 = 30000 samples at the receiver end (a RPi connected to my user board via 3-wire UART) but the samples are either above the expected value or way below it. I guess I am missing something- implementation of the sampling rate?, UART baudrate?, cpu_clocking?

I kindly ask for further help in suggesting what could be wrong given the adapted program code as below:

/*
 * adc.c
 *
 * Created: for ADC and U(S)ART
 *  Author: obabarin
 */ 


//do header and lib insertions
#include ""
#include <>

////USART defines
#define USART				(&AVR32_USART3)
//to be defined in init.c
#define TARGET_PBACLK_FREQ_HZ	BOARD_OSC0_HZ
#define USART_RX_PIN		AVR32_USART3_RXD_0_0_PIN
#define USART_RX_FUNCTION	AVR32_USART3_RXD_0_0_FUNCTION
#define USART_TX_PIN		AVR32_USART3_TXD_0_0_PIN
#define USART_TX_FUNCTION	AVR32_USART3_TXD_0_0_FUNCTION

#define AVR32_SCIF_OSCCTRL0_STARTUP_2048_RCOSC	0x00000003

////Data formatting
#define NUM_IQ			75
#define NUM_SFCW		121

//Global variable declarations
int Nm[4][32];

uint32_t Target_VCO_CAP_Address = 0;
uint32_t calibration[41];
double	Ftune = 0.0;


//Variables to store I/Q samples (2 channels of ADC to be used)

#if defined(I_CHANNEL)
unsigned long Isample = 1;
#endif

#if defined(Q_CHANNEL)
unsigned long Qsample = 1;
#endif

unsigned long temp1 = 1;
unsigned long temp2 = 1;

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

////CPU clock settings
static void setMainClock(void)
{
    //// Enable the external Osc0 of 16Mhz
    pm_enable_osc0_crystal(&AVR32_PM, FOSC0);
    
    pm_enable_clk0(&AVR32_PM, 0x00000003);
    
    ////Enable the PLL at 96MHz
    pm_pll_setup(&AVR32_PM, 0, 2, 0, 0, 16);
    
    //////PLL output VCO frequency at 48MHz
    pm_pll_set_option(&AVR32_PM, 0, 1, 1, 0);
    
    //////Enable PLL0
    pm_pll_enable(&AVR32_PM, 0);
    
    ///////Wait for PLL0 locked
    pm_wait_for_pll0_locked(&AVR32_PM) ;
    
    //////Set PBA and PBB clocks by 2 from main clock at 24 MHz
    pm_cksel(&AVR32_PM, 1, 0, 1, 0, 0, 0); //default
    
    /////Set PLL0 as main clock to 48MHz
    pm_switch_to_clock(&AVR32_PM, AVR32_PM_MCSEL_PLL0); //default
}

static void local_start_gc(void)
{
    
    // setup a generic clock
    pm_gc_setup(&AVR32_PM, AVR32_PM_GCLK_GCLK0, 1, 0, 0, 0);
    
    /* Enable Generic clock */
    pm_gc_enable(&AVR32_PM, AVR32_PM_GCLK_GCLK0);
    
    /* Set the GCLOCK function to the GPIO pin */
    gpio_enable_module_pin(7, 1);//PA07
    
    
}

//{insert other functions for configuring user board here
    
//}


int main (void)
{
    uint8_t IQsamples[74];
    uint8_t SFCWsamples[121];
    //IQsamples[0] = 0x4C; //number of samples,0x4c=76d ie 1bit for sensor ID and 75 bits
    //SFCWsamples[0] = 0x78;
            
    int j;
    int k;
    int singletone;
    //int multitone;
    uint8_t IQbuff[1]; ////buffer to hold IQsamples converted from binary to decimals and sent as string
    
    
    
    
    setMainClock();
    
    local_start_gc();
    
    volatile avr32_adc_t *adc = &AVR32_ADC;
    
    board_init();
        
    AVR32_ADC.mr |= 0x2 << AVR32_ADC_MR_PRESCAL_OFFSET;   //4.0 MHz with prescale of 2 => ADCCLOCK = CLK_ADC/((PRESCAL+1)*2). where CLK_ADC = PBA_CLK
    
    adc_configure(adc);
    
    // Enable the I/Q ADC channels.
    #if defined(I_CHANNEL)
    adc_enable(adc, I_CHANNEL);
    #endif
    #if defined(Q_CHANNEL)
    adc_enable(adc, Q_CHANNEL);
    #endif
    
    // Initialize interrupt vector table support.
    irq_initialize_vectors();
    
    // Enable interrupts
    cpu_irq_enable();
    
    #if defined(__GNUC__) && defined(__AVR32__)
    setbuf(stdout, NULL);
    setbuf(stdin, NULL);
    #endif
    
    static const gpio_map_t USART_GPIO_MAP =
    {
    {USART_RX_PIN, USART_RX_FUNCTION},
    {USART_TX_PIN, USART_TX_FUNCTION}
    };
    
    // USART options.
    static const usart_options_t USART_OPTIONS =
    {
        .baudrate     = 115200,
        //.baudrate     = 57600,
        //.baudrate     = 9600,
        //.baudrate     = 1200,
        .charlength   = 8,
        .paritytype   = USART_NO_PARITY,
        .stopbits     = USART_1_STOPBIT,
        .channelmode  = USART_NORMAL_CHMODE
    };
    
    usart_init_rs232(USART, &USART_OPTIONS, BOARD_OSC0_HZ*1.5); //use when fPBA is 24Mhz, 
    ////usart_init_rs232(USART, &USART_OPTIONS, FOSC0*1.5);
    
    while(1){
        
        //// call user board functions
        
            for(singletone=0;singletone<20;singletone++){//for1
                ////for(singletone=0;singletone<80;singletone++){//for1
                
                //AVR32_GPIO.port[0].ovrc = 1 <<6;	// Switch connected to Radar
                cpu_delay_us(1000, 1.5*BOARD_OSC0_HZ);
                k=0;
                                
                for(j=0;j<25;j++){//for2
                    //				TxBits(0x5,0x00000F88); // VCO Subsystem 3 - enable RF output stage
                    //				cpu_delay_us(1000, 3*BOARD_OSC0_HZ);
                    
                    // launch conversion on all enabled channels
                    adc_start(adc);
                    
                    // Acquire the I/Q channels
                    Isample = adc_get_value(adc, I_CHANNEL);
                    Qsample = adc_get_value(adc, Q_CHANNEL);
                    
                    ////format adc samples into bytes
                    // Creating byte 1
                    temp1=0x8000;
                    temp2 =((Isample & 0x00000300) << 5 );
                    temp1=(temp1 | temp2);
                    temp1= ((temp1 | 0x1000) >> 8  );
                    temp2=((Isample & 0x000000F0) >> 4);
                    IQsamples[k] = (uint8_t)(temp1 | temp2);
                    
                    // Creating byte 2
                    temp1 =((Isample & 0x0000000F) << 4 );
                    temp1= (temp1 | 0x08);
                    temp2= ((Qsample & 0x380) >> 7);
                    IQsamples[k+1] = (uint8_t)(temp1 | temp2);
                    
                    // Creating byte 3
                    temp1=0x80;
                    temp2= ((Qsample & 0x7F));
                    IQsamples[k+2] = (uint8_t)(temp1 | temp2);
                    
                    //				TxBits(0x5,0x00000D88); // VCO Subsystem 3 - disable RF output stage
                    
                    if (k<75) {
                        cpu_delay_us(4000, 1.5*BOARD_OSC0_HZ); //sampling frequency of 250Hz = 1/4000us
                    }//if
                    
                    k=k+3;
                    
                                        
                }//for2
                
                
                /////send CW data over uart here using a for_loop////////////////////////////
                                
                for (int a = 0; a < 75; a++){//for3
                    sprintf(IQbuff, "%d;", IQsamples[a]);  ////convert content of IQsamples to decimals and 'print' to IQbuff
                    usart_write_line(USART, IQbuff);
                    
                }//for3
                
                usart_write_line(USART, "\r\n");
                
                ////usart_write_line(USART, "ABCDEF\r\n"); //test transmit
                ////}old try
                
                
                
                cpu_delay_us(4000, 1.5*BOARD_OSC0_HZ);
                
            }//for1
            
        
    }//while
    
    
}//main

Thank you.

Thanks again @mikech.

Can you please clarify to me the difference between fcpu_hz as used in cpu_delay_us(unsigned long delay, unsigned long fcpu_hz); and pba_hz as used in usart_init_rs232(volatile avr32_usart_t *usart, const usart_options_t *opt, long pba_hz);?

Is there an instance (such as in my configuration) when fcpu_hz = pba_hz?

In my case I am certain the pba_hz is 24Mhz, but could not figure what the fcpu_hz is.

Sure it does give on pg 54 of the AT32UC3A datasheet. I was asking to be double sure I did the right configuration and to clear my doubt.