Diff: Codes/Capture.cpp

Revision:

42:d6f9ce115eaf

Parent:

39:9fd8397cbef9

Child:

43:69afea5f5a4d

diff -r b87bbdb97ac7 -r d6f9ce115eaf Codes/Capture.cpp
--- a/Codes/Capture.cpp	Thu Jan 14 17:26:05 2016 +0000
+++ b/Codes/Capture.cpp	Mon Jan 18 18:01:59 2016 +0000
@@ -6,138 +6,137 @@
  */
 #include "Capture.h"
 
-Semaphore Capture::m_CaptureSemaphore(1); //used to alert the capture thread about a ready capture 
-int Capture::m_BufferIndex;
+
+__attribute((section("AHBSRAM1"),aligned)) float Capture::m_AdcBuffers[NUMBER_OF_CHANNELS][NUMBER_OF_SAMPLES*2];// __attribute__((section("AHBSRAM0")));
 
-//extern char LargeBuffer[1024];
+bool Capture::flag_capture = 0;
+int Capture::cnt_buffer=0;
+int Capture::channel_number=0;
+int Capture::cnt_interrupt=0;
 
-__attribute((section("AHBSRAM1"),aligned)) dmaLinkedListNode Capture::m_Nodes[2];// __attribute__((section("AHBSRAM0"))); //this list holds the buffer configuration for the DMA peripheral
-__attribute((section("AHBSRAM1"),aligned)) unsigned short int Capture::m_AdcBuffers[2][NUMBER_OF_SAMPLES][NUMBER_OF_CHANNELS];// __attribute__((section("AHBSRAM0")));
 Serial rfid_serial(p28,p27);
 
