This use C6:41 cc6250em with Elite.

Hz  : [ 1  2  3  4  5  8  10  20  ]
LED : [ *  -  -  1  1  1  1   0   ]

Notice that the cali_table condition is C7:52

simplelink/ble_sdk_2_02_02_25/examples/cc2650em/simple_peripheral/ccs/app/targetConfigs/CC2650F128.ccxml

@@ -19,7 +19,7 @@
             </property>
             <property Type="choicelist" Value="1" id="Debug Probe Selection">
                 <choice Name="Select by serial number" value="0">
-                    <property Type="stringfield" Value="L1000537" id="-- Enter the serial number"/>
+                    <property Type="stringfield" Value="L1000628" id="-- Enter the serial number"/>
                 </choice>
             </property>
             <platform XML_version="1.2" id="platform_0">

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/neu/headstage_notify.h

@@ -13,17 +13,33 @@
 
 #include "headstage_cali_table.h"
 
-static uint8_t          numFFT = 16;        // user define
-static uint8_t          step = 8;          // which is numFFT/2
-static uint8_t          stageFFT = 4;       // which is log2(numFFT)
-static int twiddle_real[16] = {10000,  9238,  7071,  3826,  0,  -3827,  -7072,  -9239,  -10000,  -9239, \
-                               -7072,  -3827,  -1,  3826,  7071,  9238};
+static uint8_t          numFFT = 64;        // user define
+static uint8_t          step = 32;          // which is numFFT/2
+static uint8_t          stageFFT = 6;       // which is log2(numFFT)
+//static int twiddle_real[16] = {10000,  9238,  7071,  3826,  0,  -3827,  -7072,  -9239,  -10000,  -9239, \
+//                               -7072,  -3827,  -1,  3826,  7071,  9238};
+//
+//static int twiddle_imag[16] = { 0,  -3827,  -7072,  -9239,  -10000,  -9239,  -7072,  -3827,  -1,  3826, \
+//                                 7071,  9238,  10000,  9238,  7071,  3826};
+static int twiddle_real[64] = {10000, 9951, 9807, 9569, 9238, 8819, 8314, 7730, 7071, 6343, \
+                                5555, 4713, 3826, 2902, 1950, 980, 0, -981, -1951, -2903, \
+                                -3827, -4714, -5556, -6344, -7072, -7731, -8315, -8820, -9239, -9570, \
+                                -9808, -9952, -10000, -9952, -9808, -9570, -9239, -8820, -8315, -7731, \
+                                -7072, -6344, -5556, -4714, -3827, -2903, -1951, -981, -1, 980,\
+                                1950, 2902, 3826, 4713, 5555, 6343, 7071, 7730, 8314, 8819, \
+                                9238, 9569, 9807, 9951 };
+
+static int twiddle_imag[64] = { 0, -981, -1951, -2903, -3827, -4714, -5556, -6344, -7072, -7731, \
+                                -8315, -8820, -9239, -9570, -9808, -9952, -10000, -9952, -9808, -9570, \
+                                -9239, -8820, -8315, -7731, -7072, -6344, -5556, -4714, -3827, -2903, \
+                                -1951, -981, -1, 980, 1950, 2902, 3826, 4713, 5555, 6343, \
+                                7071, 7730, 8314, 8819, 9238, 9569, 9807, 9951, 10000, 9951, \
+                                9807, 9569, 9238, 8819, 8314, 7730, 7071, 6343, 5555, 4713, \
+                                3826, 2902, 1950, 980};
 
-static int twiddle_imag[16] = { 0,  -3827,  -7072,  -9239,  -10000,  -9239,  -7072,  -3827,  -1,  3826, \
-                                 7071,  9238,  10000,  9238,  7071,  3826};
 static void FFT(int* pred_LFP, int* imag_LFP, int numFFT);
 static void BitReverse(int* BR_Array, int numFFT);
-static void CLP(uint16_t raw_data);
+static void CLP(int     raw_data);
 static int ADC_U2S( uint16_t unsigned_buff);
 
 
@@ -63,29 +79,40 @@ static void headstage_neu_append_notify_data() {
         // illegal channel
         return;
     }
+
+    uint16_t        borshin_raw;
+    int16_t         borshin_a;
+    int16_t         borshin_b;
+    uint8_t         borshin_sample_rate;
+    int             borshin_real;
+    int             borshin_compute_data;
+    static uint8_t  borshin_sample_count;
+
     uint8_t not_buf[2];
     not_buf[0] = (channel & 0x0F) << 4 | (spi_rxbuf[1] & 0x0F);
     not_buf[1] = spi_rxbuf[2];
 
