[update] gas1 is true when run done

# Conflicts:
#	simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/headstage.h

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/Elite15_PIN.h

@@ -133,13 +133,11 @@ static void update_latch_status (uint32_t latch_num, uint32_t elite_pin, bool hi
 }
 
 static void PIN15_setOutputValue (uint32_t latch_num, uint32_t pin_num, bool highlow) {
-    if(PeriodicEvent){
-        ELITE15_SPI_CLOSE();
-    }
+    ELITE15_SPI_CLOSE();
     add_elite_pin();
     update_latch_status (latch_num, pin_num, highlow);
-    PIN_setOutputValue(&ZM_rst, latch_num, 1);               // Turn on latch
-    CPUdelay(10);
+//    PIN_setOutputValue(&ZM_rst, latch_num, 1);               // Turn on latch
+
     switch (latch_num) {
         case LOAD0: {
 //            PIN_setOutputValue(&ZM_rst, D0, LH.LATCH0[0]);
@@ -178,23 +176,17 @@ static void PIN15_setOutputValue (uint32_t latch_num, uint32_t pin_num, bool hig
             break;
         }
     }
+    PIN_setOutputValue(&ZM_rst, latch_num, 1);               // Turn on latch
     CPUdelay(10);
     PIN_setOutputValue(&ZM_rst, latch_num, 0);               // Turn off latch
     remove_elite_pin();
-
-    if(PeriodicEvent){
-        ELITE15_SPI_HOLD();
-    }
+    ELITE15_SPI_HOLD();
 }
 
 static void Init_Elite15_PIN () {
     InitLH();
     add_elite_pin();
 
-    PIN_setOutputValue(pin_handle, LOAD0, 1);
-    PIN_setOutputValue(pin_handle, LOAD1, 1);
-    PIN_setOutputValue(pin_handle, LOAD2, 1);
-    CPUdelay(10);
     PIN_setOutputValue(pin_handle, D0, 0);
     PIN_setOutputValue(pin_handle, D1, 0);
     PIN_setOutputValue(pin_handle, D2, 0);
@@ -203,12 +195,49 @@ static void Init_Elite15_PIN () {
     PIN_setOutputValue(pin_handle, D5, 0);
     PIN_setOutputValue(pin_handle, D6, 0);
     PIN_setOutputValue(pin_handle, D7, 0);
-    CPUdelay(10);
     PIN_setOutputValue(pin_handle, LOAD0, 0);
+    PIN_setOutputValue(pin_handle, LOAD1, 1);
+    PIN_setOutputValue(pin_handle, LOAD2, 1);
+    CPUdelay(10);
     PIN_setOutputValue(pin_handle, LOAD1, 0);
     PIN_setOutputValue(pin_handle, LOAD2, 0);
 
+
+    PIN_setOutputValue(pin_handle, D0, 0);
+    PIN_setOutputValue(pin_handle, D1, 0);
+    PIN_setOutputValue(pin_handle, D2, 0);
+    PIN_setOutputValue(pin_handle, D3, 0);
+    PIN_setOutputValue(pin_handle, D4, 1);
+    PIN_setOutputValue(pin_handle, D5, 1);
+    PIN_setOutputValue(pin_handle, D6, 1);
+    PIN_setOutputValue(pin_handle, D7, 1);
+    CPUdelay(10);
+    PIN_setOutputValue(pin_handle, LOAD0, 1);
+    PIN_setOutputValue(pin_handle, LOAD0, 0);
+
     remove_elite_pin();
+
+//    InitLH();
+//    add_elite_pin();
+//
+//    PIN_setOutputValue(pin_handle, LOAD0, 1);
+//    PIN_setOutputValue(pin_handle, LOAD1, 1);
+//    PIN_setOutputValue(pin_handle, LOAD2, 1);
+//    CPUdelay(10);
+//    PIN_setOutputValue(pin_handle, D0, 0);
+//    PIN_setOutputValue(pin_handle, D1, 0);
+//    PIN_setOutputValue(pin_handle, D2, 0);
+//    PIN_setOutputValue(pin_handle, D3, 0);
+//    PIN_setOutputValue(pin_handle, D4, 0);
+//    PIN_setOutputValue(pin_handle, D5, 0);
+//    PIN_setOutputValue(pin_handle, D6, 0);
+//    PIN_setOutputValue(pin_handle, D7, 0);
+//    CPUdelay(10);
+//    PIN_setOutputValue(pin_handle, LOAD0, 0);
+//    PIN_setOutputValue(pin_handle, LOAD1, 0);
+//    PIN_setOutputValue(pin_handle, LOAD2, 0);
+//
+//    remove_elite_pin();
 }
 
 

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteADC.h

@@ -46,11 +46,7 @@ static void ADC_write(uint8_t ADCin) {
     spi_ADC_txbuf[0] = ADCin;
     spi_ADC_txbuf[1] = 0b11101011;
 
-    if(PeriodicEvent){
-        ADC_SPI_TEST(2, spi_ADC_txbuf, spi_ADC_rxbuf);
-    }else{
-        ADC_SPI(2, spi_ADC_txbuf, spi_ADC_rxbuf);
-    }
+    ADC_SPI(2, spi_ADC_txbuf, spi_ADC_rxbuf);
 }
 
 static void ADC_read(uint8_t *ADCdata){
@@ -59,11 +55,7 @@ static void ADC_read(uint8_t *ADCdata){
         spi_ADC_rxbuf[i] = 0;
     }
 
-    if(PeriodicEvent){
-        ADC_SPI_TEST(2, spi_ADC_txbuf, spi_ADC_rxbuf);
-    }else{
-        ADC_SPI(2, spi_ADC_txbuf, spi_ADC_rxbuf);
-    }
+    ADC_SPI(2, spi_ADC_txbuf, spi_ADC_rxbuf);
 }
 
 /* Elite1.5 Calibration Usage */
@@ -246,12 +238,20 @@ static void ReadADCBat(uint8_t *buf){
 
 /* for Elite1.5-re */
 // Iin theoretical boundary <2.67, 1.89~80, 63~2600, >1900 (uA)
+/* Old boundary
 #define I_GAIN_SMALL_BOUNDARY     4000  // 4    uA =     4,000,000 pA
 #define I_GAIN_MID1_BOUNDARY1     2000  // 2    uA =     2,000,000 pA
 #define I_GAIN_MID1_BOUNDARY2    90000  // 90   uA =    90,000,000 pA
 #define I_GAIN_MID2_BOUNDARY1    70000  // 70   uA =    70,000,000 pA
 #define I_GAIN_MID2_BOUNDARY2  1800000  // 1800 uA =     1,800,000 nA
 #define I_GAIN_LARGE_BOUNDARY   950000  // 950  uA =       950,000 nA
+*/
+#define I_GAIN_SMALL_BOUNDARY     4000  // 4    uA =     4,000,000 pA
+#define I_GAIN_MID1_BOUNDARY1     2500  // 2.5  uA =     2,500,000 pA
+#define I_GAIN_MID1_BOUNDARY2   100000  // 100  uA =   100,000,000 pA
+#define I_GAIN_MID2_BOUNDARY1    85000  // 85   uA =    85,000,000 pA
+#define I_GAIN_MID2_BOUNDARY2  2050000  // 2050 uA =     2,050,000 nA
+#define I_GAIN_LARGE_BOUNDARY  1800000  // 1800 uA =     1,800,000 nA
 
 // Vin theoretical boundary <7, 5~200, >100 (mV)
 #define VIN_GAIN_SMALL_BOUNDARY   7000  // 7    mV =     7,000,000 nV

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteCVCurve.h

@@ -210,7 +210,6 @@ static void CV_Vscan(CVMode *CV){
         /*stop condition*/
         if(CV->_cycleNumber == 0){
             PeriodicEvent = false;
-            ELITE15_SPI_CLOSE();
             ModeLED(NO_EVENT);
         }
     }

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteDAC.h

@@ -51,11 +51,7 @@ static uint16_t DAC_outputV(uint16_t voltLV) {
     spi_DACtxbuf[1] = v1;
     spi_DACtxbuf[2] = v2;
 
-    if(PeriodicEvent){
-        DAC_SPI_TEST(SPI_DAC_SIZE, spi_DACtxbuf, spi_rxbuf);
-    }else{
-        DAC_SPI(SPI_DAC_SIZE, spi_DACtxbuf, spi_rxbuf);
-    }
+    DAC_SPI(SPI_DAC_SIZE, spi_DACtxbuf, spi_rxbuf);
 
     return voltLV;
 }
@@ -88,16 +84,20 @@ static int32_t User2Real(uint16_t UserCode){
 
 
 // DAC Vout theoretical boundary <300, 100~ (mV)
-#define DAC_VOUT_GAIN_SMALL_BOUNDARY  100000  // 100  mV =    25500(usercode)
-#define DAC_VOUT_GAIN_LARGE_BOUNDARY  300000  // 300  mV =    26500(usercode)
+#define DAC_VOUT_GAIN_SMALL_BOUNDARY           100000  // 25500(usercode) = 100 mV
+#define DAC_VOUT_GAIN_LARGE_BOUNDARY           300000  // 26500(usercode) = 300 mV
+#define DAC_VOUT_GAIN_LARGE_BOUNDARY_USERCODE   26500  // 26500(usercode) = 300 mV
+#define DAC_VOUT_GAIN_LARGE_BOUNDARY1_USERCODE  23500  // 23500(usercode) = -300 mV
 
-static void AutoGainChangeVout(int32_t RealVolt){
-    RealVolt = (RealVolt - 25000) * 200; // (RealVolt - 25000) / 5 * 1000
+static void AutoGainChangeVout(int32_t userCode){
+    int32_t RealVolt = (userCode - 25000) * 200; // (userCode - 25000) / 5 * 1000  [1uV]
     // switch to 1 level volt(small)   15K
     // switch to 2 level volt(large)   240K
 
     if(INSTRUCTION.VoutGainLevel == VOUT_GAIN_AUTO){
         INSTRUCTION.VoutGainLevel = VOUT_GAIN_15K;
+        VoutGainControl(INSTRUCTION.VoutGainLevel);
+        record_flag = false;
     }
 
     if(INSTRUCTION.VoutGainLevel == VOUT_GAIN_15K){

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteDeviceCorrection.h

@@ -29,7 +29,7 @@
 */
 
 
-#define BOARD_C6D4
+#define BOARD_C7A1
 
 typedef struct _formula{
 
@@ -46,10 +46,11 @@ struct _correction{
     uint16_t Gain0Boundary[2];
     uint16_t Gain1Boundary[4];
     uint16_t Gain2Boundary[2];
+    uint16_t Usercode2DAC15v;
 
 } Correction =
 
-#ifdef BOARD_C6E1
+#ifdef BOARD_C6E1 //not well
 {
 .ADC_volt[0].coeff = (-6251051),
 .ADC_volt[0].offset = 102081366120,
@@ -77,41 +78,45 @@ struct _correction{
 
 .Usercode2DAC[1].coeff = (-10511469),
 .Usercode2DAC[1].offset = 563770560100,
+
+.Usercode2DAC15v = MEGA_15V,
 };
 #endif
 
 #ifdef BOARD_C7A1
 {
-.ADC_volt[0].coeff = (6204),
-.ADC_volt[0].offset = -100237253,
+.ADC_volt[0].coeff = (6256),
+.ADC_volt[0].offset = -101532028,
 
-.ADC_volt[1].coeff = (214511),
-.ADC_volt[1].offset = -3485722036,
+.ADC_volt[1].coeff = (215138),
+.ADC_volt[1].offset = -3501890770,
 
-.ADC_volt[2].coeff = (6213224),
-.ADC_volt[2].offset = -101104189300,
+.ADC_volt[2].coeff = (6245014),
+.ADC_volt[2].offset = -101751226981,
 
-.ADC_current[0].coeff = 2078892,
-.ADC_current[0].offset = (-33685110900),
+.ADC_current[0].coeff = 3125920,
+.ADC_current[0].offset = (-50880328288),
 
-.ADC_current[1].coeff = 64769469,
-.ADC_current[1].offset = (-1048938859469),
+.ADC_current[1].coeff = 71636129,
+.ADC_current[1].offset = (-1166093783868),
 
-.ADC_current[2].coeff = 2090182091,
-.ADC_current[2].offset = (-33847893234994),
+.ADC_current[2].coeff = 1459555637,
+.ADC_current[2].offset = (-23757721396024),
 
-.ADC_current[3].coeff = 60030468992,
-.ADC_current[3].offset = (-972275155887907),
+.ADC_current[3].coeff = 30723232882,
+.ADC_current[3].offset = (-500144809348170),
 
-.Usercode2DAC[0].coeff = (-10512772),
-.Usercode2DAC[0].offset = 581302323013,
+.Usercode2DAC[0].coeff = (-10543817),
+.Usercode2DAC[0].offset = 583163641972,
 
-.Usercode2DAC[1].coeff = (-178991273),
-.Usercode2DAC[1].offset = 4794464882260,
+.Usercode2DAC[1].coeff = (-178077711),
+.Usercode2DAC[1].offset = 4777894559527,
+
+.Usercode2DAC15v = 41485,
 };
 #endif
 
-#ifdef BOARD_C6D4
+#ifdef BOARD_C6D4  //not well
 {
 .ADC_volt[0].coeff = (6226),
 .ADC_volt[0].offset = -100075170,
@@ -139,6 +144,107 @@ struct _correction{
 
 .Usercode2DAC[1].coeff = (-178746005),
 .Usercode2DAC[1].offset = 4789272862069,
+
+.Usercode2DAC15v = MEGA_15V,
+};
+#endif
+
+#ifdef BOARD_C771 //not well
+{
+.ADC_volt[0].coeff = (6301),
+.ADC_volt[0].offset = -102184705,
+
+.ADC_volt[1].coeff = (216877),
+.ADC_volt[1].offset = -3519583281,
+
+.ADC_volt[2].coeff = (6298448),
+.ADC_volt[2].offset = -102304286091,
+
+.ADC_current[0].coeff = 3115431,
+.ADC_current[0].offset = (-50586460394),
+
+.ADC_current[1].coeff = 71203612,
+.ADC_current[1].offset = (-1156022105141),
+
+.ADC_current[2].coeff = 1451318434,
+.ADC_current[2].offset = (-23560731221983),
+
+.ADC_current[3].coeff = 30518004246,
+.ADC_current[3].offset = (-495456618814855),
+
+.Usercode2DAC[0].coeff = (-10568719),
+.Usercode2DAC[0].offset = 585036272447,
+
+.Usercode2DAC[1].coeff = (-179441058),
+.Usercode2DAC[1].offset = 4807380622351,
+
+.Usercode2DAC15v = MEGA_15V,
+};
+#endif
+
+#ifdef BOARD_C724
+{
+.ADC_volt[0].coeff = (6251),
+.ADC_volt[0].offset = -99750397,
+
+.ADC_volt[1].coeff = (214419),
+.ADC_volt[1].offset = -3491659841,
+
+.ADC_volt[2].coeff = (6227737),
+.ADC_volt[2].offset = -101557618268,
+
+.ADC_current[0].coeff = 3138613,
+.ADC_current[0].offset = (-51149570420),
+
+.ADC_current[1].coeff = 71715555,
+.ADC_current[1].offset = (-1168777305352),
+
+.ADC_current[2].coeff = 1455501991,
+.ADC_current[2].offset = (-23719715469357),
+
+.ADC_current[3].coeff = 30688298312,
+.ADC_current[3].offset = (-500150163983795),
+
+.Usercode2DAC[0].coeff = (-10540182),
+.Usercode2DAC[0].offset = 584459109821,
+
+.Usercode2DAC[1].coeff = (-179175265),
+.Usercode2DAC[1].offset = 4801179734836,
+
+.Usercode2DAC15v = MEGA_15V,
+};
+#endif
+
+#ifdef BOARD_C874
+{
+.ADC_volt[0].coeff = (6260),
+.ADC_volt[0].offset = -99787811,
+
+.ADC_volt[1].coeff = (214494),
+.ADC_volt[1].offset = -3492178752,
+
+.ADC_volt[2].coeff = (6231057),
+.ADC_volt[2].offset = -101591914655,
+
+.ADC_current[0].coeff = 3148251,
+.ADC_current[0].offset = (-51277675282),
+
+.ADC_current[1].coeff = 71859885,
+.ADC_current[1].offset = (-1170556644217),
+
+.ADC_current[2].coeff = 1462458824,
+.ADC_current[2].offset = (-23822062635236),
+
+.ADC_current[3].coeff = 30748473913,
+.ADC_current[3].offset = (-500860829105930),
+
+.Usercode2DAC[0].coeff = (-10570366),
+.Usercode2DAC[0].offset = 585189864243,
+
+.Usercode2DAC[1].coeff = (-178920333),
+.Usercode2DAC[1].offset = 4794801719146,
+
+.Usercode2DAC15v = 41355,
 };
 #endif
 
@@ -259,8 +365,6 @@ static void ADC_overflow(uint8_t gain, uint8_t *rawdata){
 // this function should turn 0~50000 into DACcode which output the exactly voltage user want
 static uint16_t Usercode_Correction_to_DAC(uint8_t DACGain, uint16_t usercode)
 {
-    AutoGainChangeVout(usercode);
-
     long long usercode_32;
     uint16_t DACcode = 0;
 

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteFlagCTInit.h

@@ -22,6 +22,11 @@ struct _GPT{
     uint32_t BatteryADCCounter;
     uint32_t BatteryCheckCounter;
     uint32_t GptimerMultiple;
+    uint32_t StiCounter;
+    uint32_t LedGCounter;
+    uint32_t LedRCounter;
+    uint32_t Gas0Counter;
+    uint32_t Gas1Counter;
 }GPT = {0};
 
 static void InitCT(){
@@ -41,5 +46,10 @@ static void InitGPT(){
     GPT.LeadTimeCounter     = 0;
     GPT.BatteryADCCounter   = 0;
     GPT.BatteryCheckCounter = 0;
+    GPT.StiCounter          = 0;
+    GPT.LedGCounter         = 0;
+    GPT.LedRCounter         = 0;
+    GPT.Gas0Counter         = 0;
+    GPT.Gas1Counter         = 0;
 }
 #endif

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteIVCurve.h

@@ -28,13 +28,11 @@ static void IV_Vscan(IVMode *IV){
         if(IV->_current_direction_up){
             if(Vset >= IV->_Vmax){
                 PeriodicEvent = false;
-                ELITE15_SPI_CLOSE();
                 ModeLED(NO_EVENT);
             }
         }else{
             if(Vset <= IV->_Vmin){
                 PeriodicEvent = false;
-                ELITE15_SPI_CLOSE();
                 ModeLED(NO_EVENT);
             }
         }

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteInstruction.h

@@ -75,6 +75,90 @@ struct HEADSTAGE_INSTRUCTION {
     uint8_t  charge;
     int32_t  constantCurrent;
     int32_t  Currentmax;
+    int32_t  sti_v1;
+    int32_t  sti_v2;
+    int32_t  sti_v3;
+    int32_t  sti_v4;
+    int32_t  sti_v5;
+    int32_t  sti_v6;
+    int32_t  sti_v7;
+    int32_t  sti_t1;
+    int32_t  sti_t2;
+    int32_t  sti_t3;
+    int32_t  sti_t4;
+    int32_t  sti_t5;
+    int32_t  sti_t6;
+    int32_t  sti_t7;
+    uint16_t sti_cy;
+    uint16_t sti_loop;
+
+    uint8_t  ledG_sw1;
+    uint8_t  ledG_sw2;
+    uint8_t  ledG_sw3;
+    uint8_t  ledG_sw4;
+    uint8_t  ledG_sw5;
+    uint8_t  ledG_sw6;
+    uint8_t  ledG_sw7;
+    int32_t  ledG_t1;
+    int32_t  ledG_t2;
+    int32_t  ledG_t3;
+    int32_t  ledG_t4;
+    int32_t  ledG_t5;
+    int32_t  ledG_t6;
+    int32_t  ledG_t7;
+    uint16_t ledG_cy;
+    uint16_t ledG_loop;
+
+    uint8_t  ledR_sw1;
+    uint8_t  ledR_sw2;
+    uint8_t  ledR_sw3;
+    uint8_t  ledR_sw4;
+    uint8_t  ledR_sw5;
+    uint8_t  ledR_sw6;
+    uint8_t  ledR_sw7;
+    int32_t  ledR_t1;
+    int32_t  ledR_t2;
+    int32_t  ledR_t3;
+    int32_t  ledR_t4;
+    int32_t  ledR_t5;
+    int32_t  ledR_t6;
+    int32_t  ledR_t7;
+    uint16_t ledR_cy;
+    uint16_t ledR_loop;
+
+    uint8_t  gas0_sw1;
+    uint8_t  gas0_sw2;
+    uint8_t  gas0_sw3;
+    uint8_t  gas0_sw4;
+    uint8_t  gas0_sw5;
+    uint8_t  gas0_sw6;
+    uint8_t  gas0_sw7;
+    int32_t  gas0_t1;
+    int32_t  gas0_t2;
+    int32_t  gas0_t3;
+    int32_t  gas0_t4;
+    int32_t  gas0_t5;
+    int32_t  gas0_t6;
+    int32_t  gas0_t7;
+    uint16_t gas0_cy;
+    uint16_t gas0_loop;
+
+    uint8_t  gas1_sw1;
+    uint8_t  gas1_sw2;
+    uint8_t  gas1_sw3;
+    uint8_t  gas1_sw4;
+    uint8_t  gas1_sw5;
+    uint8_t  gas1_sw6;
+    uint8_t  gas1_sw7;
+    int32_t  gas1_t1;
+    int32_t  gas1_t2;
+    int32_t  gas1_t3;
+    int32_t  gas1_t4;
+    int32_t  gas1_t5;
+    int32_t  gas1_t6;
+    int32_t  gas1_t7;
+    uint16_t gas1_cy;
+    uint16_t gas1_loop;
 
     uint16_t StepTime;
 
@@ -121,5 +205,91 @@ static void InitEliteInstruction(){
     INSTRUCTION.Currentmax      = 0;
     INSTRUCTION.StepTime        = STEPTIME_ONE_SEC;
     INSTRUCTION.AdcChannel      = 0;
+
+    //pulse mode
+    INSTRUCTION.sti_t1          = 0;
+    INSTRUCTION.sti_t2          = 0;
+    INSTRUCTION.sti_t3          = 0;
+    INSTRUCTION.sti_t4          = 0;
+    INSTRUCTION.sti_t5          = 0;
+    INSTRUCTION.sti_t6          = 0;
+    INSTRUCTION.sti_t7          = 0;
+    INSTRUCTION.sti_v1          = DAC_ZERO;
+    INSTRUCTION.sti_v2          = DAC_ZERO;
+    INSTRUCTION.sti_v3          = DAC_ZERO;
+    INSTRUCTION.sti_v4          = DAC_ZERO;
+    INSTRUCTION.sti_v5          = DAC_ZERO;
+    INSTRUCTION.sti_v6          = DAC_ZERO;
+    INSTRUCTION.sti_v7          = DAC_ZERO;
+    INSTRUCTION.sti_loop        = 1;
+    INSTRUCTION.sti_cy          = 0;
+
+    INSTRUCTION.ledG_sw1        = false;
+    INSTRUCTION.ledG_sw2        = false;
+    INSTRUCTION.ledG_sw3        = false;
+    INSTRUCTION.ledG_sw4        = false;
+    INSTRUCTION.ledG_sw5        = false;
+    INSTRUCTION.ledG_sw6        = false;
+    INSTRUCTION.ledG_sw7        = false;
+    INSTRUCTION.ledG_t1         = 0;
+    INSTRUCTION.ledG_t2         = 0;
+    INSTRUCTION.ledG_t3         = 0;
+    INSTRUCTION.ledG_t4         = 0;
+    INSTRUCTION.ledG_t5         = 0;
+    INSTRUCTION.ledG_t6         = 0;
+    INSTRUCTION.ledG_t7         = 0;
+    INSTRUCTION.ledG_cy         = 0;
+    INSTRUCTION.ledG_loop       = 0;
+
+    INSTRUCTION.ledR_sw1        = false;
+    INSTRUCTION.ledR_sw2        = false;
+    INSTRUCTION.ledR_sw3        = false;
+    INSTRUCTION.ledR_sw4        = false;
+    INSTRUCTION.ledR_sw5        = false;
+    INSTRUCTION.ledR_sw6        = false;
+    INSTRUCTION.ledR_sw7        = false;
+    INSTRUCTION.ledR_t1         = 0;
+    INSTRUCTION.ledR_t2         = 0;
+    INSTRUCTION.ledR_t3         = 0;
+    INSTRUCTION.ledR_t4         = 0;
+    INSTRUCTION.ledR_t5         = 0;
+    INSTRUCTION.ledR_t6         = 0;
+    INSTRUCTION.ledR_t7         = 0;
+    INSTRUCTION.ledR_cy         = 0;
+    INSTRUCTION.ledR_loop       = 0;
+
+    INSTRUCTION.gas0_sw1        = false;
+    INSTRUCTION.gas0_sw2        = false;
+    INSTRUCTION.gas0_sw3        = false;
+    INSTRUCTION.gas0_sw4        = false;
+    INSTRUCTION.gas0_sw5        = false;
+    INSTRUCTION.gas0_sw6        = false;
+    INSTRUCTION.gas0_sw7        = false;
+    INSTRUCTION.gas0_t1         = 0;
+    INSTRUCTION.gas0_t2         = 0;
+    INSTRUCTION.gas0_t3         = 0;
+    INSTRUCTION.gas0_t4         = 0;
+    INSTRUCTION.gas0_t5         = 0;
+    INSTRUCTION.gas0_t6         = 0;
+    INSTRUCTION.gas0_t7         = 0;
+    INSTRUCTION.gas0_cy         = 0;
+    INSTRUCTION.gas0_loop       = 0;
+
+    INSTRUCTION.gas1_sw1        = false;
+    INSTRUCTION.gas1_sw2        = false;
+    INSTRUCTION.gas1_sw3        = false;
+    INSTRUCTION.gas1_sw4        = false;
+    INSTRUCTION.gas1_sw5        = false;
+    INSTRUCTION.gas1_sw6        = false;
+    INSTRUCTION.gas1_sw7        = false;
+    INSTRUCTION.gas1_t1         = 0;
+    INSTRUCTION.gas1_t2         = 0;
+    INSTRUCTION.gas1_t3         = 0;
+    INSTRUCTION.gas1_t4         = 0;
+    INSTRUCTION.gas1_t5         = 0;
+    INSTRUCTION.gas1_t6         = 0;
+    INSTRUCTION.gas1_t7         = 0;
+    INSTRUCTION.gas1_cy         = 0;
+    INSTRUCTION.gas1_loop       = 0;
 }
 #endif

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteLED.h

@@ -18,11 +18,7 @@ static void LED_color(uint8_t bright, uint8_t red, uint8_t green, uint8_t blue)
     spi_LEDtxbuf[SPI_LED_SIZE - 2] = 0xffff;
     spi_LEDtxbuf[SPI_LED_SIZE - 1] = 0xffff;
 
-    if(PeriodicEvent){
-        LED_SPI_TEST(SPI_LED_SIZE, spi_LEDtxbuf, spi_LEDrxbuf);
-    }else{
-        LED_SPI(SPI_LED_SIZE, spi_LEDtxbuf, spi_LEDrxbuf);
-    }
+    LED_SPI(SPI_LED_SIZE, spi_LEDtxbuf, spi_LEDrxbuf);
 
 }
 
@@ -153,6 +149,11 @@ static void WorkModeLED() {
         WORKLED();
         break;
     }
+    case PULSE_MODE:{
+//        Elite_led_color(COLOR_YELLOW);
+        WORKLED();
+        break;
+    }
     case CONSTANT_CURRENT:{
         WORKLED();
         break;

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/ElitePulseMode.h

@@ -0,0 +1,528 @@
+#ifndef ELITEPULSE
+#define ELITEPULSE
+
+#define Vset INSTRUCTION.Vset
+
+static void PULSE_Vscan(PULSEMode *PULSE)
+{
+    static uint16_t lastVolt;
+    static uint16_t testV;
+    if (stiFirstTime) {
+        stiFirstTime = false;
+        lastVolt = 25000;
+        PULSE->_sti_t_flag = 1;
+        PULSE->_sti_v = PULSE->_sti_v1;
+        PULSE->_sti_t = PULSE->_sti_t1;
+        if (PULSE->_sti_t == 1) {
+            PULSE->_sti_v = lastVolt;
+        }
+    } else if(!stiFirstTime) {
+        if (GPT.StiCounter >= PULSE->_sti_t) {
+            GPT.StiCounter -= PULSE->_sti_t; //to get right time
+
+            if (PULSE->_sti_lp > 0) {
+                if (PULSE->_sti_cy > 0) {
+                    if (PULSE->_sti_t_flag == 1) {
+                        PULSE->_sti_t_flag = 2;
+                        PULSE->_sti_v = PULSE->_sti_v2;
+                        PULSE->_sti_t = PULSE->_sti_t2;
+                        if (PULSE->_sti_t == 1) {
+                            PULSE->_sti_v = lastVolt;
+                        }
+                    } else if (PULSE->_sti_t_flag == 2) {
+                        PULSE->_sti_t_flag = 3;
+                        PULSE->_sti_v = PULSE->_sti_v3;
+                        PULSE->_sti_t = PULSE->_sti_t3;
+                        if (PULSE->_sti_t == 1) {
+                            PULSE->_sti_v = lastVolt;
+                        }
+                    } else if (PULSE->_sti_t_flag == 3) {
+                        PULSE->_sti_cy -- ;
+                        if (PULSE->_sti_cy == 0) {
+                            PULSE->_sti_t_flag = 4;
+                            PULSE->_sti_v = PULSE->_sti_v4;
+                            PULSE->_sti_t = PULSE->_sti_t4;
+                            if (PULSE->_sti_t == 1) {
+                                PULSE->_sti_v = lastVolt;
+                            }
+                        } else {
+                            PULSE->_sti_t_flag = 2;
+                            PULSE->_sti_v = PULSE->_sti_v2;
+                            PULSE->_sti_t = PULSE->_sti_t2;
+                            if (PULSE->_sti_t == 1) {
+                                PULSE->_sti_v = lastVolt;
+                            }
+                        }
+                    }
+                } else if (PULSE->_sti_cy <= 0){
+                    if (PULSE->_sti_t_flag == 4) {
+                        PULSE->_sti_lp -- ;
+                        if (PULSE->_sti_lp > 0) {
+                            PULSE->_sti_cy = INSTRUCTION.sti_cy;
+                            PULSE->_sti_t_flag = 2;
+                            PULSE->_sti_v = PULSE->_sti_v2;
+                            PULSE->_sti_t = PULSE->_sti_t2;
+                            if (PULSE->_sti_t == 1) {
+                                PULSE->_sti_v = lastVolt;
+                            }
+                        } else {
+                            PULSE->_sti_t_flag = 5;
+                            PULSE->_sti_v = PULSE->_sti_v5;
+                            PULSE->_sti_t = PULSE->_sti_t5;
+                            if (PULSE->_sti_t == 1) {
+                                PULSE->_sti_v = lastVolt;
+                            }
+                        }
+                    }
+                }
+            } else if (PULSE->_sti_lp <= 0) {
+                if (PULSE->_sti_t_flag == 5) {
+                    PULSE->_sti_t_flag = 6;
+                    PULSE->_sti_v = PULSE->_sti_v6;
+                    PULSE->_sti_t = PULSE->_sti_t6;
+                    if (PULSE->_sti_t == 1) {
+                        PULSE->_sti_v = lastVolt;
+                    }
+                } else if (PULSE->_sti_t_flag == 6) {
+                    PULSE->_sti_t_flag = 7;
+                    PULSE->_sti_v = PULSE->_sti_v7;
+                    PULSE->_sti_t = PULSE->_sti_t7;
+                    if (PULSE->_sti_t == 1) {
+                        PULSE->_sti_v = lastVolt;
+                    }
+                } else if (PULSE->_sti_t_flag == 7) {
+                    PULSE->_sti_v = 25000;
+                    PeriodicEvent  = false;
+                    megaTrigEnable = false;
+                    ModeLED(NO_EVENT);
+                }
+            }
+        }
+    }
+
+    //InputNotify(NOTIFY_IMPEDANCE, testV);
+
+    if (lastVolt != PULSE->_sti_v) {
+        lastVolt = PULSE->_sti_v;
+        //if (PULSE->_sti_v == 25000) {
+        //    PIN15_setOutputValue(HIGH_Z_MODE, 0);   // 1 => close high_z mode
+        //} else {
+        //    PIN15_setOutputValue(HIGH_Z_MODE, 1);   // 1 => close high_z mode
+        //}
+        DAC_outputV(Usercode_Correction_to_DAC(VOUT_GAIN_240K, PULSE->_sti_v));
+        DAC_outputV(Usercode_Correction_to_DAC(VOUT_GAIN_240K, PULSE->_sti_v));
+    }
+}
+
+static void PULSE_ledG(PULSEMode *PULSE)
+{
+    static bool lastSwitch;
+
+    if (ledGFirstTime) {
+        ledGFirstTime = false;
+        lastSwitch = false;
+        PULSE->_ledG_t_flag = 1;
+        PULSE->_ledG_sw = PULSE->_ledG_sw1;
+        PULSE->_ledG_t = PULSE->_ledG_t1;
+        if (PULSE->_ledG_t == 1) {
+            PULSE->_ledG_sw = lastSwitch;
+        }
+    } else if(!ledGFirstTime) {
+        if (GPT.LedGCounter >= PULSE->_ledG_t) {
+            GPT.LedGCounter -= PULSE->_ledG_t; //to get right time
+
+            if (PULSE->_ledG_lp > 0) {
+                if (PULSE->_ledG_cy > 0) {
+                    if (PULSE->_ledG_t_flag == 1) {
+                        PULSE->_ledG_t_flag = 2;
+                        PULSE->_ledG_sw = PULSE->_ledG_sw2;
+                        PULSE->_ledG_t  = PULSE->_ledG_t2;
+                        if (PULSE->_ledG_t == 1) {
+                            PULSE->_ledG_sw = lastSwitch;
+                        }
+                    } else if (PULSE->_ledG_t_flag == 2) {
+                        PULSE->_ledG_t_flag = 3;
+                        PULSE->_ledG_sw = PULSE->_ledG_sw3;
+                        PULSE->_ledG_t = PULSE->_ledG_t3;
+                        if (PULSE->_ledG_t == 1) {
+                            PULSE->_ledG_sw = lastSwitch;
+                        }
+                    } else if (PULSE->_ledG_t_flag == 3) {
+                        PULSE->_ledG_cy -- ;
+                        if (PULSE->_ledG_cy == 0) {
+                            PULSE->_ledG_t_flag = 4;
+                            PULSE->_ledG_sw = PULSE->_ledG_sw4;
+                            PULSE->_ledG_t = PULSE->_ledG_t4;
+                            if (PULSE->_ledG_t == 1) {
+                                PULSE->_ledG_sw = lastSwitch;
+                            }
+                        } else {
+                            PULSE->_ledG_t_flag = 2;
+                            PULSE->_ledG_sw = PULSE->_ledG_sw2;
+                            PULSE->_ledG_t = PULSE->_ledG_t2;
+                            if (PULSE->_ledG_t == 1) {
+                                PULSE->_ledG_sw = lastSwitch;
+                            }
+                        }
+                    }
+                } else if (PULSE->_ledG_cy <= 0){
+                    if (PULSE->_ledG_t_flag == 4) {
+                        PULSE->_ledG_lp -- ;
+                        if (PULSE->_ledG_lp > 0) {
+                            PULSE->_ledG_cy = INSTRUCTION.ledG_cy;
+                            PULSE->_ledG_t_flag = 2;
+                            PULSE->_ledG_sw = PULSE->_ledG_sw2;
+                            PULSE->_ledG_t = PULSE->_ledG_t2;
+                            if (PULSE->_ledG_t == 1) {
+                                PULSE->_ledG_sw = lastSwitch;
+                            }
+                        } else {
+                            PULSE->_ledG_t_flag = 5;
+                            PULSE->_ledG_sw = PULSE->_ledG_sw5;
+                            PULSE->_ledG_t = PULSE->_ledG_t5;
+                            if (PULSE->_ledG_t == 1) {
+                                PULSE->_ledG_sw = lastSwitch;
+                            }
+                        }
+                    }
+                }
+            } else if (PULSE->_ledG_lp <= 0) {
+                if (PULSE->_ledG_t_flag == 5) {
+                    PULSE->_ledG_t_flag = 6;
+                    PULSE->_ledG_sw = PULSE->_ledG_sw6;
+                    PULSE->_ledG_t = PULSE->_ledG_t6;
+                    if (PULSE->_ledG_t == 1) {
+                        PULSE->_ledG_sw = lastSwitch;
+                    }
+                } else if (PULSE->_ledG_t_flag == 6) {
+                    PULSE->_ledG_t_flag = 7;
+                    PULSE->_ledG_sw = PULSE->_ledG_sw7;
+                    PULSE->_ledG_t = PULSE->_ledG_t7;
+                    if (PULSE->_ledG_t == 1) {
+                        PULSE->_ledG_sw = lastSwitch;
+                    }
+                } else if (PULSE->_ledG_t_flag == 7) {
+                    PULSE->_ledG_sw = false;
+                    //PeriodicEvent  = false;
+                    //megaTrigEnable = false;
+                    //ModeLED(NO_EVENT);
+                }
+            }
+        }
+    }
+
+    if (lastSwitch != PULSE->_ledG_sw) {
+        lastSwitch = PULSE->_ledG_sw;
+        PIN15_setOutputValue(MEGA_G_LED, PULSE->_ledG_sw);
+    }
+}
+
+static void PULSE_ledR(PULSEMode *PULSE)
+{
+    static bool lastSwitch;
+
+    if (ledRFirstTime) {
+        ledRFirstTime = false;
+        lastSwitch = false;
+        PULSE->_ledR_t_flag = 1;
+        PULSE->_ledR_sw = PULSE->_ledR_sw1;
+        PULSE->_ledR_t = PULSE->_ledR_t1;
+        if (PULSE->_ledR_t == 1) {
+            PULSE->_ledR_sw = lastSwitch;
+        }
+    } else if(!ledRFirstTime) {
+        if (GPT.LedRCounter >= PULSE->_ledR_t) {
+            GPT.LedRCounter -= PULSE->_ledR_t; //to get right time
+
+            if (PULSE->_ledR_lp > 0) {
+                if (PULSE->_ledR_cy > 0) {
+                    if (PULSE->_ledR_t_flag == 1) {
+                        PULSE->_ledR_t_flag = 2;
+                        PULSE->_ledR_sw = PULSE->_ledR_sw2;
+                        PULSE->_ledR_t = PULSE->_ledR_t2;
+                        if (PULSE->_ledR_t == 1) {
+                            PULSE->_ledR_sw = lastSwitch;
+                        }
+                    } else if (PULSE->_ledR_t_flag == 2) {
+                        PULSE->_ledR_t_flag = 3;
+                        PULSE->_ledR_sw = PULSE->_ledR_sw3;
+                        PULSE->_ledR_t = PULSE->_ledR_t3;
+                        if (PULSE->_ledR_t == 1) {
+                            PULSE->_ledR_sw = lastSwitch;
+                        }
+                    } else if (PULSE->_ledR_t_flag == 3) {
+                        PULSE->_ledR_cy -- ;
+                        if (PULSE->_ledR_cy == 0) {
+                            PULSE->_ledR_t_flag = 4;
+                            PULSE->_ledR_sw = PULSE->_ledR_sw4;
+                            PULSE->_ledR_t = PULSE->_ledR_t4;
+                            if (PULSE->_ledR_t == 1) {
+                                PULSE->_ledR_sw = lastSwitch;
+                            }
+                        } else {
+                            PULSE->_ledR_t_flag = 2;
+                            PULSE->_ledR_sw = PULSE->_ledR_sw2;
+                            PULSE->_ledR_t = PULSE->_ledR_t2;
+                            if (PULSE->_ledR_t == 1) {
+                                PULSE->_ledR_sw = lastSwitch;
+                            }
+                        }
+                    }
+                } else if (PULSE->_ledR_cy <= 0){
+                    if (PULSE->_ledR_t_flag == 4) {
+                        PULSE->_ledR_lp -- ;
+                        if (PULSE->_ledR_lp > 0) {
+                            PULSE->_ledR_cy = INSTRUCTION.ledR_cy;
+                            PULSE->_ledR_t_flag = 2;
+                            PULSE->_ledR_sw = PULSE->_ledR_sw2;
+                            PULSE->_ledR_t = PULSE->_ledR_t2;
+                            if (PULSE->_ledR_t == 1) {
+                                PULSE->_ledR_sw = lastSwitch;
+                            }
+                        } else {
+                            PULSE->_ledR_t_flag = 5;
+                            PULSE->_ledR_sw = PULSE->_ledR_sw5;
+                            PULSE->_ledR_t = PULSE->_ledR_t5;
+                            if (PULSE->_ledR_t == 1) {
+                                PULSE->_ledR_sw = lastSwitch;
+                            }
+                        }
+                    }
+                }
+            } else if (PULSE->_ledR_lp <= 0) {
+                if (PULSE->_ledR_t_flag == 5) {
+                    PULSE->_ledR_t_flag = 6;
+                    PULSE->_ledR_sw = PULSE->_ledR_sw6;
+                    PULSE->_ledR_t = PULSE->_ledR_t6;
+                    if (PULSE->_ledR_t == 1) {
+                        PULSE->_ledR_sw = lastSwitch;
+                    }
+                } else if (PULSE->_ledR_t_flag == 6) {
+                    PULSE->_ledR_t_flag = 7;
+                    PULSE->_ledR_sw = PULSE->_ledR_sw7;
+                    PULSE->_ledR_t = PULSE->_ledR_t7;
+                    if (PULSE->_ledR_t == 1) {
+                        PULSE->_ledR_sw = lastSwitch;
+                    }
+                } else if (PULSE->_ledR_t_flag == 7) {
+                    PULSE->_ledR_sw = false;
+                    //PeriodicEvent  = false;
+                    //megaTrigEnable = false;
+                    //ModeLED(NO_EVENT);
+                }
+            }
+        }
+    }
+
+    if (lastSwitch != PULSE->_ledR_sw) {
+        lastSwitch = PULSE->_ledR_sw;
+        PIN15_setOutputValue(MEGA_R_LED, PULSE->_ledR_sw);
+    }
+}
+
+static void PULSE_gas0(PULSEMode *PULSE)
+{
+    static bool lastSwitch;
+
+    if (gas0FirstTime) {
+        gas0FirstTime = false;
+        lastSwitch = false;
+        PULSE->_gas0_t_flag = 1;
+        PULSE->_gas0_sw = PULSE->_gas0_sw1;
+        PULSE->_gas0_t = PULSE->_gas0_t1;
+        if (PULSE->_gas0_t == 1) {
+            PULSE->_gas0_sw = lastSwitch;
+        }
+    } else if(!gas0FirstTime) {
+        if (GPT.Gas0Counter >= PULSE->_gas0_t) {
+            GPT.Gas0Counter -= PULSE->_gas0_t; //to get right time
+
+            if (PULSE->_gas0_lp > 0) {
+                if (PULSE->_gas0_cy > 0) {
+                    if (PULSE->_gas0_t_flag == 1) {
+                        PULSE->_gas0_t_flag = 2;
+                        PULSE->_gas0_sw = PULSE->_gas0_sw2;
+                        PULSE->_gas0_t = PULSE->_gas0_t2;
+                        if (PULSE->_gas0_t == 1) {
+                            PULSE->_gas0_sw = lastSwitch;
+                        }
+                    } else if (PULSE->_gas0_t_flag == 2) {
+                        PULSE->_gas0_t_flag = 3;
+                        PULSE->_gas0_sw = PULSE->_gas0_sw3;
+                        PULSE->_gas0_t = PULSE->_gas0_t3;
+                        if (PULSE->_gas0_t == 1) {
+                            PULSE->_gas0_sw = lastSwitch;
+                        }
+                    } else if (PULSE->_gas0_t_flag == 3) {
+                        PULSE->_gas0_cy -- ;
+                        if (PULSE->_gas0_cy == 0) {
+                            PULSE->_gas0_t_flag = 4;
+                            PULSE->_gas0_sw = PULSE->_gas0_sw4;
+                            PULSE->_gas0_t = PULSE->_gas0_t4;
+                            if (PULSE->_gas0_t == 1) {
+                                PULSE->_gas0_sw = lastSwitch;
+                            }
+                        } else {
+                            PULSE->_gas0_t_flag = 2;
+                            PULSE->_gas0_sw = PULSE->_gas0_sw2;
+                            PULSE->_gas0_t = PULSE->_gas0_t2;
+                            if (PULSE->_gas0_t == 1) {
+                                PULSE->_gas0_sw = lastSwitch;
+                            }
+                        }
+                    }
+                } else if (PULSE->_gas0_cy <= 0){
+                    if (PULSE->_gas0_t_flag == 4) {
+                        PULSE->_gas0_lp -- ;
+                        if (PULSE->_gas0_lp > 0) {
+                            PULSE->_gas0_cy = INSTRUCTION.gas0_cy;
+                            PULSE->_gas0_t_flag = 2;
+                            PULSE->_gas0_sw = PULSE->_gas0_sw2;
+                            PULSE->_gas0_t = PULSE->_gas0_t2;
+                            if (PULSE->_gas0_t == 1) {
+                                PULSE->_gas0_sw = lastSwitch;
+                            }
+                        } else {
+                            PULSE->_gas0_t_flag = 5;
+                            PULSE->_gas0_sw = PULSE->_gas0_sw5;
+                            PULSE->_gas0_t = PULSE->_gas0_t5;
+                            if (PULSE->_gas0_t == 1) {
+                                PULSE->_gas0_sw = lastSwitch;
+                            }
+                        }
+                    }
+                }
+            } else if (PULSE->_gas0_lp <= 0) {
+                if (PULSE->_gas0_t_flag == 5) {
+                    PULSE->_gas0_t_flag = 6;
+                    PULSE->_gas0_sw = PULSE->_gas0_sw6;
+                    PULSE->_gas0_t = PULSE->_gas0_t6;
+                    if (PULSE->_gas0_t == 1) {
+                        PULSE->_gas0_sw = lastSwitch;
+                    }
+                } else if (PULSE->_gas0_t_flag == 6) {
+                    PULSE->_gas0_t_flag = 7;
+                    PULSE->_gas0_sw = PULSE->_gas0_sw7;
+                    PULSE->_gas0_t = PULSE->_gas0_t7;
+                    if (PULSE->_gas0_t == 1) {
+                        PULSE->_gas0_sw = lastSwitch;
+                    }
+                } else if (PULSE->_gas0_t_flag == 7) {
+                    PULSE->_gas0_sw = false;
+                    //PeriodicEvent  = false;
+                    //megaTrigEnable = false;
+                    //ModeLED(NO_EVENT);
+                }
+            }
+        }
+    }
+
+    if (lastSwitch != PULSE->_gas0_sw) {
+        lastSwitch = PULSE->_gas0_sw;
+        PIN15_setOutputValue(MEGA_VAL_0, PULSE->_gas0_sw);
+    }
+}
+
+static void PULSE_gas1(PULSEMode *PULSE)
+{
+    static bool lastSwitch;
+
+    if (gas1FirstTime) {
+        gas1FirstTime = false;
+        lastSwitch = true;
+            PULSE->_gas1_t_flag = 1;
+            PULSE->_gas1_sw = PULSE->_gas1_sw1;
+            PULSE->_gas1_t = PULSE->_gas1_t1;
+            if (PULSE->_gas1_t == 1) {
+                PULSE->_gas1_sw = lastSwitch;
+            }
+    } else if(!gas1FirstTime) {
+        if (GPT.Gas1Counter >= PULSE->_gas1_t) {
+            GPT.Gas1Counter -= PULSE->_gas1_t; //to get right time
+
+            if (PULSE->_gas1_lp > 0) {
+                if (PULSE->_gas1_cy > 0) {
+                    if (PULSE->_gas1_t_flag == 1) {
+                        PULSE->_gas1_t_flag = 2;
+                        PULSE->_gas1_sw = PULSE->_gas1_sw2;
+                        PULSE->_gas1_t = PULSE->_gas1_t2;
+                        if (PULSE->_gas1_t == 1) {
+                            PULSE->_gas1_sw = lastSwitch;
+                        }
+                    } else if (PULSE->_gas1_t_flag == 2) {
+                        PULSE->_gas1_t_flag = 3;
+                        PULSE->_gas1_sw = PULSE->_gas1_sw3;
+                        PULSE->_gas1_t = PULSE->_gas1_t3;
+                        if (PULSE->_gas1_t == 1) {
+                            PULSE->_gas1_sw = lastSwitch;
+                        }
+                    } else if (PULSE->_gas1_t_flag == 3) {
+                        PULSE->_gas1_cy -- ;
+                        if (PULSE->_gas1_cy == 0) {
+                            PULSE->_gas1_t_flag = 4;
+                            PULSE->_gas1_sw = PULSE->_gas1_sw4;
+                            PULSE->_gas1_t = PULSE->_gas1_t4;
+                            if (PULSE->_gas1_t == 1) {
+                                PULSE->_gas1_sw = lastSwitch;
+                            }
+                        } else {
+                            PULSE->_gas1_t_flag = 2;
+                            PULSE->_gas1_sw = PULSE->_gas1_sw2;
+                            PULSE->_gas1_t = PULSE->_gas1_t2;
+                            if (PULSE->_gas1_t == 1) {
+                                PULSE->_gas1_sw = lastSwitch;
+                            }
+                        }
+                    }
+                } else if (PULSE->_gas1_cy <= 0){
+                    if (PULSE->_gas1_t_flag == 4) {
+                        PULSE->_gas1_lp -- ;
+                        if (PULSE->_gas1_lp > 0) {
+                            PULSE->_gas1_cy = INSTRUCTION.gas1_cy;
+                            PULSE->_gas1_t_flag = 2;
+                            PULSE->_gas1_sw = PULSE->_gas1_sw2;
+                            PULSE->_gas1_t = PULSE->_gas1_t2;
+                            if (PULSE->_gas1_t == 1) {
+                                PULSE->_gas1_sw = lastSwitch;
+                            }
+                        } else {
+                            PULSE->_gas1_t_flag = 5;
+                            PULSE->_gas1_sw = PULSE->_gas1_sw5;
+                            PULSE->_gas1_t = PULSE->_gas1_t5;
+                            if (PULSE->_gas1_t == 1) {
+                                PULSE->_gas1_sw = lastSwitch;
+                            }
+                        }
+                    }
+                }
+            } else if (PULSE->_gas1_lp <= 0) {
+                if (PULSE->_gas1_t_flag == 5) {
+                    PULSE->_gas1_t_flag = 6;
+                    PULSE->_gas1_sw = PULSE->_gas1_sw6;
+                    PULSE->_gas1_t = PULSE->_gas1_t6;
+                    if (PULSE->_gas1_t == 1) {
+                        PULSE->_gas1_sw = lastSwitch;
+                    }
+                } else if (PULSE->_gas1_t_flag == 6) {
+                    PULSE->_gas1_t_flag = 7;
+                    PULSE->_gas1_sw = PULSE->_gas1_sw7;
+                    PULSE->_gas1_t = PULSE->_gas1_t7;
+                    if (PULSE->_gas1_t == 1) {
+                        PULSE->_gas1_sw = lastSwitch;
+                    }
+                } else if (PULSE->_gas1_t_flag == 7) {
+                    PULSE->_gas1_sw = true;
+                    //PeriodicEvent  = false;
+                    //megaTrigEnable = false;
+                    //ModeLED(NO_EVENT);
+                }
+            }
+        }
+    }
+
+    if (lastSwitch != PULSE->_gas1_sw) {
+        lastSwitch = PULSE->_gas1_sw;
+        PIN15_setOutputValue(MEGA_VAL_1, PULSE->_gas1_sw);
+    }
+}
+#endif

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteReset.h

@@ -3,18 +3,33 @@
 #define ELITERESET
 
 static void reset() {
+    Mega_PeriodicEvent = false;
+    megaTrigEnable = false;
+    Mega_Trig_receive = false;
+    megaStiEnable  = false;
+    megaLedGEnable = false;
+    megaLedREnable = false;
+    megaGas0Enable = false;
+    megaGas1Enable = false;
+    PIN15_setOutputValue(MEGA_G_LED, 0);
+    PIN15_setOutputValue(MEGA_R_LED, 0);
+    PIN15_setOutputValue(MEGA_VAL_0, 0);
+    PIN15_setOutputValue(MEGA_VAL_1, 1);
     ModeLED(NO_EVENT);
     InitEliteFlag();
     InitFlag();
     InitCT();
     InitGPT();
-    InitLH();
+
+    PIN15_setOutputValue(HIGH_Z_MODE, 0);   // 0 => open high_z mode
 
     VinADCGainControl(VIN_GAIN_AUTO);
     IinADCGainControl(I_GAIN_AUTO);
-    VoutGainControl(VOUT_GAIN_AUTO);
-    DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoutGainLevel, INSTRUCTION.VoltConstant));
-    PIN15_setOutputValue(HIGH_Z_MODE, 0);   // 0 => open high_z mode
+
+    INSTRUCTION.VoutGainLevel = VOUT_GAIN_15K;
+    VoutGainControl(INSTRUCTION.VoutGainLevel);
+    DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoutGainLevel, 25000));
+
     initINSBuf();
     initDATBuf();
 
@@ -33,25 +48,34 @@ static void reset() {
         spi_ADC_rxbuf[i] = 0;
     }
 
-    PIN15_setOutputValue(ADC_CS, 1);  // ADC_CS HIGH
-    PIN15_setOutputValue(DAC_CS, 1);  // DAC_CS HIGH
     CPUdelay(1600);
 }
 
 static void Eliteinterrupt() {
-    InitFlag();
+    Mega_PeriodicEvent = false;
+    Mega_Trig_receive = false;
+    megaTrigEnable = false;
+    megaStiEnable  = false;
+    megaLedGEnable = false;
+    megaLedREnable = false;
+    megaGas0Enable = false;
+    megaGas1Enable = false;
+    PIN15_setOutputValue(MEGA_G_LED, 0);
+    PIN15_setOutputValue(MEGA_R_LED, 0);
+    PIN15_setOutputValue(MEGA_VAL_0, 0);
+    PIN15_setOutputValue(MEGA_VAL_1, 1);
     ModeLED(NO_EVENT);
-
+    InitFlag();
     InitEliteFlag();
     InitCT();
     InitGPT();
-    InitLH();
 
-    VinADCGainControl(VIN_GAIN_AUTO);
-    IinADCGainControl(I_GAIN_AUTO);
-    VoutGainControl(VOUT_GAIN_AUTO);
-    DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoutGainLevel, INSTRUCTION.VoltConstant));
     PIN15_setOutputValue(HIGH_Z_MODE, 0);   // 0 => open high_z mode
+
+    INSTRUCTION.VoutGainLevel = VOUT_GAIN_15K;
+    VoutGainControl(INSTRUCTION.VoutGainLevel);
+    DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoutGainLevel, 25000));
+
     initINSBuf();
     initDATBuf();
 
@@ -70,8 +94,6 @@ static void Eliteinterrupt() {
         spi_ADC_rxbuf[i] = 0;
     }
 
-    PIN15_setOutputValue(ADC_CS, 1);  // ADC_CS HIGH
-    PIN15_setOutputValue(DAC_CS, 1);  // DAC_CS HIGH
     CPUdelay(8000);
 }
 #endif

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteSPI.h

@@ -57,20 +57,17 @@ static void Elite_SPI_init(){
 }
 
 static void LED_SPI(uint8_t length, uint16_t *spi_txbuf, uint16_t *spi_rxbuf) {
-    ELITE15_SPI_HOLD();
-
     LED_transaction.count = length;
     LED_transaction.txBuf = spi_txbuf;
     LED_transaction.rxBuf = spi_rxbuf;
 
     SPI_transfer(spiHandle0, &LED_transaction);
-
-    ELITE15_SPI_CLOSE();
 }
 
 static void ADC_SPI(uint8_t length, uint8_t *spi_txbuf, uint8_t *spi_rxbuf) {
-    ELITE15_SPI_HOLD();
-    PIN_setOutputValue(pin_handle, D6, 0);      // CS_ADC
+//    PIN15_setOutputValue(ADC_CS, 0);  // ADC_CS LOW
+    PIN_setOutputValue(pin_handle, LOAD0, 1);
+    PIN_setOutputValue(pin_handle, D6, 0); // ADC_CS LOW
 
     ADC_DAC_transaction.count = length;
     ADC_DAC_transaction.txBuf = spi_txbuf;
@@ -78,13 +75,15 @@ static void ADC_SPI(uint8_t length, uint8_t *spi_txbuf, uint8_t *spi_rxbuf) {
 
     SPI_transfer(spiHandle1, &ADC_DAC_transaction);
 
-    PIN_setOutputValue(pin_handle, D6, 1);      // CS_ADC
-    ELITE15_SPI_CLOSE();
+    PIN_setOutputValue(pin_handle, D6, 1); // ADC_CS HOGH
+    update_latch_status (ADC_CS, 1);
+//    PIN15_setOutputValue(ADC_CS, 1);  // ADC_CS HIGH
 }
 
 static void DAC_SPI(uint8_t length, uint8_t *spi_txbuf, uint8_t *spi_rxbuf) {
-    ELITE15_SPI_HOLD();
-    PIN_setOutputValue(pin_handle, D7, 0);      // CD_DAC
+//    PIN15_setOutputValue(DAC_CS, 0);            // DAC_CS LOW
+    PIN_setOutputValue(pin_handle, LOAD0, 1);
+    PIN_setOutputValue(pin_handle, D7, 0); // DAC_CS LOW
 
     ADC_DAC_transaction.count = length;
     ADC_DAC_transaction.txBuf = spi_txbuf;
@@ -92,68 +91,32 @@ static void DAC_SPI(uint8_t length, uint8_t *spi_txbuf, uint8_t *spi_rxbuf) {
 
     SPI_transfer(spiHandle1, &ADC_DAC_transaction);
 
-    PIN_setOutputValue(pin_handle, D7, 1);      // CD_DAC
-    ELITE15_SPI_CLOSE();
-}
-
-static void LED_SPI_TEST(uint8_t length, uint16_t *spi_txbuf, uint16_t *spi_rxbuf) {
-    LED_transaction.count = length;
-    LED_transaction.txBuf = spi_txbuf;
-    LED_transaction.rxBuf = spi_rxbuf;
-
-    SPI_transfer(spiHandle0, &LED_transaction);
-}
-
-static void ADC_SPI_TEST(uint8_t length, uint8_t *spi_txbuf, uint8_t *spi_rxbuf) {
-    PIN_setOutputValue(pin_handle, D6, 0);      // CS_ADC
-
-    ADC_DAC_transaction.count = length;
-    ADC_DAC_transaction.txBuf = spi_txbuf;
-    ADC_DAC_transaction.rxBuf = spi_rxbuf;
-
-    SPI_transfer(spiHandle1, &ADC_DAC_transaction);
-
-    PIN_setOutputValue(pin_handle, D6, 1);      // CS_ADC
-}
-
-static void DAC_SPI_TEST(uint8_t length, uint8_t *spi_txbuf, uint8_t *spi_rxbuf) {
-    PIN_setOutputValue(pin_handle, D7, 0);      // CD_DAC
-
-    ADC_DAC_transaction.count = length;
-    ADC_DAC_transaction.txBuf = spi_txbuf;
-    ADC_DAC_transaction.rxBuf = spi_rxbuf;
-
-    SPI_transfer(spiHandle1, &ADC_DAC_transaction);
-
-    PIN_setOutputValue(pin_handle, D7, 1);      // CD_DAC
+    PIN_setOutputValue(pin_handle, D7, 1); // DAC_CS HOGH
+    update_latch_status (DAC_CS, 1);
+//    PIN15_setOutputValue(DAC_CS, 1);            // DAC_CS HIGH
 }
 
 static void ELITE15_SPI_HOLD() {
+    Elite_SPI_init();
+
     PIN_setOutputValue(pin_handle, LOAD0, 1);
     PIN_setOutputValue(pin_handle, LOAD1, 0);
     PIN_setOutputValue(pin_handle, LOAD2, 0);
-    PIN_setOutputValue(pin_handle, D4, 1);      // HOLD_MEM
-    PIN_setOutputValue(pin_handle, D5, 1);      // CS_MEM
-    PIN_setOutputValue(pin_handle, D6, 1);      // CS_ADC
-    PIN_setOutputValue(pin_handle, D7, 1);      // CD_DAC
-    Elite_SPI_init();
 }
 static void ELITE15_SPI_CLOSE() {
-    PIN_setOutputValue(pin_handle, D4, 1);      // HOLD_MEM
-    PIN_setOutputValue(pin_handle, D5, 1);      // CS_MEM
-    PIN_setOutputValue(pin_handle, D6, 1);      // CS_ADC
-    PIN_setOutputValue(pin_handle, D7, 1);      // CD_DAC
     PIN_setOutputValue(pin_handle, LOAD0, 0);
     PIN_setOutputValue(pin_handle, LOAD1, 0);
     PIN_setOutputValue(pin_handle, LOAD2, 0);
+
     SPI_close(spiHandle0);
     SPI_close(spiHandle1);
 }
 
 /* Elite1.5 Calibration SPI */
 static void CAL_ADC_SPI(uint8_t length, uint8_t *spi_txbuf, uint8_t *spi_rxbuf) {
-//    ELITE15_SPI_HOLD();
-    PIN_setOutputValue(pin_handle, D6, 0);      // CS_ADC
+//    PIN15_setOutputValue(ADC_CS, 0);  // ADC_CS LOW
+    PIN_setOutputValue(pin_handle, LOAD0, 1);
+    PIN_setOutputValue(pin_handle, D6, 0); // ADC_CS LOW
 
     ADC_DAC_transaction.count = length;
     ADC_DAC_transaction.txBuf = spi_txbuf;
@@ -161,21 +124,9 @@ static void CAL_ADC_SPI(uint8_t length, uint8_t *spi_txbuf, uint8_t *spi_rxbuf)
 
     SPI_transfer(spiHandle1, &ADC_DAC_transaction);
 
-    PIN_setOutputValue(pin_handle, D6, 1);      // CS_ADC
-//    ELITE15_SPI_CLOSE();
+    PIN_setOutputValue(pin_handle, D6, 1); // ADC_CS HOGH
+    update_latch_status (ADC_CS, 1);
+//    PIN15_setOutputValue(ADC_CS, 1);  // ADC_CS HIGH
 }
 
-static void CAL_LED_SPI(uint8_t length, uint16_t *spi_txbuf, uint16_t *spi_rxbuf) {
-//    ELITE15_SPI_HOLD();
-
-    LED_transaction.count = length;
-    LED_transaction.txBuf = spi_txbuf;
-    LED_transaction.rxBuf = spi_rxbuf;
-
-    SPI_transfer(spiHandle0, &LED_transaction);
-
-//    ELITE15_SPI_CLOSE();
-}
-
-
 #endif // ELITE_SPI

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteWorkData.h

@@ -327,6 +327,230 @@ CVSCANMode * InitCVSCANMode(){
 }
 /*End of CONSTANT_VSCAN Mode*/
 
+/* PULSE_MODE Mode(PULSE_MODE)*/
+typedef struct _PULSEMode {
+    MEASURE;
+    int32_t  _Vset;
+    int32_t  _sti_v1;
+    int32_t  _sti_v2;
+    int32_t  _sti_v3;
+    int32_t  _sti_v4;
+    int32_t  _sti_v5;
+    int32_t  _sti_v6;
+    int32_t  _sti_v7;
+    int32_t  _sti_t1;
+    int32_t  _sti_t2;
+    int32_t  _sti_t3;
+    int32_t  _sti_t4;
+    int32_t  _sti_t5;
+    int32_t  _sti_t6;
+    int32_t  _sti_t7;
+    int32_t  _sti_t;
+    int32_t  _sti_v;         //output voltage now
+    int32_t  _sti_t_flag;    //Where's the time stage turn
+    uint16_t _sti_cy;
+    uint16_t _sti_lp;
+
+    //ledG
+    uint8_t  _ledG_sw1;
+    uint8_t  _ledG_sw2;
+    uint8_t  _ledG_sw3;
+    uint8_t  _ledG_sw4;
+    uint8_t  _ledG_sw5;
+    uint8_t  _ledG_sw6;
+    uint8_t  _ledG_sw7;
+    int32_t  _ledG_t1;
+    int32_t  _ledG_t2;
+    int32_t  _ledG_t3;
+    int32_t  _ledG_t4;
+    int32_t  _ledG_t5;
+    int32_t  _ledG_t6;
+    int32_t  _ledG_t7;
+    int32_t  _ledG_t;
+    uint8_t  _ledG_sw;
+    int32_t  _ledG_t_flag;
+    uint16_t _ledG_cy;
+    uint16_t _ledG_lp;
+
+    //ledR
+    uint8_t  _ledR_sw1;
+    uint8_t  _ledR_sw2;
+    uint8_t  _ledR_sw3;
+    uint8_t  _ledR_sw4;
+    uint8_t  _ledR_sw5;
+    uint8_t  _ledR_sw6;
+    uint8_t  _ledR_sw7;
+    int32_t  _ledR_t1;
+    int32_t  _ledR_t2;
+    int32_t  _ledR_t3;
+    int32_t  _ledR_t4;
+    int32_t  _ledR_t5;
+    int32_t  _ledR_t6;
+    int32_t  _ledR_t7;
+    int32_t  _ledR_t;
+    uint8_t  _ledR_sw;
+    int32_t  _ledR_t_flag;
+    uint16_t _ledR_cy;
+    uint16_t _ledR_lp;
+
+    //gas0
+    uint8_t  _gas0_sw1;
+    uint8_t  _gas0_sw2;
+    uint8_t  _gas0_sw3;
+    uint8_t  _gas0_sw4;
+    uint8_t  _gas0_sw5;
+    uint8_t  _gas0_sw6;
+    uint8_t  _gas0_sw7;
+    int32_t  _gas0_t1;
+    int32_t  _gas0_t2;
+    int32_t  _gas0_t3;
+    int32_t  _gas0_t4;
+    int32_t  _gas0_t5;
+    int32_t  _gas0_t6;
+    int32_t  _gas0_t7;
+    int32_t  _gas0_t;
+    uint8_t  _gas0_sw;
+    int32_t  _gas0_t_flag;
+    uint16_t _gas0_cy;
+    uint16_t _gas0_lp;
+
+    //gas1
+    uint8_t  _gas1_sw1;
+    uint8_t  _gas1_sw2;
+    uint8_t  _gas1_sw3;
+    uint8_t  _gas1_sw4;
+    uint8_t  _gas1_sw5;
+    uint8_t  _gas1_sw6;
+    uint8_t  _gas1_sw7;
+    int32_t  _gas1_t1;
+    int32_t  _gas1_t2;
+    int32_t  _gas1_t3;
+    int32_t  _gas1_t4;
+    int32_t  _gas1_t5;
+    int32_t  _gas1_t6;
+    int32_t  _gas1_t7;
+    int32_t  _gas1_t;
+    uint8_t  _gas1_sw;
+    int32_t  _gas1_t_flag;
+    uint16_t _gas1_cy;
+    uint16_t _gas1_lp;
+} PULSEMode;
+
+PULSEMode * InitPULSEMode() {
+    PULSEMode *ret = malloc(sizeof(PULSEMode));
+    ret->_measureCurrent = 0;
+    ret->_measureVin     = 0;
+    ret->_measureVout    = 0;
+    ret->_measureBat     = 0;
+    ret->_VoViSwitch     = INSTRUCTION.VoViSwitch;
+    ret->_Vset           = 0;
+    ret->_sti_v1         = INSTRUCTION.sti_v1;
+    ret->_sti_v2         = INSTRUCTION.sti_v2;
+    ret->_sti_v3         = INSTRUCTION.sti_v3;
+    ret->_sti_v4         = INSTRUCTION.sti_v4;
+    ret->_sti_v5         = INSTRUCTION.sti_v5;
+    ret->_sti_v6         = INSTRUCTION.sti_v6;
+    ret->_sti_v7         = INSTRUCTION.sti_v7;
+    ret->_sti_t1         = INSTRUCTION.sti_t1;
+    ret->_sti_t2         = INSTRUCTION.sti_t2;
+    ret->_sti_t3         = INSTRUCTION.sti_t3;
+    ret->_sti_t4         = INSTRUCTION.sti_t4;
+    ret->_sti_t5         = INSTRUCTION.sti_t5;
+    ret->_sti_t6         = INSTRUCTION.sti_t6;
+    ret->_sti_t7         = INSTRUCTION.sti_t7;
+    ret->_sti_t          = INSTRUCTION.sti_t1;
+    ret->_sti_v          = INSTRUCTION.sti_v1;
+    ret->_sti_t_flag     = 1;
+    ret->_sti_cy         = INSTRUCTION.sti_cy;
+    ret->_sti_lp         = INSTRUCTION.sti_loop;
+
+    //ledG
+    ret->_ledG_sw1       = INSTRUCTION.ledG_sw1;
+    ret->_ledG_sw2       = INSTRUCTION.ledG_sw2;
+    ret->_ledG_sw3       = INSTRUCTION.ledG_sw3;
+    ret->_ledG_sw4       = INSTRUCTION.ledG_sw4;
+    ret->_ledG_sw5       = INSTRUCTION.ledG_sw5;
+    ret->_ledG_sw6       = INSTRUCTION.ledG_sw6;
+    ret->_ledG_sw7       = INSTRUCTION.ledG_sw7;
+    ret->_ledG_t1        = INSTRUCTION.ledG_t1;
+    ret->_ledG_t2        = INSTRUCTION.ledG_t2;
+    ret->_ledG_t3        = INSTRUCTION.ledG_t3;
+    ret->_ledG_t4        = INSTRUCTION.ledG_t4;
+    ret->_ledG_t5        = INSTRUCTION.ledG_t5;
+    ret->_ledG_t6        = INSTRUCTION.ledG_t6;
+    ret->_ledG_t7        = INSTRUCTION.ledG_t7;
+    ret->_ledG_t         = INSTRUCTION.ledG_t1;
+    ret->_ledG_sw        = INSTRUCTION.ledG_sw1;
+    ret->_ledG_t_flag    = 1;
+    ret->_ledG_cy        = INSTRUCTION.ledG_cy;
+    ret->_ledG_lp        = INSTRUCTION.ledG_loop;
+
+    //ledR
+    ret->_ledR_sw1       = INSTRUCTION.ledR_sw1;
+    ret->_ledR_sw2       = INSTRUCTION.ledR_sw2;
+    ret->_ledR_sw3       = INSTRUCTION.ledR_sw3;
+    ret->_ledR_sw4       = INSTRUCTION.ledR_sw4;
+    ret->_ledR_sw5       = INSTRUCTION.ledR_sw5;
+    ret->_ledR_sw6       = INSTRUCTION.ledR_sw6;
+    ret->_ledR_sw7       = INSTRUCTION.ledR_sw7;
+    ret->_ledR_t1        = INSTRUCTION.ledR_t1;
+    ret->_ledR_t2        = INSTRUCTION.ledR_t2;
+    ret->_ledR_t3        = INSTRUCTION.ledR_t3;
+    ret->_ledR_t4        = INSTRUCTION.ledR_t4;
+    ret->_ledR_t5        = INSTRUCTION.ledR_t5;
+    ret->_ledR_t6        = INSTRUCTION.ledR_t6;
+    ret->_ledR_t7        = INSTRUCTION.ledR_t7;
+    ret->_ledR_t         = INSTRUCTION.ledR_t1;
+    ret->_ledR_sw        = INSTRUCTION.ledR_sw1;
+    ret->_ledR_t_flag    = 1;
+    ret->_ledR_cy        = INSTRUCTION.ledR_cy;
+    ret->_ledR_lp        = INSTRUCTION.ledR_loop;
+
+    //gas0
+    ret->_gas0_sw1       = INSTRUCTION.gas0_sw1;
+    ret->_gas0_sw2       = INSTRUCTION.gas0_sw2;
+    ret->_gas0_sw3       = INSTRUCTION.gas0_sw3;
+    ret->_gas0_sw4       = INSTRUCTION.gas0_sw4;
+    ret->_gas0_sw5       = INSTRUCTION.gas0_sw5;
+    ret->_gas0_sw6       = INSTRUCTION.gas0_sw6;
+    ret->_gas0_sw7       = INSTRUCTION.gas0_sw7;
+    ret->_gas0_t1        = INSTRUCTION.gas0_t1;
+    ret->_gas0_t2        = INSTRUCTION.gas0_t2;
+    ret->_gas0_t3        = INSTRUCTION.gas0_t3;
+    ret->_gas0_t4        = INSTRUCTION.gas0_t4;
+    ret->_gas0_t5        = INSTRUCTION.gas0_t5;
+    ret->_gas0_t6        = INSTRUCTION.gas0_t6;
+    ret->_gas0_t7        = INSTRUCTION.gas0_t7;
+    ret->_gas0_t         = INSTRUCTION.gas0_t1;
+    ret->_gas0_sw        = INSTRUCTION.gas0_sw1;
+    ret->_gas0_t_flag    = 1;
+    ret->_gas0_cy        = INSTRUCTION.gas0_cy;
+    ret->_gas0_lp        = INSTRUCTION.gas0_loop;
+
+    //gas1
+    ret->_gas1_sw1       = INSTRUCTION.gas1_sw1;
+    ret->_gas1_sw2       = INSTRUCTION.gas1_sw2;
+    ret->_gas1_sw3       = INSTRUCTION.gas1_sw3;
+    ret->_gas1_sw4       = INSTRUCTION.gas1_sw4;
+    ret->_gas1_sw5       = INSTRUCTION.gas1_sw5;
+    ret->_gas1_sw6       = INSTRUCTION.gas1_sw6;
+    ret->_gas1_sw7       = INSTRUCTION.gas1_sw7;
+    ret->_gas1_t1        = INSTRUCTION.gas1_t1;
+    ret->_gas1_t2        = INSTRUCTION.gas1_t2;
+    ret->_gas1_t3        = INSTRUCTION.gas1_t3;
+    ret->_gas1_t4        = INSTRUCTION.gas1_t4;
+    ret->_gas1_t5        = INSTRUCTION.gas1_t5;
+    ret->_gas1_t6        = INSTRUCTION.gas1_t6;
+    ret->_gas1_t7        = INSTRUCTION.gas1_t7;
+    ret->_gas1_t         = INSTRUCTION.gas1_t1;
+    ret->_gas1_sw        = INSTRUCTION.gas1_sw1;
+    ret->_gas1_t_flag    = 1;
+    ret->_gas1_cy        = INSTRUCTION.gas1_cy;
+    ret->_gas1_lp        = INSTRUCTION.gas1_loop;
+    return ret;
+}
+/*End of PULSE_MODE Mode*/
+
 /* Cycle CC Mode */
 typedef struct _CCCMode{
     int32_t _measureCurrent;
@@ -423,6 +647,7 @@ typedef union _WorkMode{
     LSVMode *LSV;
     CVSCANMode *CVSCAN;
     PSMode *PS;
+    PULSEMode *PULSE;
 //    CCCMode *CCC;
 }WorkMode;
 
@@ -464,6 +689,9 @@ void InitWorkMode(WorkMode *WM){
         case CONSTANT_VSCAN:
             WM->CVSCAN = InitCVSCANMode();
             break;
+        case PULSE_MODE:
+            WM->PULSE = InitPULSEMode();
+            break;
 //        case CYCLE_CONSTANT_CURRENT:
 //            WM->CCC = InitCCCMode();
 //            break;
@@ -536,6 +764,12 @@ void FreeWorkMode(WorkMode *WM){
                 WM->CVSCAN = NULL;
             }
             break;
+        case PULSE_MODE:
+            if(WM->PULSE != NULL){
+                free(WM->PULSE);
+                WM->PULSE = NULL;
+            }
+            break;
 //        case CYCLE_CONSTANT_CURRENT:
 //            if(WM->CCC != NULL){
 //                free(WM->CCC);

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/Elite_PIN.h

@@ -61,6 +61,13 @@
 #define enable_10v                      LOAD1, D5
 #define enable_5v                       LOAD1, D6
 
+/* Megafly control */
+#define MEGA_G_LED                      LOAD1, D0
+#define MEGA_R_LED                      LOAD1, D1
+#define MEGA_VAL_0                      LOAD1, D2
+#define MEGA_VAL_1                      LOAD1, D3
+#define MEGA_TRIG                       IOID_0
+
 PIN_Handle       pin_handle;
 static PIN_State ZM_rst;
 
@@ -79,6 +86,7 @@ const PIN_Config BLE_IO[] = {
     LOAD2 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL,
 
     switch_on | PIN_INPUT_EN | PIN_PULLDOWN,                                    // to sense switch
+    MEGA_TRIG | PIN_GPIO_OUTPUT_DIS | PIN_INPUT_EN | PIN_PULLDOWN,
 
     PIN_TERMINATE
 };
@@ -99,9 +107,13 @@ static void add_elite_pin() {
 //    }
 }
 
+static void megafly_trig_callback(PIN_Handle handle, PIN_Id pinId);
+
 static void remove_elite_pin() {
     PIN_close(pin_handle);
     pin_handle = PIN_open(&ZM_rst, BLE_IO);
+    PIN_registerIntCb(pin_handle, megafly_trig_callback);
+    PIN_setInterrupt(pin_handle, MEGA_TRIG | PIN_IRQ_NEGEDGE);
 }
 
 /*!

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/Elite_def.h

@@ -39,6 +39,7 @@
 #define ADC_TEST                        0x91
 #define CALI_DAC_MODE                   0x93
 #define CALI_ADC_MODE                   0x92
+#define PULSE_MODE                      0x94
 
 // CIS (control instruction)
 #define CIS_VERSION                     0x40
@@ -55,6 +56,21 @@
 #define ReadADCVolt(x)           ((x==0)? ReadADCVout(spi_ADC_rxbuf) : ReadADCVin(spi_ADC_rxbuf))
 #define PARA_1                   0x01
 #define PARA_2                   0x02
+#define PARA_3                   0x03
+#define PARA_4                   0x04
+#define PARA_5                   0x05
+#define PARA_6                   0x06
+#define PARA_7                   0x07
+#define PARA_8                   0x08
+#define PARA_9                   0x09
+#define PARA_10                  0x0A
+#define PARA_11                  0x0B
+#define PARA_12                  0x0C
+#define PARA_13                  0x0D
+#define PARA_14                  0x0E
+#define PARA_15                  0x0F
+#define PARA_16                  0x10
+#define PARA_17                  0x11
 
 //Elite LED
 #define COLOR_BLACK              0x00
@@ -80,5 +96,6 @@
 #define WORKING                  0x04
 #define POST_WORK                0x05
 
-
+#define MEGA_15V                 41406
+#define VALUE_ZERO_TO_ONE(_v)    (_v == 0) ? 1 : _v
 #endif

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/Elite_mode_ADC_DAC.h

@@ -62,7 +62,8 @@ static void DACenable(WorkMode *WorkModeData, int32_t VoltData ,uint8_t afterRea
             case VT_CURVE:
             case CYCLIC_VOLTAMMETRY:
             case LINEAR_SWEEP_VOLTAMMETRY:
-            case CONSTANT_VSCAN:{
+            case CONSTANT_VSCAN:
+            case PULSE_MODE:{
                 break;
             }
             default:{
@@ -82,7 +83,8 @@ static void DACenable(WorkMode *WorkModeData, int32_t VoltData ,uint8_t afterRea
             }
             case IT_CURVE:
             case VT_CURVE:
-            case CONSTANT_CURRENT:{
+            case CONSTANT_CURRENT:
+            case PULSE_MODE:{
                 break;
             }
             case CYCLIC_VOLTAMMETRY:{
@@ -142,6 +144,10 @@ static void CC_Plot(WorkMode *WorkModeData){
             #define CURRENT_MODE WorkModeData->CVSCAN
             break;
         }
+        case PULSE_MODE:{
+            #define CURRENT_MODE WorkModeData->PULSE
+            break;
+        }
         default: {
             break;
         }
@@ -279,6 +285,10 @@ static void IT_Plot(WorkMode *WorkModeData) {
             #define CURRENT_MODE WorkModeData->CVSCAN
             break;
         }
+        case PULSE_MODE:{
+            #define CURRENT_MODE WorkModeData->PULSE
+            break;
+        }
         default: {
             break;
         }
@@ -357,6 +367,10 @@ static void VT_Plot(WorkMode *WorkModeData) {
             #define CURRENT_MODE WorkModeData->CVSCAN
             break;
         }
+        case PULSE_MODE:{
+            #define CURRENT_MODE WorkModeData->PULSE
+            break;
+        }
         default: {
             break;
         }
@@ -440,6 +454,10 @@ static void readIin(WorkMode *WorkModeData){
             #define TEMP_MODE WorkModeData->CVSCAN
             break;
         }
+        case PULSE_MODE:{
+            #define TEMP_MODE WorkModeData->PULSE
+            break;
+        }
         default: {
             break;
         }
@@ -497,6 +515,10 @@ static int32_t readVinVout(WorkMode *WorkModeData){
             #define TEMP_MODE WorkModeData->CVSCAN
             break;
         }
+        case PULSE_MODE:{
+            #define TEMP_MODE WorkModeData->PULSE
+            break;
+        }
         default: {
             break;
         }
@@ -565,6 +587,10 @@ static void cali_IT_plot(WorkMode *WorkModeData) {
             #define CURRENT_MODE WorkModeData->CVSCAN
             break;
         }
+        case PULSE_MODE:{
+            #define CURRENT_MODE WorkModeData->PULSE
+            break;
+        }
         default: {
             #define CURRENT_MODE WorkModeData->VT
             break;
@@ -576,6 +602,7 @@ static void cali_IT_plot(WorkMode *WorkModeData) {
     static int32_t ADCValueSUM     = 0;
     int32_t ADCValueAVG            = 0;
     int16_t ADCValueAVG_RAW        = 0;
+    static uint16_t cali_count_max = 1000;
 
     if(ADCSwitch == 0){ /**read Iin(buffer)**/
         if(INSTRUCTION.AutoGainEnable){
@@ -588,6 +615,11 @@ static void cali_IT_plot(WorkMode *WorkModeData) {
                 record_flag = false;
             }
         }
+        if(INSTRUCTION.ADCGainLevel == 0) {
+            cali_count_max = 5000;
+        } else {
+            cali_count_max = 1000;
+        }
 
         if(record_flag == false){
             static int recordCount = 0;
@@ -598,7 +630,7 @@ static void cali_IT_plot(WorkMode *WorkModeData) {
             }
         }else{
             static uint16_t cali_count = 0;
-            if(cali_count >= 1000){
+            if(cali_count >= cali_count_max){
                 ADCValueAVG = ADCValueSUM / cali_count;
 
                 InputNotify(NOTIFY_CURRENT, ADCValueAVG);
@@ -615,7 +647,6 @@ static void cali_IT_plot(WorkMode *WorkModeData) {
                 cali_count = 0;
 
                 PeriodicEvent = false;
-                ELITE15_SPI_CLOSE();
                 ModeLED(NO_EVENT);
             }else{
                 cali_count++;
@@ -678,6 +709,10 @@ static void cali_VT_plot(WorkMode *WorkModeData) {
             #define CURRENT_MODE WorkModeData->CVSCAN
             break;
         }
+        case PULSE_MODE:{
+            #define CURRENT_MODE WorkModeData->PULSE
+            break;
+        }
         default: {
             #define CURRENT_MODE WorkModeData->VT
             break;
@@ -690,6 +725,7 @@ static void cali_VT_plot(WorkMode *WorkModeData) {
     static int32_t ADCValueSUM     = 0;
     int32_t ADCValueAVG            = 0;
     int16_t ADCValueAVG_RAW        = 0;
+    static uint16_t cali_count_max = 1000;
 
     if(ADCSwitch == 0){ /**read Iin(buffer)**/
         if(CURRENT_MODE->_VoViSwitch == 0x01 || CURRENT_MODE->_VoViSwitch == 0x02){
@@ -706,6 +742,12 @@ static void cali_VT_plot(WorkMode *WorkModeData) {
             }
             VoltData = CURRENT_MODE->_measureVin;
         }
+
+        if(INSTRUCTION.VinADCGainLevel == 0) {
+            cali_count_max = 5000;
+        } else {
+            cali_count_max = 1000;
+        }
 //        else if(CURRENT_MODE->_VoViSwitch == 0x00){
 //            ReadADCVolt(CURRENT_MODE->_VoViSwitch);
 //            CURRENT_MODE->_measureVout = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_DAC, spi_ADC_rxbuf);
@@ -721,7 +763,7 @@ static void cali_VT_plot(WorkMode *WorkModeData) {
             }
         }else{
             static uint16_t cali_count = 0;
-            if(cali_count >= 1000){
+            if(cali_count >= cali_count_max){
                 ADCValueAVG = ADCValueSUM / cali_count;
 
                 InputNotify(NOTIFY_VOLT, ADCValueAVG);
@@ -738,7 +780,6 @@ static void cali_VT_plot(WorkMode *WorkModeData) {
                 cali_count = 0;
 
                 PeriodicEvent = false;
-                ELITE15_SPI_CLOSE();
                 ModeLED(NO_EVENT);
             }else{
                 cali_count++;

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/Elite_version.h

@@ -3,10 +3,10 @@
 #define VERSION_DATE
 
 #define VERSION_DATE_YEAR      20
-#define VERSION_DATE_MONTH     9
-#define VERSION_DATE_DAY       7
+#define VERSION_DATE_MONTH     12
+#define VERSION_DATE_DAY       11
 #define VERSION_DATE_HOUR      17
-#define VERSION_DATE_MINUTE    58
+#define VERSION_DATE_MINUTE    20
 
 // this is NOT the version hash !!
 // it's the last version hash

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/impedance_meter.h

@@ -38,6 +38,15 @@ static void elite_gptimer_callback(GPTimerCC26XX_Handle handle, GPTimerCC26XX_In
     GPT.GptimerCounter++;
 }
 
+static void megafly_trig_callback(PIN_Handle handle, PIN_Id pinId) {
+//    bool trig = 1;
+//    trig = PIN_getInputValue(MEGA_TRIG);
+    if (INSTRUCTION.eliteFxn == PULSE_MODE && megaTrigEnable){
+        Mega_PeriodicEvent = true;
+        Mega_Trig_receive = true;
+    }
+//    PIN15_setOutputValue(MEGA_G_LED, 1);
+}
 
 static void ZM_update_instruction_callback(uint8_t ins_type, uint8_t chip_ID, uint8_t *ins);
 
@@ -46,15 +55,21 @@ static void ZM_init() {
 
     // initialize
     pin_handle = PIN_open(&ZM_rst, BLE_IO);
+//    PIN_registerIntCb(pin_handle, megafly_trig_callback);
+//    PIN_setInterrupt(pin_handle, MEGA_TRIG | PIN_IRQ_NEGEDGE);
+
     Init_Elite15_PIN();
+    ELITE15_SPI_HOLD();
 
     PIN15_setOutputValue(shutdown_6994, 1);     // OFF = 1 => turn off 6994
     PIN15_setOutputValue(enable_10v, 0);        // enable 10V
+    PIN15_setOutputValue(HIGH_Z_MODE, 0);       // HIGH Z MODE // 1 => close high_z mode
 
-    PIN15_setOutputValue(ADC_CS, 1);            // ADC_CS HIGH
-    PIN15_setOutputValue(DAC_CS, 1);            // DAC_CS HIGH
-    PIN15_setOutputValue(MEM_CS, 1);            // MEM_CS HIGH
-    PIN15_setOutputValue(HIGH_Z_MODE, 0);       // HIGH Z MODE
+    /* Turn off Megafly output pin */
+    PIN15_setOutputValue(MEGA_G_LED, 0);
+    PIN15_setOutputValue(MEGA_R_LED, 0);
+    PIN15_setOutputValue(MEGA_VAL_0, 0);
+    PIN15_setOutputValue(MEGA_VAL_1, 1);
 
     InitEliteInstruction();
     IinADCGainControl(INSTRUCTION.ADCGainLevel);
@@ -129,7 +144,6 @@ static void SimpleBLEPeripheral_performPeriodicTask(WorkMode *WorkModeData) {
                 if (INSTRUCTION.Ve1 == INSTRUCTION.Ve2) {
                     DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoutGainLevel, INSTRUCTION.Ve1));
                     PeriodicEvent = false;
-                    ELITE15_SPI_CLOSE();
                     ModeLED(NO_EVENT);
                 }
             }
@@ -174,7 +188,7 @@ static void SimpleBLEPeripheral_performPeriodicTask(WorkMode *WorkModeData) {
 
         uint16_t bat = ((uint16_t)(NotifyVoltBat[2]) << 8 & 0xFF00 ) | ((uint16_t)(NotifyVoltBat[3]) & 0x00FF);
         if( bat < 768 && bat > 20){
-            PIN15_setOutputValue(enable_5v, 0);
+//            PIN15_setOutputValue(enable_5v, 0);
         }
 
         //ADC counter
@@ -204,20 +218,160 @@ static void SimpleBLEPeripheral_performPeriodicTask(WorkMode *WorkModeData) {
         }
 
 //        EliteDone();
-    }else if(INSTRUCTION.eliteFxn == VOLT_OUTPUT){
+    }
+    else if (INSTRUCTION.eliteFxn == PULSE_MODE) {
+         /** Periodic Event **/
+         // Default working flow is vscan -> ADC read -> send notify
+         // We will need a flag to control vscan, ADC and notify
+
+         GPT.DeltaGptimerCounter = GPT.GptimerCounter - GPT.GptimerCounter0;
+         GPT.GptimerCounter0 = GPT.GptimerCounter;
+
+         if(EliteWorkReset){
+             InitEliteGPtimer();
+             EliteWorkReset  = false;
+             batteryADC_flag = false;
+             record_flag     = true;
+             //pulsemode variable
+             stiFirstTime  = true;
+             ledGFirstTime = true; //green led
+             ledRFirstTime = true; //red led
+             gas0FirstTime = true; //gas0
+             gas1FirstTime = true; //gas1
+             VinADCGainControl(INSTRUCTION.VinADCGainLevel);
+             IinADCGainControl(INSTRUCTION.ADCGainLevel);
+             VoutGainControl(INSTRUCTION.VoutGainLevel);
+             if (Ve1MatchVe2Mode()) {
+                 if (INSTRUCTION.Ve1 == INSTRUCTION.Ve2) {
+                     DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoutGainLevel, INSTRUCTION.Ve1));
+                     PeriodicEvent = false;
+                     ModeLED(NO_EVENT);
+                 }
+             } else if (INSTRUCTION.eliteFxn == PULSE_MODE) {
+                if(!megaStiEnable && !megaLedGEnable && !megaLedREnable && !megaGas0Enable && !megaGas1Enable){
+                     PeriodicEvent = false;
+                     ModeLED(NO_EVENT);
+                }
+             }
+
+         }
+
+
+         GPT.LeadTimeCounter = GPT.LeadTimeCounter + GPT.DeltaGptimerCounter;
+         if(leadTimeReset && GPT.LeadTimeCounter <= 2000){
+             vscanReset = true;
+         }else{
+             if(notifyFirst_flag){
+                 GPT.NotifyCounter = INSTRUCTION.notifyRate - 20;
+                 notifyFirst_flag = false;
+             }
+             vscanReset = false;
+             leadTimeReset = false;
+         }
+
+        //pulse mode counter
+        GPT.StiCounter = GPT.StiCounter + GPT.DeltaGptimerCounter;
+        GPT.LedGCounter = GPT.LedGCounter + GPT.DeltaGptimerCounter;
+        GPT.LedRCounter = GPT.LedRCounter + GPT.DeltaGptimerCounter;
+        GPT.Gas0Counter = GPT.Gas0Counter + GPT.DeltaGptimerCounter;
+        GPT.Gas1Counter = GPT.Gas1Counter + GPT.DeltaGptimerCounter;
+
+        if (vscanReset) {
+            DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoutGainLevel, 25000));
+            DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoutGainLevel, 25000));
+            //vscanReset = false;
+        }else{
+            if (megaStiEnable) {
+                PULSE_Vscan(WorkModeData->PULSE);
+            }
+
+            if (megaLedGEnable){
+                PULSE_ledG(WorkModeData->PULSE);
+            }
+
+            if (megaLedREnable){
+                PULSE_ledR(WorkModeData->PULSE);
+            }
+
+            if (megaGas0Enable){
+                PULSE_gas0(WorkModeData->PULSE);
+            }
+
+            if (megaGas1Enable){
+                PULSE_gas1(WorkModeData->PULSE);
+            }
+        }
+
+//         if(GPT.VscanRateCounter >= INSTRUCTION.VsetRate){
+//             if(GPT.VscanRateCounter >= INSTRUCTION.VsetRate * 2){
+//                 GPT.GptimerMultiple = GPT.VscanRateCounter / INSTRUCTION.VsetRate;
+//             }else{
+//                 GPT.GptimerMultiple = 1;
+//             }
+//             GPT.VscanRateCounter -= INSTRUCTION.VsetRate * GPT.GptimerMultiple; //To get right time
+//             vscan_flag = true;
+//             if(vscan_flag){
+//                 EliteVscanControl(WorkModeData);
+//                 vscan_flag = false;
+//             }
+//         }
+
+         //battery counter
+         GPT.BatteryADCCounter = GPT.BatteryADCCounter + GPT.DeltaGptimerCounter;
+         GPT.BatteryCheckCounter = GPT.BatteryCheckCounter + GPT.DeltaGptimerCounter;
+         if(GPT.BatteryCheckCounter >= 50000){
+             GPT.BatteryCheckCounter -= 50000; //To get right time
+             batteryCheck_flag = true;
+         }
+
+         uint16_t bat = ((uint16_t)(NotifyVoltBat[2]) << 8 & 0xFF00 ) | ((uint16_t)(NotifyVoltBat[3]) & 0x00FF);
+         if( bat < 768 && bat > 20){
+ //            PIN15_setOutputValue(enable_5v, 0);
+         }
+
+         //ADC counter
+         GPT.SampleRateCounter = GPT.SampleRateCounter + GPT.DeltaGptimerCounter;
+         if(GPT.SampleRateCounter >= INSTRUCTION.sampleRate){
+             GPT.SampleRateCounter = 0; //To get right data, ADC must be delay 1.5ms
+             ADC_flag = true;
+             if(ADC_flag){
+                 EliteADCControl(WorkModeData);
+                 ADC_flag = false;
+             }
+         }
+
+         //Notify counter(Notify control, check if we need to send notify)
+         //please don't put Notify counter before ADC counter, maybe get wrong data
+         GPT.NotifyCounter = GPT.NotifyCounter + GPT.DeltaGptimerCounter;
+         if(GPT.NotifyCounter >= INSTRUCTION.notifyRate){
+             GPT.NotifyCounter -= INSTRUCTION.notifyRate; //To get right time
+             notify_flag = true;
+             if(vscanReset){
+                 notify_flag = false;
+             }
+             if(notify_flag && megaStiEnable){
+                 InputNotify(NOTIFY_IMPEDANCE, Mega_Trig_receive);
+                 SendNotify();
+                 Mega_Trig_receive = false;
+                 notify_flag = false;
+             }
+         }
+
+    //        EliteDone();
+    }
+    else if(INSTRUCTION.eliteFxn == VOLT_OUTPUT){
         WorkModeData->VO->_Vset = INSTRUCTION.VoltConstant;
         DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoutGainLevel, WorkModeData->VO->_Vset)); //UserCode -> DAC code -> DAC out
         FreeWorkMode(WorkModeData);
         PeriodicEvent = false;
-        ELITE15_SPI_CLOSE();
-    }else if(INSTRUCTION.eliteFxn == CALI_DAC_MODE){
+    }
+    else if(INSTRUCTION.eliteFxn == CALI_DAC_MODE){
         DAC_outputV(INSTRUCTION.VoltConstant); //UserCode -> DAC code -> DAC out
         FreeWorkMode(WorkModeData);
         PeriodicEvent = false;
-        ELITE15_SPI_CLOSE();
     }
     else{
-        InitFlag();
+//        InitFlag();
     }
 }
 
@@ -268,6 +422,10 @@ static void EliteADCControl(WorkMode *WorkModeData) {
 
             break;
         }
+        case PULSE_MODE:{
+            CC_Plot(WorkModeData);
+            break;
+        }
         default:{
             break;
         }
@@ -313,6 +471,10 @@ static void EliteVscanControl(WorkMode *WorkModeData) {
             CVSCAN_Vscan(WorkModeData->CVSCAN);
             break;
         }
+        case PULSE_MODE:{
+//            PULSE_Vscan(WorkModeData->PULSE);
+            break;
+        }
         default:{
             break;
         }

simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/simple_peripheral.c

@@ -546,17 +546,18 @@ static void SimpleBLEPeripheral_taskFxn(UArg a0, UArg a1) {
 
     // Initialize application
     SimpleBLEPeripheral_init();
-
     ZM_init();
-//    Elite_SPI_init();
     WorkMode *WorkModeData = CreateWorkMode();
 
+    // init DAC, set output ~= 0 V
+    INSTRUCTION.VoutGainLevel = VOUT_GAIN_15K;
+    VoutGainControl(INSTRUCTION.VoutGainLevel);
+    DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoutGainLevel, 25000));
+
     uint8_t  key         = 0;
     uint16_t counter6994 = 0;
     bool     EliteOn     = 0;
 
-    // init DAC, set output ~= 0 V
-    DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoutGainLevel, 25000));
     elite_gptimer_start();
 
     // Application main loops
@@ -616,6 +617,7 @@ static void SimpleBLEPeripheral_taskFxn(UArg a0, UArg a1) {
             events &= ~SBP_PERIODIC_EVT;
             if (!PeriodicEvent) {                // if there is no periodic event
                 key = PIN_getInputValue(switch_on);
+
                 if (EliteOn) {
                     if (counter6994 < CLOCK_ONE_SECOND/2) {  // counter6994 enable a IC after 35 counts
                         counter6994++;
@@ -624,20 +626,35 @@ static void SimpleBLEPeripheral_taskFxn(UArg a0, UArg a1) {
                         counter6994++;
                     }
                     EliteKeyPress(key);
-                    if(key != 0){  //detect Elite battery power when no periodic event
-                        measureBat();
-                    }
+
+//                    if(key != 0){  //detect Elite battery power when no periodic event
+//                        measureBat();
+//                    }
                     if(Free_Work_Mode){
                         FreeWorkMode(WorkModeData);
                         InitEliteInstruction();
-                        IinADCGainControl(INSTRUCTION.ADCGainLevel);
-                        DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoutGainLevel, INSTRUCTION.VoltConstant));
-
                         Free_Work_Mode = false;
                     }
+                    /* Megafly trigger */
+//                    trig = PIN_getInputValue(MEGA_TRIG);        // trigger: 1 -> 0
+                    if (Mega_PeriodicEvent) {
+                        Mega_PeriodicEvent = false;
+                        PeriodicEvent = true;
+                    } else {
+
+                    }
                 } else {
-                    EliteOn = TurnOnElite(key);
+//                    EliteOn = TurnOnElite(key);
+                    headstage_battery_volt();
+                    uint16_t bat = ((uint16_t)(NotifyVoltBat[2]) << 8 & 0xFF00 ) |
+                                   ((uint16_t)(NotifyVoltBat[3]) & 0x00FF);
+                    PIN15_setOutputValue(enable_5v, 1);  // enable 5V
+                    TurnOn10V();
+                    ModeLED(BT_WAIT);
+                    EliteOn = true;
                 }
+
+
             }
             else {                               // if there is periodic event
                 if(InitPeriodicEvent){