-//This function prepares the capture buffers and starts the DMA peripheral
-void Capture::Start()
-{
-    m_Nodes[0].destAddr = (unsigned int)m_AdcBuffers[0];// HERE GOES THE BUFFER ADDRESS(unsigned int)adval;
-    m_Nodes[0].sourceAddr = (unsigned int)&LPC_ADC->ADGDR;
-    m_Nodes[0].dmaControl = (NUMBER_OF_SAMPLES*NUMBER_OF_CHANNELS)| DMA_DST_WIDTH_HALFWORD | DMA_SRC_WIDTH_HALFWORD | DMA_DST_INCREMENT | DMA_TC_INT;
-    m_Nodes[0].nextNode = (unsigned int)&m_Nodes[1];
+Ticker timer_interrupt;
+
+DigitalOut led1(LED1);
 
-    m_Nodes[1].destAddr = (unsigned int)m_AdcBuffers[1];// HERE GOES THE BUFFER ADDRESS(unsigned int)adval2;
-    m_Nodes[1].sourceAddr = (unsigned int)&LPC_ADC->ADGDR;
-    m_Nodes[1].dmaControl = (NUMBER_OF_SAMPLES*NUMBER_OF_CHANNELS)| DMA_DST_WIDTH_HALFWORD | DMA_SRC_WIDTH_HALFWORD | DMA_DST_INCREMENT | DMA_TC_INT;
-    m_Nodes[1].nextNode = (unsigned int)&m_Nodes[0];
 
-    m_BufferIndex=0;
-
-    while(!(LPC_ADC->ADDR0&(1U<<31)));  //waits the completion of the ADC Channel 0 capture - for synchronization purposes
-    while(!(LPC_ADC->ADDR0&(1U<<31)));  //waits the completion of the ADC Channel 0 capture - for synchronization purposes
-
-    setup_channel(&m_Nodes[0],0,DMA_PERIPHERAL_ADC,DMA_MEMORY);
+float Capture::GetValue(int nsamples, int nchannel)
+{
+    return m_AdcBuffers[nchannel][nsamples];
 }
 
-//This function initializes the ADC and DMA peripherals
-void Capture::Initialize()
-{   
-    //printf("0x%lx\n",  LargeBuffer);
-    init_adc(FREQBASE*NUMBER_OF_SAMPLES*NUMBER_OF_CHANNELS);
-    select_channels(ADC_CH_0|ADC_CH_1|ADC_CH_2|ADC_CH_3|ADC_CH_4|ADC_CH_5);
-    LPC_ADC->ADCR |= ADC_MODE_BURST;
-
-    init_dma();
-    
-    Start();
-    
-    m_CaptureSemaphore.wait();
+void Capture::PutValue(int nsamples, int nchannel, float value)
+{
+    m_AdcBuffers[nchannel][nsamples] = value;
 }
 
-void Capture::Stop()
-{
-    m_CaptureSemaphore.release();   //release semaphore
-    stop_channel();
-}
-
-void Capture::Wait()
+void Capture::CopyBuffer(int channel, float *dest)
 {
-    m_CaptureSemaphore.wait(osWaitForever);
-}
-
-unsigned short int Capture::GetValue(int nsamples, int nchannel)
-{
-    return ADC_CONVERT(m_AdcBuffers[m_BufferIndex][nsamples][nchannel]);
-}
-
-void Capture::CopyBuffer(int channel, unsigned short int *dest)
-{
+    memcpy(dest, &m_AdcBuffers[channel][0], sizeof(float) * NUMBER_OF_SAMPLES);
+    /*
     for(int i=0;i<NUMBER_OF_SAMPLES;i++)
     {
         dest[i] = GetValue(i,channel);
     }
-}
-
-void Capture::CopyBufferSigned(int channel, short int *dest)
-{
-    for(int i=0;i<NUMBER_OF_SAMPLES;i++)
-    {
-        dest[i] = GetValue(i,channel);
-    }
+    */
 }
 
-void Capture::CopyBufferFloat(int channel, float *dest)
-{
-    for(int i=0;i<NUMBER_OF_SAMPLES;i++)
-    {
-        dest[i] = (float) GetValue(i,channel);
-    }
-}
-
-void Capture::ISRHandler()
-{
-    Capture::m_BufferIndex = (~Capture::m_BufferIndex)&1;
-
-    Capture::m_CaptureSemaphore.release();
-    LPC_GPDMA->DMACIntTCClear = 0xFF;
-}
-/*
-bool Capture::ReadRFID(int channel,char *rfid)
+void Capture::InitializeAD()
 {
     
-    char cmd[4];
-    cmd[0] = 'S';
-    cmd[1] = '0'+channel;
-    cmd[2] = '\n';
-    cmd[3] = '\0';
+    init_adc(200000);                   // Inicializa o AD com a frequencia de amostragem de 200 kHz
+    LPC_ADC->ADCR &= ~ADC_MODE_BURST;   // Desabilito o modo burst de captura para utilizar apenas a captura simples
+    NVIC_DisableIRQ(TIMER3_IRQn);   // Desabilita a interrupção do Timer3
     
-    //send
-    rfid_serial.puts(cmd);
+}
+
+void Capture::AcquireValues()
+{
+
+    NVIC_DisableIRQ(TIMER3_IRQn);   // Desabilita a interrupção do Timer3
+    timer_interrupt.attach_us(&Capture::FcnTimerInt,11);    // Seta a interrupção do timer3 para cada 11us apontando para a função FcnTimerInt
+    cnt_buffer = 0;
+    cnt_interrupt = 0;
+    flag_capture = 0;   
+    channel_number = 0;
+    LPC_ADC->ADCR |= ADC_START_NOW; // Habilita a captura do A/D -> Captura Simples
+    //printf("\r\nPASSOU do init \n"); 
+     
+    select_channels(1<<channel_number); //         
+    
+    NVIC_EnableIRQ(TIMER3_IRQn); // Habilita a interrupção do timer 3
+    for(volatile int i=0; i<100000; i++); // Gasta tempo
+
+    while(!flag_capture);
     
-    //receive
-    char ch=0;
-    char ans[10];
-    int cnt=0;
-    int tmout=1000;
-    while(ch != '\n' && tmout-- && cnt<9)
+    /*for (int i=0;i<NUMBER_OF_SAMPLES;i++)
+    {
+        printf("\r\n%d", i);
+        
+        for (int j=0;j<6;j++)
+        {
+            float val = 0;
+            val = (float)m_AdcBuffers[j][i] - (float)Settings::get_Offset(j);
+            val /= (float)Settings::get_Gain(j);
+            //printf("\t%f", m_AdcBuffers[j][i]);
+            printf("\t%2.2f", val);
+        }
+    }*/
+    //printf("\n");
+}
+
+extern "C" void Capture::FcnTimerInt(void)
+{
+    if (cnt_interrupt < 120)    // Descarta as primeiras leituras para estabilizar as leituras do A/D
     {
-        if(rfid_serial.readable())
+        while(!(LPC_ADC->ADGDR>>31));
+        m_AdcBuffers[channel_number][0] = ((LPC_ADC->ADGDR>>4)&0xfff);
+        if (channel_number < 5)
+            {
+                channel_number++;
+            }
+            else
+            {
+                channel_number = 0;
+            }
+        cnt_buffer = 0;   
+        cnt_interrupt++;
+        select_channels(1<<channel_number);
+        LPC_ADC->ADCR |= ADC_START_NOW;
+                
+    }
+    else    //Armazena as leituras no buffer dos canais
+    {
+        while(!(LPC_ADC->ADGDR>>31));  // Aguarda o bit de DONE ser setado no registrador ADGDR sinalizando o final de uma captura
+        
+        if (cnt_buffer < NUMBER_OF_SAMPLES)
         {
-            ch = rfid_serial.getc();
-            if(!((ch>='0' && ch<='9') || (ch >= 'A' && ch <= 'F')))ch='0';
-            ans[cnt++] = ch;
+            
+            //Pega o valor do AD e adapta de 16 bits para 12 bits
+            m_AdcBuffers[channel_number][cnt_buffer] = (float) ((LPC_ADC->ADGDR>>4)&0xfff);
+                        
+            if (channel_number < 5)
+            {
+                channel_number++;
+            }
+            else
+            {
+                channel_number = 0;
+                cnt_buffer++;
+            }   
         }
         else
-            wait_ms(1);
-        
-    }
-    if (cnt > 0){
-        ans[cnt-1] = '\0';
-        for(int i=0;i<10;i++)
-            rfid[i] = ans[i];
-        return true;
-    }
-    return false;
-    
+        {
+            
+            flag_capture = 1;
+            NVIC_DisableIRQ(TIMER3_IRQn);
+            //timer_interrupt.detach();
+        }
+        select_channels(1<<channel_number);
+        LPC_ADC->ADCR |= ADC_START_NOW;
+   }
 }
-*/
 
 void Capture::ReadRFID(int channel,char *rfid)
 {