-    // Borshin closed-loop start here    <<<<<<<<<<<<<<<<<<<<---->>>>>>>>>>>>>>>>>>>>----------------------
-    uint16_t        borshin_raw;
-    uint8_t         borshin_a;
-    uint8_t         borshin_b;
-    uint8_t         borshin_sample_rate;
-    uint16_t        borshin_real;
-
-    borshin_raw = (spi_rxbuf[1]&0x0F)<<8 | spi_rxbuf[2];
-    borshin_a = CaliTable.Ch[channel].Gain[ rec_register_value[REC_CHANNEL_INDEX] ];
-    borshin_b = CaliTable.Ch[channel].Offset[ rec_register_value[REC_CHANNEL_INDEX] ];
-    borshin_real = borshin_raw * borshin_a + borshin_b; //  range from [ FFF , 000 ]
-    borshin_sample_rate = 2000000/10/rec_register_value[REC_ADC_CLOCK_INDEX];
-    CLP(borshin_real);              //  This function input is 12-bit value
-                                    //  the function will buffer 16-point then
-                                    //  perform 16-point FFT.
-                                    //  Afterwards, calculate sum of PSD then
-                                    //  decided if HVS happened. (GPIO_4)
-    // Borshin closed-loop END here    <<<<<<<<<<<<<<<<<<<<----------------------------->>>>>>>>>>>>>>>>>>>>
+    // Borshin FFT start here    <<<<<<<<<<<<<<<<<<<<---->>>>>>>>>>>>>>>>>>>>----------------------
+    borshin_sample_count = !borshin_sample_count;
+    if (borshin_sample_count){
 
+        borshin_raw = (spi_rxbuf[1]&0x0F)<<8 | spi_rxbuf[2];        //  range from [ FFF , 000 ]
+        borshin_a = CaliTable.Ch[channel].Gain[ rec_register_value[REC_CHANNEL_INDEX] ];
+        borshin_b = CaliTable.Ch[channel].Offset[ rec_register_value[REC_CHANNEL_INDEX] ];
+        borshin_real = (borshin_raw - 2048 - borshin_b)*1000/borshin_a;   //  range from +- someting [ no FFF , 000 ]
+        borshin_compute_data = borshin_real >> 10;
+        borshin_sample_rate = 2000000/10/rec_register_value[REC_ADC_CLOCK_INDEX];
+        //    if (borshin_raw<3450&&borshin_raw>600)
+        //        headstage_pin_output(PIN_CLP, 1);
+        //    else
+        //        headstage_pin_output(PIN_CLP, 0);
+        CLP( borshin_compute_data );    //  This function input is 12-bit value
+                                        //  the function will buffer 16-point then
+                                        //  perform 16-point FFT.
+                                        //  Afterwards, calculate sum of PSD then
+                                        //  decided if HVS happened. (GPIO_4)
+        // Borshin FFT END here    <<<<<<<<<<<<<<<<<<<<----------------------------->>>>>>>>>>>>>>>>>>>>
+    }
     uint8_t data_size = headstage_notify_append_data(not_buf);
 
     if (data_size >= BLE_NOT_BUFF_SIZE) {
@@ -234,18 +261,33 @@ static void BitReverse(int* BR_Array, int numFFT){
     uint8_t     n=0;
     int         tmp;
 
+    // for (uint8_t i=0; i<numFFT; i++){
+    //     n = i;                              // printf ("%d %d\n",i,n);
+    //     n = (n&0x0f)<<4  | (n&0xf0)>>4;     // 0123_4567 -> 4567_0123
+    //     n = (n&0x33)<<2  | (n&0xcc)>>2;     // 4567_0123 -> 6745_2301
+    //     n = (n&0xaa)<<2  | (n&0x55)>>1;     // 7856_3412 -> 7654_3210
+    //     n = n >> 1;                         // 7654_3210 -> 0765_4321
+    //     if (n>i){
+    //         tmp = BR_Array[n];
+    //         BR_Array[n] = BR_Array[i];
+    //         BR_Array[i] = tmp;
+    //     }
+    // }
+
+    //  This BIR specify for 6-bit (0000_0000 ~ 0011_1111)
     for (uint8_t i=0; i<numFFT; i++){
         n = i;                              // printf ("%d %d\n",i,n);
-        n = (n&0x0f)<<4  | (n&0xf0)>>4;     // 0123_4567 -> 4567_0123
-        n = (n&0x33)<<2  | (n&0xcc)>>2;     // 4567_0123 -> 6745_2301
-        n = (n&0xaa)<<2  | (n&0x55)>>1;     // 7856_3412 -> 7654_3210
-        n = n >> 1;                         // 7654_3210 -> 0765_4321
+        n = (n&0x07)<<3  | (n)>>3;          // 0012_3456 -> 0045_6123
+        n = (n&0x09)<<2  | (n&0x36)>>1;     // 0045_6123 -> 0064_5312
+        n = (n&0x09)<<1  | (n&0x12)>>1 | (n&0x24);     // 0064_5312 -> 0065_4321
         if (n>i){
             tmp = BR_Array[n];
             BR_Array[n] = BR_Array[i];
             BR_Array[i] = tmp;
         }
     }
+
+
     return;
 }  // END Bit Reverse Order Sort
 
@@ -258,61 +300,53 @@ static void BitReverse(int* BR_Array, int numFFT){
  *
  * @return  None.
  */
-static void CLP(uint16_t unsigned_real_data){
+static void CLP(int     signed_real_data){
 
     int                 signed_buff;
     static int          accumu_sum;
-    static int          x_in[16];
-    static int          real[16];
-    static int          imag[16];
-    static int          count_sample;
-    static int          count_data;
+    static int          x_in[64];
+    static int          real[64];
+    static int          imag[64];
+    static int          count;
     int                 abs_tmp;
-    static int          present, past1, past2, hvs;
-    static int          w[6] = {1597,-1909,1856,-1190,630,23};
 
-    count_sample++;                         //  count+1 every 1-ms
-    if (count_sample>=24){                  //  ensure sample LFP data every 24-ms(41.6667Hz)
-        signed_buff = ADC_U2S(unsigned_real_data); //  FFF ~ 000 to +7FF ~ -7FF
-        x_in[count_data] = signed_buff;
-        real[count_data] = signed_buff;
-        imag[count_data] = 0;
-        count_sample = 0;                   //  re-calculate count
-        count_data++;
-        if (count_data>=6){
-            accumu_sum = 0;
-            for (int i=6;i<numFFT;i++){
-                real[i] = ( w[0] * real[i-1] \
-                          + w[1] * real[i-2] \
-                          + w[2] * real[i-3] \
-                          + w[3] * real[i-4] \
-                          + w[4] * real[i-5] \
-                          + w[5] * real[i-6] )>>10;
-                imag[i] = 0;
-            }
-            BitReverse( real, numFFT);
-            FFT( real, imag, numFFT);
-            for (int i=1;i<6;i++){
-                if (i>=2&&i<=4){
-                    accumu_sum += real[i]*real[i]+imag[i]*imag[i];
+//    signed_buff = ADC_U2S(unsigned_real_data);
+    x_in[count] = signed_real_data;
+    real[count] = signed_real_data;
+    imag[count] = 0;
+    count++;
+    if (count >= numFFT){
+        BitReverse( real, numFFT);
+        FFT( real, imag, numFFT);
+        abs_tmp=0;
+        accumu_sum = 0;
+        for ( int i=0; i<numFFT; i++){
+            accumu_sum = accumu_sum + (real[i]*real[i]+imag[i]*imag[i]);
+            if (i>0){
+                if (i==1){
+                    abs_tmp = real[i]*real[i]+imag[i]*imag[i];
                 }
                 real[i-1] = x_in[i];
                 imag[i-1] = 0;
                 x_in[i-1] = x_in[i];
             }
-            present = (  (accumu_sum>>12)  >  45000 )?1:0;
-            if (present+past1+past2==3)
-                hvs = 1;
-            else
-                hvs = 0;
-            past2 = past1;
-            past1 = present;
-            if (hvs==1)
-                headstage_pin_output(PIN_CLP, 1);
-            else
-                headstage_pin_output(PIN_CLP, 0);
-            count_data--;
         }
+        int   flag;
+        flag = abs_tmp*100/(accumu_sum>>1);
+        if (flag > 62 && flag < 65 ){
+            headstage_pin_output(PIN_CLP, 1);
+        }
+        else {
+            headstage_pin_output(PIN_CLP, 0);
+        }
+//        if (abs_tmp > 300000 ){
+//            headstage_pin_output(PIN_CLP, 1);
+//        }
+//        else {
+//            headstage_pin_output(PIN_CLP, 0);
+//        }
+        count--;
     }
+
     return;
 }