Diff: main.cpp

Revision:

16:d25147dfdd5c

Parent:

15:3cd408f99547

Child:

17:f051190b4bff

--- a/main.cpp	Sat Feb 23 01:05:26 2019 +0000
+++ b/main.cpp	Mon Mar 18 03:10:55 2019 +0000
@@ -20,17 +20,17 @@
 Serial pc(USBTX, USBRX,115200);
 //Serial pc(USBTX, USBRX, 9600);
 Serial rpi(PA_9,PA_10,115200);
-
+Timer t;
 
-int32_t channel_data[NUM_CHANNELS];
-int32_t new_data;
+int32_t channel_data[NUM_CHANNELS] = {0,0,0,0,0,0,0,0,0,0};
+int32_t new_data = 0;;
 int32_t avg_data[NUM_CHANNELS];
 int32_t data_buffer[NUM_CHANNELS][10];
 int32_t data_sum[NUM_CHANNELS];
 int32_t ind = 0;
 int num_samples = 0;
-int num_avgs = 4;
-int ptr =-1;
+int num_avgs = 6;
+int ptr =0;
 
 void starting()
 {
@@ -48,8 +48,7 @@
 {
     bool int_status;
     char val;
-    for(int n=start_reg;n<=end_reg;n++)
-    {
+    for(int n=start_reg; n<=end_reg; n++) {
         val = adc1.read8bits(n,&int_status);
         pc.printf("reg %02x, val =%02x\r\n",n,val);
     }
@@ -59,48 +58,130 @@
 {
     bool int_status;
     char val;
-    for(int n=start_reg;n<=end_reg;n++)
-    {
+    for(int n=start_reg; n<=end_reg; n++) {
         val = adc2.read8bits(n,&int_status);
         pc.printf("reg %02x, val =%02x\r\n",n,val);
     }
 }
 
 
-void get_avgs() {
-    ptr++; //increment pointer
-    if (ptr == num_avgs) {
-        ptr = 0; //reset pointer
-    }
+void get_avgs()
+{
     if (num_samples < num_avgs) {
         num_samples++; //increment number of samples
-    }
-    else {
+    } else {
         for (int n = 0; n<NUM_CHANNELS; n++) { //loop over channels
             data_sum[n] -= data_buffer[n][ptr]; //subtract oldest sample
         }
     }
-    for (int n=0;n<NUM_CHANNELS;n++) {
+    for (int n=0; n<NUM_CHANNELS; n++) {
         data_buffer[n][ptr] = channel_data[n]; //put new sample in buffer
         data_sum[n] += channel_data[n]; //add new sample
-        avg_data[n] = data_sum[n] / num_avgs; //get new average    
+        avg_data[n] = data_sum[n] / num_avgs; //get new average
+    }
+    ptr++; //increment pointer
+    if (ptr == num_avgs) {
+        ptr = 0; //reset pointer
+    }
+}
+
+#define NUM_FILTER_TAPS 12
+float filter_buffer[NUM_CHANNELS][NUM_FILTER_TAPS];
+//float lpf[NUM_FILTER_TAPS] = {
+//    0.066753767,
+//    0.288003606,
+//    0.489209110,
+//    0.333448254,
+//    -0.066620544,
+//    -0.194774726,
+//    0.013641767,
+//    0.112606208,
+//    -0.010259249,
+//    -0.061377259,
+//    0.011435200,
+//    0.029613752,
+//    -0.007630463,
+//    -0.008933779,
+//    0.005065228,
+//    993.16906E-6,
+//    -0.001594816,
+//    420.77505E-6
+//};
+//float lpf[NUM_FILTER_TAPS] = {
+// 0.261120009762270400,
+// 0.577407043230469430,
+// 0.318153169307452854,
+//-0.102856989837421975,
+//-0.077312734575000375,
+// 0.025405207067910347,
+//-0.001960444494723064,
+// 44.73953904209371050E-6};
+//float lpf[NUM_FILTER_TAPS] = {
+// 0.074209685703864631,
+// 0.218596393892535157,
+// 0.322579925396349776,
+// 0.274804773971007665,
+// 0.121138454342240451,
+// 0.004556618102039918,
+//-0.017928065442454785,
+// 0.002042214034417321
+//} ;
+float lpf[NUM_FILTER_TAPS] = {
+ 0.021922032288610106,
+ 0.092023100339809011,
+ 0.202378776983641817,
+ 0.290407730540869380,
+ 0.283915707651621163,
+ 0.175369892196639704,
+ 0.037613514962477279,
+-0.044492932416232721,
+-0.049124217289769172,
+-0.017864664397846109,
+ 0.003294185403418759,
+ 0.004556873736760698
+};
+
+
+void fir( ) {
+    int coef_ptr;
+    float filtered_data;
+    for (int channel = 0; channel<NUM_CHANNELS; channel++) {
+        coef_ptr = ptr;
+        filter_buffer[channel][coef_ptr] = channel_data[channel];
+        filtered_data = 0;
+        if (num_samples < NUM_FILTER_TAPS) {
+            num_samples++;
+            avg_data[channel] = channel_data[channel];
+        } else {//run the filter if we have enough samples
+            for(uint8_t n=0; n<NUM_FILTER_TAPS; n++) {
+                //            pc.printf("x = %d\r\n",(*x)[channel][ptr]);
+                filtered_data += lpf[n]*(float)filter_buffer[channel][coef_ptr]; //incrementing throught the coeficients as we go back through samples.
+                if (coef_ptr==0) {
+                    coef_ptr = NUM_FILTER_TAPS-1; //wrap index
+                } else {
+                    coef_ptr--;
+                }
+            }
+            avg_data[channel] = (int32_t)filtered_data;
+        }
+    }
+    ptr++; //increment filter buffer
+    if (ptr == NUM_FILTER_TAPS) {//loop buffer pointer index
+        ptr = 0;
     }
 }
 
 
-int main() `
+
+int main()
 {
 
 //    int32_t channel_data2[NUM_CHANNELS];
 
-    
-    
+
 
-    
-    
-    //int filterdiv = 4; //this is the divisor in the IIR channel filter. 
-//    It adds 1/filterdiv of the difference between the new sample and the average to the new average
-//    This is integer math, so I am sticking to multiples of 2 for now.
+
+
     int32_t checksum2 =0;
     int32_t checksum = 0;
     char checksum_byte = 0;
@@ -109,156 +190,153 @@
     vOut1 = 0.5-vdiff/2;
     vOut2 = 0.5+vdiff/2;
     starting();
-        
+
     bool int_state;
     spi.format(8,MAX11410_SPI_MODE); //configure number of spi bits 8, 16
     spi.frequency(8000000); // Max 8MHz
     //read chip ID
-    
+
     pc.printf("chip ID %d\r\n",adc1.read8bits(REG_PART_ID,&int_state) );
-    
+
     //config ADC 1
     adc1.reset(); //POR chip 1
     adc2.reset(); //POR chip 2
-        
+
     //check default register configs
     pc.printf("default regs for ADC1\r\n");
     print8bitRegsAdc1(REG_PD,REG_WAIT_START);
-    
+
     pc.printf("default regs for ADC2\r\n");
     print8bitRegsAdc2(REG_PD,REG_WAIT_START);
-    
-    //config interrupts, PGA, Buffer, polarity, reference    
+
+    //config interrupts, PGA, Buffer, polarity, reference
     char mode_config = MODE_NORMAL;
     adc1.write8bitReg(REG_PD,mode_config);      //got to normal mode
     adc2.write8bitReg(REG_PD,mode_config);      //got to normal mode
-    
+
     char filter_config = FIR_SIXTY | _RATE(5) ; //five is the max at 35.6 sps
     adc1.write8bitReg( REG_FILTER,filter_config );
     adc2.write8bitReg( REG_FILTER,filter_config );
- 
+
     char ctrl_config = INT_CLOCK | BIPOLAR | TWOS_COMP | _PBUF_EN(0) | _NBUF_EN(0) | REF_AVDD ; //ADC configuration
     adc1.write8bitReg( REG_CTRL, ctrl_config );
     adc2.write8bitReg( REG_CTRL, ctrl_config );
-    
+
     char source_config = VBIAS_ACTIVE | BRN_OFF | _IDAC(0); //not sourcing current
     adc1.write8bitReg( REG_SOURCE,source_config );
     adc2.write8bitReg( REG_SOURCE,source_config );
 
-    uint32_t status_ie_config = DATA_RDY_INT | CAL_RDY_INT | CONV_RDY_INT;   
-    adc1.write24bitReg(REG_STATUS_IE,status_ie_config); 
+    uint32_t status_ie_config = DATA_RDY_INT | CAL_RDY_INT | CONV_RDY_INT;
+    adc1.write24bitReg(REG_STATUS_IE,status_ie_config);
     adc2.write8bitReg( REG_SOURCE,source_config );
-    
+
     char gain_setting = 0;
     char pga_config = PGA | _GAIN_EXP(gain_setting) ; //no gain
     adc1.write8bitReg(REG_PGA,pga_config);
     adc2.write8bitReg(REG_PGA,pga_config);
 
     pc.printf("PGA gain = %d\r\n",1<<gain_setting);
-    
+
     //check register writes
-    pc.printf("checking register writes\r\n");
+    pc.printf("checking register writes ADC1\r\n");
     pc.printf("reg %02x, val %02x, set to %02x\r\n",REG_PD,adc1.read8bits(REG_PD,&int_state),mode_config);
-    pc.printf("reg %02x, val %02x, set to %02x\r\n",REG_FILTER,adc1.read8bits(REG_FILTER,&int_state),filter_config);     
+    pc.printf("reg %02x, val %02x, set to %02x\r\n",REG_FILTER,adc1.read8bits(REG_FILTER,&int_state),filter_config);
     pc.printf("reg %02x, val %02x, set to %02x\r\n",REG_CTRL,adc1.read8bits(REG_CTRL,&int_state),ctrl_config);
     pc.printf("reg %02x, val %02x, set to %02x\r\n",REG_SOURCE,adc1.read8bits(REG_SOURCE,&int_state),source_config);
-    pc.printf("reg %02x, val %06x, set to %06x\r\n",REG_STATUS_IE,adc1.read24bits(REG_STATUS_IE,&int_state),status_ie_config);     
-    pc.printf("reg %02x, val %02x, set to %02x\r\n",REG_PGA,adc1.read8bits(REG_PGA,&int_state),pga_config);    
-    
-        // for each channel 1-5
+    pc.printf("reg %02x, val %06x, set to %06x\r\n",REG_STATUS_IE,adc1.read24bits(REG_STATUS_IE,&int_state),status_ie_config);
+    pc.printf("reg %02x, val %02x, set to %02x\r\n",REG_PGA,adc1.read8bits(REG_PGA,&int_state),pga_config);
+    pc.printf("checking register writes ADC2\r\n");
+    pc.printf("reg %02x, val %02x, set to %02x\r\n",REG_PD,adc2.read8bits(REG_PD,&int_state),mode_config);
+    pc.printf("reg %02x, val %02x, set to %02x\r\n",REG_FILTER,adc2.read8bits(REG_FILTER,&int_state),filter_config);
+    pc.printf("reg %02x, val %02x, set to %02x\r\n",REG_CTRL,adc2.read8bits(REG_CTRL,&int_state),ctrl_config);
+    pc.printf("reg %02x, val %02x, set to %02x\r\n",REG_SOURCE,adc2.read8bits(REG_SOURCE,&int_state),source_config);
+    pc.printf("reg %02x, val %06x, set to %06x\r\n",REG_STATUS_IE,adc2.read24bits(REG_STATUS_IE,&int_state),status_ie_config);
+    pc.printf("reg %02x, val %02x, set to %02x\r\n",REG_PGA,adc2.read8bits(REG_PGA,&int_state),pga_config);
+    // for each channel 1-5
 ///        for(int n=0;n<5;n++)
 ///        {
 ///            //select channel
 ///            char p_ch = 2*n<<4;
 ///            char n_ch = 2*n+1;
 ///            adc1.write8bitReg(REG_MUX_CTRL0, p_ch | n_ch );
-///            
+///
 ///            //select data output register and begin conversion
 ///            adc1.write8bitReg(REG_CONV_START, (_DEST(n) | SINGLE_CONV) );
-///            
+///
 ///            //optional: cal Gain
-///            
+///
 ///            //optional: cal Offset
-///            
+///
 ///            //optional: store cal parameters
-///            
+///
 ///            //begin conversion
-///            
+///
 ///            //wait for interrupt
 ///            while(!adc1.interrupt() )
 ///            {
 ///                wait_ms(CONV_DELAY_MS);//do nothing
 /////                pc.printf("waiting for int");
 ///            }
-///            
+///
 ///            //read conversion
 ///           channel_data[n] = adc1.read24bitsSigned(REG_DATA0+n,&int_state);
-///           pc.printf("%d, ",channel_data[n]);    
+///           pc.printf("%d, ",channel_data[n]);
 ///        } //channel sweep
 ///        pc.printf("\r\n");
 ///
-///    
+///
 ///    //config ADC 2: repeat above
-    
-    
+
+
 
-    pc.printf("beginning while loop");
+    pc.printf("beginning while loop\r\n");
     wait_ms(1000);
-    while(1) 
-    {
-        for(int n=0; n<5; n++)
-        {
-            //setup ADCs to read in parallel 
+    t.start();
+    while(1) {
+        for(int n=0; n<5; n++) {
+            //setup ADCs to read in parallel
             //select channel
             char p_ch = 2*n+1<<4;
             char n_ch = 2*n;
             adc1.write8bitReg(REG_MUX_CTRL0, p_ch | n_ch );
             adc2.write8bitReg(REG_MUX_CTRL0, p_ch | n_ch );
-            
+
             //select data output register and begin conversion
             adc1.write8bitReg(REG_CONV_START, (_DEST(n) | SINGLE_CONV) );
             adc2.write8bitReg(REG_CONV_START, (_DEST(n) | SINGLE_CONV) );
-            
+
             //optional: cal Gain
-            
+
             //optional: cal Offset
-            
+
             //optional: store cal parameters
-            
+
             //begin conversion
-            
+
             //wait for interrupt
-            while(!adc1.interrupt() )
-            {
+            while(!adc1.interrupt() ) {
                 wait_ms(CONV_DELAY_MS);//do nothing
 //                pc.printf("waiting for int");
             }
-            if  (channel_data[n] == 0)
-            {
+            if  (channel_data[n] == 0) {
                 channel_data[n] = adc1.read24bitsSigned(REG_DATA0+n,&int_state);
+            } else {
+                new_data = adc1.read24bitsSigned(REG_DATA0+n,&int_state);
+//                channel_data[n] += (new_data-channel_data[n])/filterdiv;
+                channel_data[n] = new_data;
             }
-            else
-            {
-                new_data = adc1.read24bitsSigned(REG_DATA0+n,&int_state);
-//                channel_data[n] += (new_data-channel_data[n])/filterdiv; 
-                channel_data[n] = new_data; 
-            }
-            while(!adc2.interrupt() )
-            {
+            while(!adc2.interrupt() ) {
                 wait_ms(CONV_DELAY_MS);//do nothing
 //                pc.printf("waiting for int");
             }
             //read conversion
-            if  (channel_data[n+5] == 0)
-            {
+            if  (channel_data[n+5] == 0) {
                 channel_data[n+5] = adc2.read24bitsSigned(REG_DATA0+n,&int_state);
-            }
-            else
-            {
+            } else {
                 new_data = adc2.read24bitsSigned(REG_DATA0+n,&int_state);
                 //channel_data[n+5] += (new_data-channel_data[n+5])/filterdiv;
-                channel_data[n] = new_data;  
-            }               
+                channel_data[n+5] = new_data;
+            }
         }
         //            calc checksum
         checksum = 0x66 + 0x01;
@@ -267,24 +345,21 @@
 //            checksum += channel_data[n];
 //        }
 //        checksum_byte = (char) checksum;
-    
-        for (int n=0; n<NUM_CHANNELS; n++)
-        {
-            for(int m=0;m<4;m++)
-            {
-               byte2print[n*4+m] = getNthByte(channel_data[n],3-m);
-               checksum += getNthByte(channel_data[n],3-m);
-           }
+
+        for (int n=0; n<NUM_CHANNELS; n++) {
+            for(int m=0; m<4; m++) {
+                byte2print[n*4+m] = getNthByte(channel_data[n],3-m);
+                checksum += getNthByte(channel_data[n],3-m);
+            }
         }
         checksum_byte = (char) checksum;
 
         //print data and checksum
-        
+
         //            print header 0x6601
         rpi.putc(0x66);
         rpi.putc(0x01);
-        for (int n =0; n<40;n++)
-        {
+        for (int n =0; n<40; n++) {
             rpi.putc(byte2print[n]);
         }
         rpi.putc( checksum_byte );
@@ -297,15 +372,20 @@
 //        pc.printf("orig  reconstructed\r\n");
 
         get_avgs(); //calculate running average
-        
-        for (int n=0;n<NUM_CHANNELS;n++)
-        {
-            pc.printf("%d, %d\r\n",n,avg_data[n]);
+//        fir(); //run FIR filter on all channels
+
+//        pc.printf("%d, ",t.read_ms());
+        for (int n=0; n<NUM_CHANNELS; n++) {
+//        for (int n=3; n<7; n++) {
+//            pc.printf("%d, %d\r\n",n,avg_data[n]);
+            pc.printf("%d, ",avg_data[n]);
+//            pc.printf("%d, ",channel_data[n]);
         }
+        pc.printf("\r\n");
 //        checksum2 = 0;
 //        for(int n=0;n<NUM_CHANNELS;n++)
 //        {
-//            checksum2 += channel_data2[n];    
+//            checksum2 += channel_data2[n];
 //        }
 //        pc.printf("checksum %02X, %08X, %08X\r\n",checksum_byte,checksum,checksum2);
     } //end while