TODO: delete auto gain

[CC] notify rate 10

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

@@ -160,6 +160,7 @@ static int32_t AutoGainReadCurrent(uint8_t *buf){
 
     if(INSTRUCTION.ADCGainLevel == GAIN_AUTO){
         INSTRUCTION.ADCGainLevel = GAIN_200R;
+//        LED_color(DARKLED, 0x00, 0x00, 0xFF);
     }
 
     if(INSTRUCTION.ADCGainLevel == GAIN_200R){
@@ -168,18 +169,18 @@ static int32_t AutoGainReadCurrent(uint8_t *buf){
 
         // switch to mid range current
         if(Real_Current < GAIN_LARGE_BOUNDARY && Real_Current > -1*GAIN_LARGE_BOUNDARY){
-//            LED_color(DARKLED, 0x00, 0x0F, 0xFF);
             INSTRUCTION.ADCGainLevel = GAIN_10K;
             ReadCurrent(spi_ADC_rxbuf);
             Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+//            LED_color(DARKLED, 0x00, 0xFF, 0x00);
 
-            // switch to small range current
-            if (Real_Current < GAIN_MID_BOUNDARY1 && Real_Current > -1*GAIN_MID_BOUNDARY1){
-//                LED_color(DARKLED, 0x00, 0x00, 0xFF);
-                INSTRUCTION.ADCGainLevel = GAIN_200K;
-                ReadCurrent(spi_ADC_rxbuf);
-                Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
-            }
+//            // switch to small range current
+//            if (Real_Current < GAIN_MID_BOUNDARY1 && Real_Current > -1*GAIN_MID_BOUNDARY1){
+//                INSTRUCTION.ADCGainLevel = GAIN_200K;
+//                ReadCurrent(spi_ADC_rxbuf);
+//                Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+//                LED_color(DARKLED, 0xFF, 0x00, 0x00);
+//            }
         }
     }
     else if(INSTRUCTION.ADCGainLevel == GAIN_10K){
@@ -188,18 +189,18 @@ static int32_t AutoGainReadCurrent(uint8_t *buf){
 
         // switch to large range current
         if(Real_Current > GAIN_MID_BOUNDARY2 || Real_Current < -1*GAIN_MID_BOUNDARY2){
-//            LED_color(DARKLED, 0xFF, 0x0F, 0x0F);
             INSTRUCTION.ADCGainLevel = GAIN_200R;
             ReadCurrent(spi_ADC_rxbuf);
             Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+//            LED_color(DARKLED, 0x00, 0x00, 0xFF);
         }
 
         // switch to small range current
         else if (Real_Current < GAIN_MID_BOUNDARY1 && Real_Current > -1*GAIN_MID_BOUNDARY1){
-//            LED_color(DARKLED, 0x00, 0x00, 0xFF);
             INSTRUCTION.ADCGainLevel = GAIN_200K;
             ReadCurrent(spi_ADC_rxbuf);
             Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+//            LED_color(DARKLED, 0xFF, 0x00, 0x00);
         }
     }
     else if(INSTRUCTION.ADCGainLevel == GAIN_200K){
@@ -208,14 +209,12 @@ static int32_t AutoGainReadCurrent(uint8_t *buf){
 
         // switch to mid range current
         if(Real_Current > GAIN_SMALL_BOUNDARY || Real_Current < -1*GAIN_SMALL_BOUNDARY){
-//           LED_color(DARKLED, 0x00, 0x0F, 0xFF);
-           INSTRUCTION.ADCGainLevel = GAIN_10K;
-           ReadCurrent(spi_ADC_rxbuf);
-           Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
-
+            INSTRUCTION.ADCGainLevel = GAIN_10K;
+            ReadCurrent(spi_ADC_rxbuf);
+            Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+//            LED_color(DARKLED, 0x00, 0xFF, 0x00);
            // switch to large range current
 //           if(Real_Current > GAIN_MID_BOUNDARY2 || Real_Current < -1*GAIN_MID_BOUNDARY2){
-//               LED_color(DARKLED, 0xFF, 0x0F, 0x0F);
 //               INSTRUCTION.ADCGainLevel = GAIN_200R;
 //               ReadCurrent(spi_ADC_rxbuf);
 //               Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);

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

@@ -2,128 +2,165 @@
 #ifndef ELITECCMODE
 #define ELITECCMODE
 
-#define CC_ZERO_POINT     1500000
-#define MAX_DAC_UC    50000
-#define MIN_DAC_UC      0
-#define CURRENT_LV_ONE      1
-#define CURRENT_LV_ZERO     0
-
 static void CCModeDACControl(int32_t IUC_Measure_Difference);
 
+static int32_t CCModeReadCurrent(CCMode *CC){
 
-/*********************************************************************
- * @struct  Constant Current Code
- *
- * @brief   A struct to handle CC mode command
- */
-typedef struct _CURRENT_USER_CODE {
-
-    /** current value **/
-    // current value divide current level into 3,000,001 pieces
-    // 1,500,000 is zero point
-    int32_t value;
-
-    /** ADC level range: 0-2 **/
-    // constant current value will decide ADC gain level
-    // if |1500000 - value| > 10000 (+-100 uA)     => lv = GAIN_200R
-    // else if |1500000 - valule| > 1000 (+-10 uA) => lv = GAIN_10K
-    // else lv = GAIN_200K
-    uint8_t lv;
-
-    /* Vmax and Vmin */
-    // Vmax protect battery charge
-    // Vmin protect battery discharge
-    // uint = mV
-    uint16_t Vmax;
-    uint16_t Vmin;
-
-    /** transform a current user code (IUC) to real current in nA **/
-    int32_t (*_Transform2RealnA)(struct _CURRENT_USER_CODE *);
-
-    /** Measure Current **/
-    int32_t _MeasureCurrent;
-
-    /** MeasureCurrent operation **/
-    void (*SetMeasureCurrent)(struct _CURRENT_USER_CODE *, int32_t);
-
-    int32_t (*GetMeasureCurrent)(struct _CURRENT_USER_CODE *);
-}CURRENT_USER_CODE;
-
-//static CURRENT_USER_CODE CurrentUserCode;
-
-static int32_t CCModeReadCurrent(void *WorkModeData){
-
-    int32_t Real_Current = 0;
-    CURRENT_USER_CODE *CurrentUserCode = WorkModeData;
-//    CurrentUserCode = WorkModeData;
+    static uint8_t VoltCurrentSwitch = 0;
 
     CCModeDACEnable = 1;    // This flag will control DAC working
 
     // set current value and ADC gain level
-    CCCurrent2IUC(CurrentUserCode);
-
-    // set ADC gain according to constant current value
-    INSTRUCTION.ADCGainLevel = CurrentUserCode->lv;
-
-    // read ADC current
-    ReadCurrent(spi_ADC_rxbuf);
+    CCCurrent2IUC(CC);
 
     // decode ADC value and put it into notify buffer
-    Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
-    CurrentUserCode->SetMeasureCurrent(CurrentUserCode, Real_Current);
 
-    return Real_Current;
+    // Use 9-th measure value as real-measure value
+    // because some value in the begin are garbage
+    if(VoltCurrentSwitch < 9){
+        ReadCurrent(spi_ADC_rxbuf);
+        VoltCurrentSwitch ++;
+    }
+    else if(VoltCurrentSwitch == 9){
+        // read current
+        if(INSTRUCTION.AutoGainEnable){
+            CC->_MeasureData = AutoGainReadCurrent(spi_ADC_rxbuf);
+        }
+        else{
+            ReadCurrent(spi_ADC_rxbuf);
+            CC->_MeasureData = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+        }
+        VoltCurrentSwitch ++;
+    }
+    else if(VoltCurrentSwitch <18){
+        // read volt
+        ReadVolt(spi_ADC_rxbuf);
+        VoltCurrentSwitch++;
+    }
+    else if(VoltCurrentSwitch == 18){
+        // read volt
+        ReadVolt(spi_ADC_rxbuf);
+        CC->BatteryV = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_VOLT, spi_ADC_rxbuf);
+
+        // if Iin connect to battery +, Vout connect to battery -
+//        CC->BatteryV = CC->BatteryV - (CC->value - CC_ZERO_POINT)*10/1e5;   // I_set * 10R = V_Iin2GND (mA * ohm)
+
+        // if Iin connect to battery -, Vout connect to battery +
+        CC->BatteryV = CC->BatteryV + (CC->value - CC_ZERO_POINT)*10/1e5;   // I_set * 10R = V_Iin2GND (mA * ohm)
+
+        VoltCurrentSwitch++;
+    }
+    else{
+        VoltCurrentSwitch = 0;
+    }
+
+
+//    /** read battery voltage **/
+//    // read ADC volt
+//    ReadVolt(spi_ADC_rxbuf);
+//
+//    // decode ADC value and put it into notify buffer
+//    CC->BatteryV = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_VOLT, spi_ADC_rxbuf);
+//
+    NotifyVolt[0] = (uint8_t) (CC->BatteryV >> 24);
+    NotifyVolt[1] = (uint8_t) ((CC->BatteryV & 0x00FF0000) >> 16);
+    NotifyVolt[2] = (uint8_t) ((CC->BatteryV & 0x0000FF00) >> 8);
+    NotifyVolt[3] = (uint8_t) (CC->BatteryV & 0x000000FF);
+
+    return CC->_MeasureData;
 }
 
-static int32_t CCModeVoltOut(void *WorkModeData){
-    int32_t MeasureCurrent = 0, IUCCurrent = 0;
-    CURRENT_USER_CODE *CurrentUserCode = WorkModeData;
+static int32_t CCModeVoltOut(CCMode *CC){
+    int32_t MeasureCurrent = 0, IUCCurrent = 0, ADCRealVolt = 0;
 
     if(!CCModeDACEnable){
         // DAC should not work now
         return 0;
     }
 
-    IUCCurrent = CurrentUserCode->_Transform2RealnA(CurrentUserCode);
-    if(CurrentUserCode->lv == GAIN_200K || CurrentUserCode->lv == GAIN_10K ){
-        MeasureCurrent = CurrentUserCode->GetMeasureCurrent(CurrentUserCode);
-        CCModeDACControl(IUCCurrent - MeasureCurrent);
-    }
-    else{
-        MeasureCurrent = CurrentUserCode->GetMeasureCurrent(CurrentUserCode);
-        CCModeDACControl(IUCCurrent - MeasureCurrent);
-    }
-//    NotifyCurrent[0] = (uint8_t) (IUCCurrent >> 24);
-//    NotifyCurrent[1] = (uint8_t) ((IUCCurrent & 0x00FF0000) >> 16);
-//    NotifyCurrent[2] = (uint8_t) ((IUCCurrent & 0x0000FF00) >> 8);
-//    NotifyCurrent[3] = (uint8_t) (IUCCurrent & 0x000000FF);
-//
-//    NotifyVolt[0] = (uint8_t) (MeasureCurrent >> 24);
-//    NotifyVolt[1] = (uint8_t) ((MeasureCurrent & 0x00FF0000) >> 16);
-//    NotifyVolt[2] = (uint8_t) ((MeasureCurrent & 0x0000FF00) >> 8);
-//    NotifyVolt[3] = (uint8_t) (MeasureCurrent & 0x000000FF);
+    IUCCurrent = CC->_Transform2RealnA(CC);
+
+    MeasureCurrent = CC->_MeasureData;
+    CCModeDACControl(IUCCurrent - MeasureCurrent);
+
+    NotifyCurrent[0] = (uint8_t) (IUCCurrent >> 24);
+    NotifyCurrent[1] = (uint8_t) ((IUCCurrent & 0x00FF0000) >> 16);
+    NotifyCurrent[2] = (uint8_t) ((IUCCurrent & 0x0000FF00) >> 8);
+    NotifyCurrent[3] = (uint8_t) (IUCCurrent & 0x000000FF);
+
+    NotifyImpedance[0] = (uint8_t) (MeasureCurrent >> 24);
+    NotifyImpedance[1] = (uint8_t) ((MeasureCurrent & 0x00FF0000) >> 16);
+    NotifyImpedance[2] = (uint8_t) ((MeasureCurrent & 0x0000FF00) >> 8);
+    NotifyImpedance[3] = (uint8_t) (MeasureCurrent & 0x000000FF);
+
+//    DACCode2Real2Notify(Usercode_Correction_to_DAC(INSTRUCTION.VoltConstant));
+//    if(IUCCurrent > 1000){
+//        ADCRealVolt = 2*(INSTRUCTION.VoltConstant - 25000)/10 - IUCCurrent*200/1e6;
+//    }
+//    else{
+//        CC->BatteryV = 2*(INSTRUCTION.VoltConstant - 25000)/10 - IUCCurrent*200/1e7;
+//    }
+
+//    NotifyVolt[0] = (uint8_t) (CC->BatteryV >> 24);
+//    NotifyVolt[1] = (uint8_t) ((CC->BatteryV & 0x00FF0000) >> 16);
+//    NotifyVolt[2] = (uint8_t) ((CC->BatteryV & 0x0000FF00) >> 8);
+//    NotifyVolt[3] = (uint8_t) (CC->BatteryV & 0x000000FF);
 
-    DACCode2Real2Notify(Usercode_Correction_to_DAC(INSTRUCTION.VoltConstant));
     CCModeDACEnable = 0;
     return MeasureCurrent;
 }
 
 static void CCModeDACControl(int32_t IUC_Measure_Difference){
-    if(IUC_Measure_Difference > 100000 || IUC_Measure_Difference < -100000){
-        INSTRUCTION.VoltConstant = INSTRUCTION.VoltConstant + IUC_Measure_Difference/1e4;
-        DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoltConstant));
+    int32_t step;
+    if(IUC_Measure_Difference < 100 && IUC_Measure_Difference > -100){
+        step = (IUC_Measure_Difference > 0) ? 1:-1;
     }
-    else if(IUC_Measure_Difference > 1000 || IUC_Measure_Difference < -1000){
-        INSTRUCTION.VoltConstant = INSTRUCTION.VoltConstant + IUC_Measure_Difference/1e3;
-        DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoltConstant));
+    else if(IUC_Measure_Difference < 1000 && IUC_Measure_Difference > -1000){
+        step = IUC_Measure_Difference / 100;
     }
-    else if(IUC_Measure_Difference > 0){
-        INSTRUCTION.VoltConstant = INSTRUCTION.VoltConstant + 1;
-        DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoltConstant));
+    else if(IUC_Measure_Difference < 10000 && IUC_Measure_Difference > -10000){
+        step = IUC_Measure_Difference / 1000;
     }
-    else if(IUC_Measure_Difference < 0){
-       INSTRUCTION.VoltConstant = INSTRUCTION.VoltConstant - 1;
-       DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoltConstant));
+    else{
+        step = IUC_Measure_Difference / 1e4;
+    }
+
+    // over/under flow
+    if( (INSTRUCTION.VoltConstant + step) > MAX_DAC_UC || (INSTRUCTION.VoltConstant + step) < MIN_DAC_UC ){
+        if(step > 0){
+            INSTRUCTION.VoltConstant = (INSTRUCTION.VoltConstant + MAX_DAC_UC)/2;
+        }
+        else{
+            INSTRUCTION.VoltConstant = (INSTRUCTION.VoltConstant + MIN_DAC_UC)/2;
+        }
+    }
+    else{
+        INSTRUCTION.VoltConstant = INSTRUCTION.VoltConstant + step;
+    }
+    DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoltConstant));
+}
+
+// XXX : should we reset DAC output after STOP?
+static void CCModeReverseCurrent(CCMode *CC){
+    if(CC->StandBy){
+        if(CT.StandByCounter == CC->StandByTime){
+            CC->StandBy = false;
+            CT.StandByCounter = 0;
+        }
+        else{
+            CT.StandByCounter ++;
+        }
+    }
+    else{
+        // reverse charge/discharge
+        if(CC->BatteryV == CC->VMax){
+            CC->StandBy = true;
+            CC->value = CC->DischargeCurrent;
+        }
+        else if(CC->BatteryV == CC->VMin){
+            CC->StandBy = true;
+            CC->value = CC->ChargeCurrent;
+        }
     }
 }
 
@@ -133,24 +170,24 @@ static void CCModeDACControl(int32_t IUC_Measure_Difference){
 * Real current value : -15.00000 ~ 15.00000 mA
 *  => user code = 1500000 mapping to 0.00000 mA
 */
-static void CCCurrent2IUC(CURRENT_USER_CODE *CurrentUserCode){
+static void CCCurrent2IUC(CCMode *CC){
     int32_t CurrentValue = 0;
 
-    CurrentUserCode->value = INSTRUCTION.ConstantCurrent;
-    CurrentValue = CurrentUserCode->value - CC_ZERO_POINT;
+    CC->value = INSTRUCTION.ConstantCurrent;
+    CurrentValue = CC->value - CC_ZERO_POINT;
 
     /* set ADC level */
     // largest current
     if (CurrentValue > 10000 || CurrentValue < -10000){
-        CurrentUserCode->lv = GAIN_200R;
+        CC->lv = GAIN_200R;
     }
     // mid range current
     else if (CurrentValue > 1000 || CurrentValue < -1000){
-        CurrentUserCode->lv = GAIN_10K;
+        CC->lv = GAIN_10K;
     }
     // least range current
     else{
-        CurrentUserCode->lv = GAIN_200K;
+        CC->lv = GAIN_200K;
     }
 }
 
@@ -163,33 +200,33 @@ static void CCCurrent2IUC(CURRENT_USER_CODE *CurrentUserCode){
  *
  * @return  an int32_t current value in nA
  */
-static int32_t _Transform2RealnA(CURRENT_USER_CODE *self){
-    int32_t IUCReal;
+//static int32_t _Transform2RealnA(CCMode *self){
+//    int32_t IUCReal;
+//
+//    // self->value : 0 ~ 3000000 (which is -1500000 ~ 1500000 (10nA) )
+//    IUCReal = (self->value - CC_ZERO_POINT) * 10;
+//    return IUCReal;
+//}
+//
+//static void SetMeasureCurrent(CCMode *self, int32_t current){
+//    self->_MeasureCurrent = current;
+//}
+//
+//static int32_t GetMeasureCurrent(CCMode *self){
+//    return self->_MeasureCurrent;
+//}
 
-    // self->value : 0 ~ 3000000 (which is -1500000 ~ 1500000 (10nA) )
-    IUCReal = (self->value - CC_ZERO_POINT) * 10;
-    return IUCReal;
-}
-
-static void SetMeasureCurrent(CURRENT_USER_CODE *self, int32_t current){
-    self->_MeasureCurrent = current;
-}
-
-static int32_t GetMeasureCurrent(CURRENT_USER_CODE *self){
-    return self->_MeasureCurrent;
-}
-
-static CURRENT_USER_CODE *InitCurrentUserCode(){
-    CURRENT_USER_CODE *CurrentUserCode = malloc(sizeof(CURRENT_USER_CODE));
-    CurrentUserCode->value = CC_ZERO_POINT;
-    CurrentUserCode->lv = GAIN_AUTO;
-    CurrentUserCode->Vmax = MAX_DAC_UC;  // max DAC UserCode
-    CurrentUserCode->Vmin = MIN_DAC_UC;  // min DAC UserCode
-    CurrentUserCode-> _MeasureCurrent = 0;
-    CurrentUserCode->_Transform2RealnA = &_Transform2RealnA;
-    CurrentUserCode->SetMeasureCurrent = &SetMeasureCurrent;
-    CurrentUserCode->GetMeasureCurrent = &GetMeasureCurrent;
-    return CurrentUserCode;
-}
+//static CURRENT_USER_CODE *InitCurrentUserCode(){
+//    CCMode *CurrentUserCode = malloc(sizeof(CCMode));
+//    CurrentUserCode->value = CC_ZERO_POINT;
+//    CurrentUserCode->lv = GAIN_AUTO;
+//    CurrentUserCode->Vmax = MAX_DAC_UC;  // max DAC UserCode
+//    CurrentUserCode->Vmin = MIN_DAC_UC;  // min DAC UserCode
+//    CurrentUserCode-> _MeasureData = 0;
+//    CurrentUserCode->_Transform2RealnA = &_Transform2RealnA;
+//    CurrentUserCode->SetMeasureData = &SetMeasureCurrent;
+//    CurrentUserCode->GetMeasureData = &GetMeasureCurrent;
+//    return CurrentUserCode;
+//}
 
 #endif

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

@@ -2,7 +2,7 @@
 #ifndef ELITECV
 #define ELITECV
 
-static uint16_t SWVCurve() {
+static uint16_t SWVCurve(WorkMode *WorkModeData) {
     static uint8_t  counter;
     static uint16_t outputV;
     static uint16_t Volt;
@@ -57,7 +57,7 @@ static uint16_t SWVCurve() {
     return outputV;
 }
 
-static uint16_t DPVCurve() {
+static uint16_t DPVCurve(WorkMode *WorkModeData) {
     static uint8_t  counter;
     static uint16_t Volt1;
     static uint16_t Volt2;
@@ -132,15 +132,15 @@ static uint16_t DPVCurve() {
     }
 }
 
-static uint16_t CVCurve() {
+static uint16_t CVCurve(CVMode *CV) {
     static uint16_t DACOutCode;
     static bool direction_up;           // direction_up = true, if Vfinal > Vorigin
     static bool current_direction_up;   // current_direction_up = true, Vstep => positive. vice versa
 
     // reset origin volt at the begin
     if (DACReset) {
-        DACUserCode = INSTRUCTION.VoltOrigin;
-        if (INSTRUCTION.VoltFinal > INSTRUCTION.VoltOrigin) {
+        DACUserCode = CV->_VOrigin;
+        if (INSTRUCTION.VoltFinal > CV->_VOrigin) {
             direction_up         = true;
             current_direction_up = true;
         } else {
@@ -155,30 +155,30 @@ static uint16_t CVCurve() {
         return DACOutCode;
     }
 
-    if (StepTimeCounter == INSTRUCTION.StepTime) {
+    if (CT.StepTimeCounter == CV->_StepTime) {
 
         // Decide next direction
         if (direction_up) {
-            if (DACUserCode >= INSTRUCTION.VoltFinal) {
+            if (DACUserCode >= CV->_VStop) {
                 current_direction_up = false;  // problem occurs when origin == 0000 final == ffff!!!!!!
-            } else if (DACUserCode <= INSTRUCTION.VoltOrigin) {
+            } else if (DACUserCode <= CV->_VOrigin) {
                 current_direction_up = true;
-                if (INSTRUCTION.CycleNumber == 0) {
+                if (CV->_CycleNumber == 0) {
                     PeriodicEvent = false;  // periodic event end
                     DACReset      = true;
                 }
-                INSTRUCTION.CycleNumber--;
+                CV->_CycleNumber--;
             }
         } else {
-            if (DACUserCode <= INSTRUCTION.VoltFinal) {
+            if (DACUserCode <= CV->_VStop) {
                 current_direction_up = true;  // problem occurs when origin == 0000 final == ffff!!!!!!
-            } else if (DACUserCode >= INSTRUCTION.VoltOrigin) {
+            } else if (DACUserCode >= CV->_VOrigin) {
                 current_direction_up = false;
-                if (INSTRUCTION.CycleNumber == 0) {
+                if (CV->_CycleNumber == 0) {
                     PeriodicEvent = false;  // periodic event end
                     DACReset      = true;
                 }
-                INSTRUCTION.CycleNumber--;
+                CV->_CycleNumber--;
             }
         }
 
@@ -186,52 +186,52 @@ static uint16_t CVCurve() {
         if (direction_up) {
             if (current_direction_up) {
                 // DACUserCode overflow ?
-                if (DACUserCode + INSTRUCTION.Step < DACUserCode) {
-                    DACUserCode = INSTRUCTION.VoltFinal;
+                if (DACUserCode + CV->_Step < DACUserCode) {
+                    DACUserCode = CV->_VStop;
                 }
-                else if (DACUserCode + INSTRUCTION.Step > INSTRUCTION.VoltFinal) {
-                    DACUserCode = INSTRUCTION.VoltFinal;
+                else if (DACUserCode + CV->_Step > CV->_VStop) {
+                    DACUserCode =CV->_VStop;
                 }
                 else {
-                    DACUserCode = DACUserCode + INSTRUCTION.Step;
+                    DACUserCode = DACUserCode + CV->_Step;
                 }
             }
             else {
                 // DACUserCode underflow ?
-                if (DACUserCode - INSTRUCTION.Step > DACUserCode || DACUserCode > 60000) {
-                    DACUserCode = INSTRUCTION.VoltOrigin;
+                if (DACUserCode - CV->_Step > DACUserCode || DACUserCode > 60000) {
+                    DACUserCode = CV->_VOrigin;
                 }
 
                 // reach Vorigin ?
-                else if (DACUserCode - INSTRUCTION.Step <  INSTRUCTION.VoltOrigin) {
-                    DACUserCode = INSTRUCTION.VoltOrigin;
+                else if (DACUserCode - CV->_Step <  CV->_VOrigin) {
+                    DACUserCode = CV->_VOrigin;
                 }
                 else {
-                    DACUserCode = DACUserCode - INSTRUCTION.Step;
+                    DACUserCode = DACUserCode - CV->_Step;
                 }
             }
         }
         else {
             if (current_direction_up) {
-                if (DACUserCode + INSTRUCTION.Step < DACUserCode) {
-                     DACUserCode = INSTRUCTION.VoltOrigin;
+                if (DACUserCode + CV->_Step < DACUserCode) {
+                     DACUserCode = CV->_VOrigin;
                 }
-                else if (DACUserCode + INSTRUCTION.Step >  INSTRUCTION.VoltOrigin) {
-                    DACUserCode = INSTRUCTION.VoltOrigin;
+                else if (DACUserCode + CV->_Step >  CV->_VOrigin) {
+                    DACUserCode = CV->_VOrigin;
                 }
                 else {
-                     DACUserCode = DACUserCode + INSTRUCTION.Step;
+                     DACUserCode = DACUserCode + CV->_Step;
                 }
             }
             else {
-                if (DACUserCode - INSTRUCTION.Step > DACUserCode || DACUserCode > 60000) {
-                     DACUserCode = INSTRUCTION.VoltFinal;
+                if (DACUserCode - CV->_Step > DACUserCode || DACUserCode > 60000) {
+                     DACUserCode = CV->_VStop ;
                 }
-                else if (DACUserCode - INSTRUCTION.Step < INSTRUCTION.VoltFinal) {
-                    DACUserCode = INSTRUCTION.VoltFinal;
+                else if (DACUserCode - CV->_Step < CV->_VStop) {
+                    DACUserCode = CV->_VStop;
                 }
                 else {
-                     DACUserCode = DACUserCode - INSTRUCTION.Step;
+                     DACUserCode = DACUserCode - CV->_Step;
                 }
             }
         }

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

@@ -29,7 +29,7 @@
 */
 
 
-#define BOARD_VENUS
+#define BOARD_MERCURY
 
 typedef struct _formula{
 
@@ -141,8 +141,8 @@ struct _correction{
 .ADC_current[0].coeff = 30022512,
 .ADC_current[0].offset = -729552647201,
 
-.ADC_current[1].coeff = 658398533,
-.ADC_current[1].offset = -16001498741131,
+.ADC_current[1].coeff = 658398533000,
+.ADC_current[1].offset = -16001498741131000,
 
 .ADC_current[2].coeff = 30908351000,
 .ADC_current[2].offset = -746548614824000,
@@ -172,8 +172,8 @@ struct _correction{
 .ADC_current[1].coeff = 652738209,
 .ADC_current[1].offset = -15767733896990,
 
-.ADC_current[2].coeff = 30959456,
-.ADC_current[2].offset = -748026885843,
+.ADC_current[2].coeff = 30959456000,
+.ADC_current[2].offset = -748026885843000,
 
 .DAC2RealV.coeff = (-18880478),
 .DAC2RealV.offset = 629012735316,
@@ -350,8 +350,8 @@ struct _correction{
 .ADC_current[1].coeff = 68760643,
 .ADC_current[1].offset = (-1123221851971),
 
-.ADC_current[2].coeff = 61882330,
-.ADC_current[2].offset = (-1010385966159),
+.ADC_current[2].coeff = 61882330000,
+.ADC_current[2].offset = (-10103859661590),
 
 .DAC2RealV.coeff = (-18690126),
 .DAC2RealV.offset = 564319610294,
@@ -462,8 +462,8 @@ struct _correction{
 .ADC_current[1].coeff = 656423459,
 .ADC_current[1].offset = (-10660544072862),
 
-.ADC_current[2].coeff = 31414514,
-.ADC_current[2].offset = (-510185549182),
+.ADC_current[2].coeff = 31414514000,
+.ADC_current[2].offset = (-510185549182000),
 
 .DAC2RealV.coeff = (-18990774),
 .DAC2RealV.offset = 570886531263,
@@ -507,34 +507,6 @@ struct _correction{
 };
 #endif
 
-#ifdef BOARD_WATER_STAR
-{
-.ADC_volt.coeff = (-6259808),
-.ADC_volt.offset = 102009860128,
-
-.ADC_current[0].coeff = 31335917,
-.ADC_current[0].offset = (-511426612252),
-
-.ADC_current[1].coeff = 658172815,
-.ADC_current[1].offset = (-10738251896209),
-
-.ADC_current[2].coeff = 31482687000,
-.ADC_current[2].offset = (-513650531545000),
-
-.DAC2RealV.coeff = (-10548297),
-.DAC2RealV.offset = 562611756757,
-
-.Usercode2DAC.coeff = (-10500262),
-.Usercode2DAC.offset = 559630236100,
-
-.Gain0Boundary[0] = 0x5D96,
-.Gain0Boundary[1] = 0x5DD9,
-
-.Gain1Boundary[0] = 0x57CD,
-.Gain1Boundary[1] = 0x639F
-};
-#endif
-
 #ifdef BOARD_MARS
 {
 .ADC_volt.coeff = (-6270623),
@@ -690,10 +662,6 @@ static int32_t DecodeADCValue(uint8_t ADCGain, uint8_t ADCChannel, uint8_t *ADC_
     // return real volt to controller
     if(ADCChannel == ADC_CH_VOLT){
         ADCRealVolt = DecodeADCVolt(ADC_measure);
-        NotifyVolt[0] = (uint8_t) (ADCRealVolt >> 24);
-        NotifyVolt[1] = (uint8_t) ((ADCRealVolt & 0x00FF0000) >> 16);
-        NotifyVolt[2] = (uint8_t) ((ADCRealVolt & 0x0000FF00) >> 8);
-        NotifyVolt[3] = (uint8_t) (ADCRealVolt & 0x000000FF);
         ret = ADCRealVolt;
     }
 
@@ -703,8 +671,16 @@ static int32_t DecodeADCValue(uint8_t ADCGain, uint8_t ADCChannel, uint8_t *ADC_
         if ( (INSTRUCTION.eliteFxn == IV_CURVE) || (INSTRUCTION.eliteFxn == CV_CURVE)) {
             // wait 0.1 sec until circuit stable => discard first data means wait 0.1 sec
             if(DiscardIVFirstData){
-                DiscardIVFirstData = 0;
-                return 0;
+                DiscardIVFirstData ++;
+                DecodeADCCurrent(ADCGain, ADC_measure);
+                ret = DecodeADCCurrent(ADCGain, ADC_measure);
+
+                // DiscardIVFirstData :1,2; discard two data
+                // DiscardIVFirstData = 0; recording data
+                if(DiscardIVFirstData == 3){
+                    DiscardIVFirstData = 0;
+                }
+                return ret;
             }
 
             // return a real time current (used for deciding auto gain)
@@ -712,7 +688,7 @@ static int32_t DecodeADCValue(uint8_t ADCGain, uint8_t ADCChannel, uint8_t *ADC_
             ADCRealCurrent_long = ADCRealCurrent_long + ret;
             avg_number ++;
 
-            if (StepTimeCounter == INSTRUCTION.StepTime - 1) {
+            if (CT.StepTimeCounter == INSTRUCTION.StepTime - 1) {
                 DiscardIVFirstData = 1;
                 ADCRealCurrent_long = ADCRealCurrent_long / avg_number;
                 NotifyCurrent[0] = (uint8_t) (ADCRealCurrent_long >> 24);
@@ -721,6 +697,12 @@ static int32_t DecodeADCValue(uint8_t ADCGain, uint8_t ADCChannel, uint8_t *ADC_
                 NotifyCurrent[3] = (uint8_t) (ADCRealCurrent_long & 0x000000FF);
                 avg_number = 0;
                 ADCRealCurrent_long = 0;
+
+                int32_t G = ADCGain;
+                NotifyImpedance[0] = (uint8_t) (G >> 24);
+                NotifyImpedance[1] = (uint8_t) ((G & 0x00FF0000) >> 16);
+                NotifyImpedance[2] = (uint8_t) ((G & 0x0000FF00) >> 8);
+                NotifyImpedance[3] = (uint8_t) (G & 0x000000FF);
             }
         }
 
@@ -733,7 +715,6 @@ static int32_t DecodeADCValue(uint8_t ADCGain, uint8_t ADCChannel, uint8_t *ADC_
             NotifyCurrent[3] = (uint8_t) (ADCRealCurrent & 0x000000FF);
             ret = ADCRealCurrent;
         }
-
     }
 
     else{

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

@@ -0,0 +1,21 @@
+
+#ifndef ELITE_FLAG_CT_INIT
+#define ELITE_FLAG_CT_INIT
+
+static void InitCT(){
+    CT.SampleRate_counter = 1;
+    CT.StepTimeCounter = 1;
+    CT.NotifyCounter = 1;
+    CT.StandByCounter = 0;
+}
+
+static void InitFlag(){
+    PeriodicEvent = false;      // is there an PeriodicEvent?
+    InitPeriodicEvent = true;   // need to create a WorkModeData?
+    DACReset = true;
+    CCModeDACEnable = 0;        // to make sure DAC work after ADC
+    Free_Work_Mode = true;      // Free(WorkModeData)
+//    DiscardIVFirstData = 0;
+}
+
+#endif

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

@@ -2,6 +2,8 @@
 #ifndef ELITEIT
 #define ELITEIT
 
+#define absolute(a) ((a<0)? -a:a)
+
 //static int32_t IT_Plot() {
 //    // read ADC current
 //    int32_t Real_Current = 0;
@@ -20,7 +22,27 @@
 //    return Real_Current;
 //}
 
-static int32_t  IT_Plot() {
+static int32_t IT_Plot(WorkMode *WorkModeData) {
+
+    switch (INSTRUCTION.eliteFxn) {
+            case IV_CURVE:{
+                #define CURRENT_MODE WorkModeData->IV
+                break;
+            }
+            case CV_CURVE:{
+                #define CURRENT_MODE WorkModeData->CV
+                break;
+            }
+            case IT_CURVE:{
+                #define CURRENT_MODE WorkModeData->IT
+                break;
+            }
+            default: {
+                #define CURRENT_MODE WorkModeData->IV
+                break;
+            }
+    }
+   
     // read ADC current
     int32_t Real_Current = 0;
 
@@ -32,7 +54,22 @@ static int32_t  IT_Plot() {
         Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
     }
 
+    // IT->SetMeasureData((struct Measure *) IT, Real_Current);
+    // Real_Current = IT->GetMeasureData((struct Measure *) IT);
+    CURRENT_MODE->_MeasureData = Real_Current;
+
+
+//     if(INSTRUCTION.eliteFxn == IV_CURVE){
+//         if(absolute(Real_Current) > CURRENT_MODE->_LimitValue){
+////             PeriodicEvent = false;  //Real current exceed expected limit value, force stop
+////             DACReset      = true;
+//             reset();
+//         }
+//     }
+
+
     return Real_Current;
 }
 
+
 #endif

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

@@ -2,7 +2,7 @@
 #ifndef ELITEIV
 #define ELITEIV
 
-static uint16_t VoltScan() {
+static uint16_t VoltScan(WorkMode *WorkModeData) {
     uint16_t Voltage;
     if (INSTRUCTION.VoltOrigin == INSTRUCTION.VoltFinal) {
         Voltage = Usercode_Correction_to_DAC(INSTRUCTION.VoltOrigin);
@@ -10,27 +10,28 @@ static uint16_t VoltScan() {
         PeriodicEvent = false;
         return Voltage;
     } else if (INSTRUCTION.eliteFxn == SQUARE_WAVE_VOLTAMMETRY) {
-        Voltage = SWVCurve();
+        Voltage = SWVCurve(WorkModeData);
     } else if (INSTRUCTION.eliteFxn == DIFFERENTIAL_PULSE_VOLTAMMETRY) {
-        Voltage = DPVCurve();
+        Voltage = DPVCurve(WorkModeData);
     } else if (INSTRUCTION.eliteFxn == CV_CURVE) {
-        Voltage = CVCurve();
+        Voltage = CVCurve(WorkModeData->CV);
     }
 
     // IV plot mode
     else {
-        Voltage = OneWayVoltScan();
+        Voltage = OneWayVoltScan(WorkModeData->IV);
     }
 
     return Voltage;
 }
 
-static uint16_t OneWayVoltScan() {
+static uint16_t OneWayVoltScan(IVMode *IV) {
     static uint16_t DACOutCode;
 
     // reset origin volt at the begin
     if (DACReset) {
-        DACUserCode = INSTRUCTION.VoltOrigin;
+//        DACUserCode = IV->GetVOrigin((struct VoltOutPara *) IV);
+        DACUserCode = IV->_VOrigin;
         DACOutCode = Usercode_Correction_to_DAC(DACUserCode);
         DACReset   = false;
 
@@ -39,26 +40,26 @@ static uint16_t OneWayVoltScan() {
         return DACOutCode;
     }
 
-    if (StepTimeCounter == INSTRUCTION.StepTime) {
-        if (INSTRUCTION.VoltOrigin < INSTRUCTION.VoltFinal) {
+    if (CT.StepTimeCounter == IV->_StepTime){
+        if (IV->_VOrigin < IV->_VStop) {
             // output the next output volt
-            DACUserCode = DACUserCode + INSTRUCTION.Step;
+            DACUserCode = DACUserCode + IV->_Step;
             DACOutCode = Usercode_Correction_to_DAC(DACUserCode);
             DAC_outputV(DACOutCode);
 
             // end IV task if we reach INSTRUCTION.VoltFinal
-            if (DACUserCode >= INSTRUCTION.VoltFinal) {
+            if (DACUserCode >= IV->_VStop) {
                 PeriodicEvent = false;
                 DACReset      = true;
             }
         } else {
 
-            DACUserCode = DACUserCode - INSTRUCTION.Step;
+            DACUserCode = DACUserCode - IV->_Step;
 
             // check if DACUserCode underflow
             if(DACUserCode >= 60000){
 //                LED_color(DARKLED, 0xFF, 0x00, 0x00);
-                DACUserCode = INSTRUCTION.VoltFinal;
+                DACUserCode = IV->_VStop;
             }
 
 //            int32_t DACUC = DACUserCode;
@@ -72,9 +73,10 @@ static uint16_t OneWayVoltScan() {
             DAC_outputV(DACOutCode);
 
             // end IV task if we reach INSTRUCTION.VoltFinal
-            if (DACUserCode <= INSTRUCTION.VoltFinal) {
+            if (DACUserCode <= IV->_VStop){
                 PeriodicEvent = false;
                 DACReset      = true;
+//                reset();
             }
         }
     }

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

@@ -20,6 +20,16 @@
 #define CURRENT_LV_UA 0x01
 #define CURRENT_LV_MA 0x02
 
+/* DAC reset parameter */
+#define DAC_ZERO 25000
+#define DAC_POS_MAX 0x0000
+#define DAC_NEG_MAX 0xFFFF
+
+// Step time macro
+#define STEPTIME_HALF_SEC 5000
+#define STEPTIME_ONE_SEC 10000
+#define STEPTIME_TWO_SEC 20000
+
 /*==============================
  ==== headstage instruction ====
  =============================*/
@@ -38,6 +48,7 @@ struct HEADSTAGE_INSTRUCTION {
     uint16_t VoltFinal;
     uint16_t Step;
     uint16_t  StepTime;
+
      // constant volt
     uint16_t VoltConstant;
 
@@ -46,6 +57,9 @@ struct HEADSTAGE_INSTRUCTION {
 
     uint8_t AutoGainEnable;
 
+    /** Notify parameter **/
+    uint16_t NotifyRate;
+
     /** Constant Current Parameter **/
     int32_t ConstantCurrent;
 
@@ -71,14 +85,15 @@ struct HEADSTAGE_INSTRUCTION {
 static void InitEliteInstruction(){
     INSTRUCTION.chip_id = 0;
     INSTRUCTION.SampleRateIndex = 1;
-    INSTRUCTION.SampleRate = 10;
+    INSTRUCTION.SampleRate = 100;
     INSTRUCTION.VoltOrigin = DAC_ZERO;
-    INSTRUCTION.VoltFinal = DAC_POS_MAX;
+    INSTRUCTION.VoltFinal = DAC_ZERO;
     INSTRUCTION.Step = 0x0005; // 0x0005 = 1mV
     INSTRUCTION.StepTime = STEPTIME_HALF_SEC;    // about 0.5 sec
-    INSTRUCTION.VoltConstant = 25000;  // is about 0V
+    INSTRUCTION.VoltConstant = DAC_ZERO;  // is about 0V
     INSTRUCTION.ADCGainLevel = GAIN_AUTO;
     INSTRUCTION.AutoGainEnable = 1;
+    INSTRUCTION.NotifyRate = STEPTIME_ONE_SEC/10;
     INSTRUCTION.ResisterMeter = RESISTER_METER_LARGE;
     INSTRUCTION.ConstantCurrent = 0x00000000;
     INSTRUCTION.eliteFxn = 0; // default is a null event

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

@@ -3,15 +3,14 @@
 #define ELITERESET
 
 static void reset() {
-    PeriodicEvent       = false;
-    DACReset = true;
-    CCModeDACEnable = 0;
-    InitEliteInstruction();
-    SampleRate_counter  = 1;
-    StepTimeCounter     = 1;
-    DiscardIVFirstData = 1;
+    InitFlag();
+    InitCT();
+
+    // IV/CV mode reset
+    DiscardIVFirstData = 0;
     avg_number          = 0;
     ADCRealCurrent_long = 0;
+
     ADCGainControl(INSTRUCTION.ADCGainLevel);
     DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoltConstant));
 
@@ -50,17 +49,15 @@ static void reset() {
 }
 
 static void Eliteinterrupt() {
-    PeriodicEvent       = false;
-    DACReset = true;
-    CCModeDACEnable = 0;
-    InitEliteInstruction();
-    StepTimeCounter     = 1;
-    SampleRate_counter  = 1;
-    DiscardIVFirstData = 1;
+    InitFlag();
+    InitCT();
+
+    // IV/CV mode reset
+    DiscardIVFirstData = 0;
     avg_number          = 0;
     ADCRealCurrent_long = 0;
-    ADCGainControl(INSTRUCTION.ADCGainLevel);
-    DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoltConstant));
+//    ADCGainControl(INSTRUCTION.ADCGainLevel);
+//    DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoltConstant));
 
     LEDPowerON();
     for (int i = 0; i < BLE_INS_BUFF_SIZE; i++) {
@@ -92,13 +89,10 @@ static void Eliteinterrupt() {
 }
 
 static void CleanBuffer() {
-    PeriodicEvent       = false;
-    DACReset = true;
-    CCModeDACEnable = 0;
-//    InitEliteInstruction();
-    SampleRate_counter  = 1;
-    StepTimeCounter     = 1;
-    DiscardIVFirstData = 1;
+    InitFlag();
+    InitEliteInstruction();
+    InitCT();
+    DiscardIVFirstData = 0;
     avg_number          = 0;
     ADCRealCurrent_long = 0;
 

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

@@ -2,7 +2,7 @@
 #ifndef ELITEVT
 #define ELITEVT
 
-static void VT_Plot() {
+static void VT_Plot(VTMode *VT) {
     // ADC gain is don't care when measuring voltage
     uint8_t ADCGain = 0;
 
@@ -10,7 +10,13 @@ static void VT_Plot() {
     ReadVolt(spi_ADC_rxbuf);
 
     // decode ADC value and put it into notify buffer
-    DecodeADCValue(ADCGain, ADC_CH_VOLT, spi_ADC_rxbuf);
+    VT->SetMeasureData((struct Measure *) VT, DecodeADCValue(ADCGain, ADC_CH_VOLT, spi_ADC_rxbuf));
+
+    int32_t ADCRealVolt = VT->GetMeasureData((struct Measure *) VT);
+    NotifyVolt[0] = (uint8_t) (ADCRealVolt >> 24);
+    NotifyVolt[1] = (uint8_t) ((ADCRealVolt & 0x00FF0000) >> 16);
+    NotifyVolt[2] = (uint8_t) ((ADCRealVolt & 0x0000FF00) >> 8);
+    NotifyVolt[3] = (uint8_t) (ADCRealVolt & 0x000000FF);
 }
 
 #endif

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

@@ -0,0 +1,574 @@
+/**
+*
+* struct WorkMode{
+*   // Measure Only
+*   ITMode;
+*   VTMode;
+*
+*   // Measure + VoltOut
+*   RTMode;
+*   IVMode;
+*   CVMode;
+*
+*   // Volt out only
+*   VOutMode
+* }
+*
+* -------------------------------
+* // Measure Only
+* struct ITMode{
+*   MeasureData
+*   SetMeasureData()
+*   GetMeasureData()
+* }
+*
+* -------------------------------
+* // VoltOut parameter
+* stuct VOutMode{
+*   Vout_UC
+*   VoltOrigin
+*   Vstop;
+*   Step;
+*   StepTime;
+*   CycleNumber;
+* }
+*
+*/
+
+#ifndef ELITE_WORK_DATA
+#define ELITE_WORK_DATA
+
+#include "EliteInstruction.h"
+#define IV_CURVE 0b00010000
+#define CV_CURVE 0b00100000
+#define VOLT_OUTPUT 0b00110000
+#define ZT_CURVE 0b01000000
+#define VT_CURVE 0b01010000
+#define IT_CURVE 0b01100000
+#define SET_SAMPLE_RATE 0b01110000
+#define SET_ADC_GAIN 0b10000000
+#define DIFFERENTIAL_PULSE_VOLTAMMETRY 0b10100000
+#define SQUARE_WAVE_VOLTAMMETRY 0b10110000
+#define POTENTIAL_STATE 0b11000000
+#define CONSTANT_CURRENT 0b11010000
+#define SET_RESISTER_LEVEL 0b11100000
+
+static bool Free_Work_Mode = false;
+typedef void (*InitWorkData) ();
+
+/***** Template of Measure and VoltOut parameter *****/
+#define MEASURE \
+    int32_t _MeasureData;    \
+    void (*SetMeasureData) (struct Measure *, int32_t);  \
+    int32_t (*GetMeasureData) (struct Measure *)
+
+/* VoltOut is an UserCode */
+/* VOrigin, VStop, Step are all UserCode */
+#define VOUT_PARA \
+    uint16_t _VoltOut;  \
+    uint16_t _VOrigin;  \
+    uint16_t _VStop;    \
+    uint16_t _Step;     \
+    uint16_t _StepTime;  \
+    uint16_t _CycleNumber
+//    void (*SetVoltOut) (struct VoltOutPara *, uint16_t);  \
+//    uint16_t (*GetVoltOut) (struct VoltOutPara *);  \
+//    void (*SetVOrigin) (struct VoltOutPara *, uint16_t);  \
+//    uint16_t (*GetVOrigin) (struct VoltOutPara *);  \
+//    void (*SetVStop) (struct VoltOutPara *, uint16_t);  \
+//    uint16_t (*GetVStop) (struct VoltOutPara *);  \
+//    void (*SetStep) (struct VoltOutPara *, uint16_t);  \
+//    uint16_t (*GetStep) (struct VoltOutPara *);  \
+//    void (*SetStepTime) (struct VoltOutPara *, uint16_t);  \
+//    uint16_t (*GetStepTime) (struct VoltOutPara *);  \
+//    void (*SetCycleNumber) (struct VoltOutPara *, uint16_t);  \
+//    uint16_t (*GetCycleNumber) (struct VoltOutPara *)
+
+#define LIMIT \
+    uint32_t _LimitValue; \
+    void (*SetLimitValue) (struct Limit *, uint32_t); \
+    uint32_t (*GetLimitValue) (struct Limit*)
+
+struct Measure{
+    MEASURE;
+};
+
+struct VoltOutPara{
+    VOUT_PARA;
+};
+
+struct Limit{
+    LIMIT;
+};
+/***** End of Measure and VoltOut parameter *****/
+
+
+/***** Measure Only Mode *****/
+void _SetMeasureData(struct Measure *self, int32_t Data){
+    self->_MeasureData = Data;
+}
+
+int32_t _GetMeasureData(struct Measure *self){
+    return self->_MeasureData;
+}
+
+
+/**** Limit Mode ****/
+//LimitValue
+void _SetLimitValue(struct Limit *self, uint32_t LimitValue){
+    self->_LimitValue = LimitValue;
+}
+uint32_t _GetLimitValue(struct Limit *self){
+    return self->_LimitValue;
+}
+
+/* IT Mode Data */
+typedef struct _ITMode{
+    MEASURE;
+    LIMIT;
+}ITMode;
+
+ITMode * InitITMode(){
+    ITMode *ret = malloc(sizeof(ITMode));
+    ret->_MeasureData = 0;
+    ret->SetMeasureData = &_SetMeasureData;
+    ret->GetMeasureData = &_GetMeasureData;
+
+    ret->_LimitValue = 0;
+    
+    ret->SetLimitValue = &_SetLimitValue;
+    ret->GetLimitValue = &_GetLimitValue;
+    return ret;
+}
+/* End of IT Mode Data */
+
+/* VT Mode Data */
+typedef struct _VTMode{
+    MEASURE;
+}VTMode;
+
+VTMode * InitVTMode(){
+    VTMode *ret = malloc(sizeof(VTMode));
+    ret->_MeasureData = 0;
+    ret->SetMeasureData = &_SetMeasureData;
+    ret->GetMeasureData = &_GetMeasureData;
+    return ret;
+}
+/* End of VT Mode Data */
+/***** End of Measure Only Mode *****/
+
+
+/**** VoltOut Only Mode ****/
+// VoltOut
+void _SetVoltOut(struct VoltOutPara *self, uint16_t VoltOut){
+    self->_VoltOut = VoltOut;
+}
+uint16_t _GetVoltOut(struct VoltOutPara *self){
+    return self->_VoltOut;
+}
+
+// VOrigin
+void _SetVOrigin(struct VoltOutPara *self, uint16_t VOrigin){
+    self->_VOrigin = VOrigin;
+}
+uint16_t _GetVOrigin(struct VoltOutPara *self){
+    return self->_VOrigin;
+}
+
+// VStop
+void _SetVStop(struct VoltOutPara *self, uint16_t VStop){
+    self->_VStop = VStop;
+}
+uint16_t _GetVStop(struct VoltOutPara *self){
+    return self->_VStop;
+}
+
+// Step
+void _SetStep(struct VoltOutPara *self, uint16_t Step){
+    self->_Step = Step;
+}
+uint16_t _GetStep(struct VoltOutPara *self){
+    return self->_Step;
+}
+
+// StepTime
+void _SetStepTime(struct VoltOutPara *self, uint16_t StepTime){
+    self->_StepTime = StepTime;
+}
+uint16_t _GetStepTime(struct VoltOutPara *self){
+    return self->_StepTime;
+}
+
+// CycleNumber
+void _SetCycleNumber(struct VoltOutPara *self, uint16_t CycleNumber){
+    self->_CycleNumber = CycleNumber;
+}
+uint16_t _GetCycleNumber(struct VoltOutPara *self){
+    return self->_CycleNumber;
+}
+
+
+/* VoltOut Mode Data */
+typedef struct _VoltOutMode{
+    VOUT_PARA;
+}VoltOutMode;
+
+VoltOutMode *InitVoltOutMode(){
+    VoltOutMode *ret = malloc(sizeof(VoltOutMode));
+    ret->_VoltOut = INSTRUCTION.VoltConstant;  // 25000 is DAC_ZERO
+    ret->_VOrigin = DAC_ZERO;
+    ret->_VStop = DAC_ZERO;
+    ret->_Step  =   0;
+    ret->_StepTime = 10000; // STEPTIME_ONE_SEC
+    ret->_CycleNumber = 1;
+
+//    ret->SetVoltOut = &_SetVoltOut;
+//    ret->GetVoltOut = &_GetVoltOut;
+//    ret->SetVOrigin = &_SetVOrigin;
+//    ret->GetVOrigin = &_GetVOrigin;
+//    ret->SetVStop = &_SetVStop;
+//    ret->GetVStop = &_GetVStop;
+//    ret->SetStep = &_SetStep;
+//    ret->GetStep = &_GetStep;
+//    ret->SetStepTime = &_SetStepTime;
+//    ret->GetStepTime = &_GetStepTime;
+//    ret->SetCycleNumber = &_SetCycleNumber;
+//    ret->GetCycleNumber = &_GetCycleNumber;
+    return ret;
+}
+/* End of VoltOut Mode Data */
+/**** End of VoltOut Only Mode ****/
+
+
+/**** Measure + VoltOut Mode ****/
+/* IV Mode Data */
+typedef struct _IVMode{
+    MEASURE;
+    VOUT_PARA;
+    LIMIT;
+}IVMode;
+
+IVMode *InitIVMode(){
+    IVMode *ret = malloc(sizeof(IVMode));
+    ret->_MeasureData = 0;
+    ret->SetMeasureData = &_SetMeasureData;
+    ret->GetMeasureData = &_GetMeasureData;
+
+    ret->_VoltOut = DAC_ZERO;
+    ret->_VOrigin = INSTRUCTION.VoltOrigin;
+    ret->_VStop = INSTRUCTION.VoltFinal;
+    ret->_Step  = INSTRUCTION.Step;
+    ret->_StepTime = INSTRUCTION.StepTime;
+    ret->_CycleNumber = 1;
+
+//    ret->SetVoltOut = &_SetVoltOut;
+//    ret->GetVoltOut = &_GetVoltOut;
+//    ret->SetVOrigin = &_SetVOrigin;
+//    ret->GetVOrigin = &_GetVOrigin;
+//    ret->SetVStop = &_SetVStop;
+//    ret->GetVStop = &_GetVStop;
+//    ret->SetStep = &_SetStep;
+//    ret->GetStep = &_GetStep;
+//    ret->SetStepTime = &_SetStepTime;
+//    ret->GetStepTime = &_GetStepTime;
+//    ret->SetCycleNumber = &_SetCycleNumber;
+//    ret->GetCycleNumber = &_GetCycleNumber;
+
+    ret->_LimitValue = 1e5;
+    
+    ret->SetLimitValue = &_SetLimitValue;
+    ret->GetLimitValue = &_GetLimitValue;
+    return ret;
+}
+/* End of IV Mode Data */
+
+/* RT Mode Data */
+typedef struct _RTMode{
+    MEASURE;
+    VOUT_PARA;
+}RTMode;
+
+RTMode * InitRTMode(){
+    RTMode *ret = malloc(sizeof(RTMode));
+    ret->_MeasureData = 0;
+    ret->SetMeasureData = &_SetMeasureData;
+    ret->GetMeasureData = &_GetMeasureData;
+
+    ret->_VoltOut = DAC_ZERO;  // 25000 is DAC_ZERO
+    ret->_VOrigin = DAC_ZERO;
+    ret->_VStop = DAC_ZERO;
+    ret->_Step  =   0;
+    ret->_StepTime = 10000; // STEPTIME_ONE_SEC
+    ret->_CycleNumber = 1;
+
+//    ret->SetVoltOut = &_SetVoltOut;
+//    ret->GetVoltOut = &_GetVoltOut;
+//    ret->SetVOrigin = &_SetVOrigin;
+//    ret->GetVOrigin = &_GetVOrigin;
+//    ret->SetVStop = &_SetVStop;
+//    ret->GetVStop = &_GetVStop;
+//    ret->SetStep = &_SetStep;
+//    ret->GetStep = &_GetStep;
+//    ret->SetStepTime = &_SetStepTime;
+//    ret->GetStepTime = &_GetStepTime;
+//    ret->SetCycleNumber = &_SetCycleNumber;
+//    ret->GetCycleNumber = &_GetCycleNumber;
+    return ret;
+}
+/* End of RT Mode Data */
+
+/* CV Mode*/
+typedef struct _CVMode{
+    MEASURE;
+    VOUT_PARA;
+}CVMode;
+
+CVMode * InitCVMode(){
+    CVMode *ret = malloc(sizeof(CVMode));
+    ret->_MeasureData = 0;
+    ret->SetMeasureData = &_SetMeasureData;
+    ret->GetMeasureData = &_GetMeasureData;
+
+    ret->_VoltOut = DAC_ZERO;  // 25000 is DAC_ZERO
+    ret->_VOrigin = INSTRUCTION.VoltOrigin;
+    ret->_VStop = INSTRUCTION.VoltFinal;
+    ret->_Step  = INSTRUCTION.Step;
+    ret->_StepTime = INSTRUCTION.StepTime; // STEPTIME_ONE_SEC
+    ret->_CycleNumber = INSTRUCTION.CycleNumber;
+
+//    ret->SetVoltOut = &_SetVoltOut;
+//    ret->GetVoltOut = &_GetVoltOut;
+//    ret->SetVOrigin = &_SetVOrigin;
+//    ret->GetVOrigin = &_GetVOrigin;
+//    ret->SetVStop = &_SetVStop;
+//    ret->GetVStop = &_GetVStop;
+//    ret->SetStep = &_SetStep;
+//    ret->GetStep = &_GetStep;
+//    ret->SetStepTime = &_SetStepTime;
+//    ret->GetStepTime = &_GetStepTime;
+//    ret->SetCycleNumber = &_SetCycleNumber;
+//    ret->GetCycleNumber = &_GetCycleNumber;
+    return ret;
+}
+/*End of CV Mode*/
+
+/* Const Current Mode */
+#define CC_ZERO_POINT     1500000
+#define MAX_DAC_UC    50000
+#define MIN_DAC_UC      0
+#define CURRENT_LV_ONE      1
+#define CURRENT_LV_ZERO     0
+
+/*********************************************************************
+ * @struct  Constant Current Code
+ *
+ * @brief   A struct to handle CC mode command
+ */
+typedef struct _CCMode{
+    // measure value
+    MEASURE;    // current
+    int32_t BatteryV;
+
+    /** Experience Setting **/
+    /** current value **/
+    // current value divide current level into 3,000,001 pieces
+    // 1,500,000 is zero point
+    int32_t value;
+
+    /** ADC level range: 0-2 **/
+    // constant current value will decide ADC gain level
+    // if |1500000 - value| > 10000 (+-100 uA)     => lv = GAIN_200R
+    // else if |1500000 - valule| > 1000 (+-10 uA) => lv = GAIN_10K
+    // else lv = GAIN_200K
+    uint8_t lv;
+
+    /* Vmax and Vmin */
+    // Vmax protect battery charge
+    // Vmin protect battery discharge
+    // uint = mV
+    uint16_t VMax;
+    uint16_t VMin;
+
+    /* Charge/Discharge Current */
+    int32_t ChargeCurrent;
+    int32_t DischargeCurrent;
+    uint8_t CycleNumber;
+
+    bool StandBy;
+    uint32_t StandByTime;
+
+    /** transform a current user code (IUC) to real current in nA **/
+    int32_t (*_Transform2RealnA)(struct _CCMode *);
+}CCMode;
+
+/*********************************************************************
+ * @fn      Transform2RealnA
+ *
+ * @brief   transform an IUC into real current value in nA.
+ *
+ * @param   self, which is an IUC
+ *
+ * @return  an int32_t current value in nA
+ */
+int32_t _Transform2RealnA(CCMode *self){
+    int32_t IUCReal;
+
+    // self->value : 0 ~ 3000000 (which is -1500000 ~ 1500000 (10nA) )
+    IUCReal = (self->value - CC_ZERO_POINT) * 10;
+    return IUCReal;
+}
+
+CCMode * InitCCMode(){
+    CCMode *ret = malloc(sizeof(CCMode));
+    ret->_MeasureData = 0;
+    ret->SetMeasureData = &_SetMeasureData;
+    ret->GetMeasureData = &_GetMeasureData;
+    ret->BatteryV = 0;
+
+    ret->value = CC_ZERO_POINT;
+    ret->lv = INSTRUCTION.ADCGainLevel;
+    ret->VMax = MAX_DAC_UC;  // max DAC UserCode
+    ret->VMin = MIN_DAC_UC;  // min DAC UserCode
+    ret->ChargeCurrent = 0;
+    ret->DischargeCurrent = 0;
+    ret->CycleNumber = 0;
+    ret->StandBy = false;
+    ret->StandByTime = 0;
+    ret->_Transform2RealnA = &_Transform2RealnA;
+    return ret;
+}
+/*End of Const Current Mode Mode*/
+
+/** Potential State Mode **/
+typedef struct _PS{
+    // measure
+    MEASURE; // circuit current
+    int32_t ReferenceVolt;
+
+    VOUT_PARA;
+}PSMode;
+
+PSMode *InitPSMode(){
+    PSMode *ret = malloc(sizeof(PSMode));
+    ret->_MeasureData = 0;
+    ret->SetMeasureData = &_SetMeasureData;
+    ret->GetMeasureData = &_GetMeasureData;
+    ret->ReferenceVolt = 0;
+
+    ret->_VoltOut = DAC_ZERO;  // 25000 is DAC_ZERO
+    ret->_VOrigin = INSTRUCTION.VoltOrigin;
+    ret->_VStop = INSTRUCTION.VoltFinal;
+    ret->_Step  = INSTRUCTION.Step;
+    ret->_StepTime = INSTRUCTION.StepTime; // STEPTIME_ONE_SEC
+    ret->_CycleNumber = INSTRUCTION.CycleNumber;
+    return ret;
+}
+
+/** End of Potential State Mode **/
+
+typedef union _WorkMode{
+    // Measure only
+    ITMode *IT;
+    VTMode *VT;
+
+    // Output Only
+    VoltOutMode *VO;
+
+    // Measure + Output
+    IVMode *IV;
+    CVMode *CV;
+    RTMode *RT;
+    CCMode *CC;
+    PSMode *PS;
+}WorkMode;
+
+WorkMode *CreateWorkMode(){
+    WorkMode *ret = malloc(sizeof(WorkMode));
+    return ret;
+}
+
+void InitWorkMode(WorkMode *WM){
+    switch(INSTRUCTION.eliteFxn){
+        case IV_CURVE:
+            WM->IV = InitIVMode();
+            break;
+        case CV_CURVE:
+            WM->CV = InitCVMode();
+            break;
+        case VOLT_OUTPUT:
+            WM->VO = InitVoltOutMode();
+            break;
+        case ZT_CURVE:
+            WM->RT = InitRTMode();
+            break;
+        case VT_CURVE:
+            WM->VT = InitVTMode();
+            break;
+        case IT_CURVE:
+            WM->IT = InitITMode();
+            break;
+        case CONSTANT_CURRENT:
+            WM->CC = InitCCMode();
+            break;
+
+        default:
+            WM->VT = InitVTMode();
+            break;
+    }
+}
+
+void FreeWorkMode(WorkMode *WM){
+    switch(INSTRUCTION.eliteFxn){
+        case IV_CURVE:
+            if(WM->IV != NULL){
+                free(WM->IV);
+                WM->IV = NULL;
+            }
+            break;
+        case CV_CURVE:
+            if(WM->CV != NULL){
+                free(WM->CV);
+                WM->CV = NULL;
+            }
+            break;
+        case VOLT_OUTPUT:
+            if(WM->VO != NULL){
+                free(WM->VO);
+                WM->VO = NULL;
+            }
+            break;
+        case ZT_CURVE:
+            if(WM->RT != NULL){
+                free(WM->RT);
+                WM->RT = NULL;
+            }
+            break;
+        case VT_CURVE:
+            if(WM->VT != NULL){
+                free(WM->VT);
+                WM->VT = NULL;
+            }
+            break;
+        case IT_CURVE:
+            if(WM->IT != NULL){
+                free(WM->IT);
+                WM->IT = NULL;
+            }
+            break;
+        case CONSTANT_CURRENT:
+            if(WM->CC != NULL){
+                free(WM->CC);
+                WM->CC = NULL;
+            }
+            break;
+        default:
+            if(WM->IV != NULL){
+                free(WM->IV);
+                WM->IV = NULL;
+            }
+            break;
+    }
+//    free(WM);
+}
+
+#endif

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

@@ -9,7 +9,7 @@ static void ZT_notify(int32_t impedance);
 // => calculate the resister
 // change the output voltage step
 // => get a R-T curve (with resolution = 1 sample/volt step )
-static void ZT_Plot() {
+static void ZT_Plot(RTMode *RT) {
 //    int32_t Real_Resister = 0;
     static uint16_t CurrentMeasure=0, VoltMeasure=0;
     uint8_t SPICurrent[SPI_ADC_SIZE]={0}, SPIVolt[SPI_ADC_SIZE]={0};

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

@@ -431,6 +431,7 @@ static Clock_Struct periodicClock;
 #include "simple_gatt_profile.h"
 
 static bool            PeriodicEvent = false;
+static bool InitPeriodicEvent = true;
 static ICall_Semaphore semaphore;
 static uint16_t        events;
 
@@ -601,33 +602,20 @@ static void set_update_instruction_callback(update_instruction_callback_type cal
 static uint16_t DAC_outputV(uint16_t voltLV);
 static int32_t DAC_to_realV(uint16_t DACcode);
 
-/* DAC reset parameter */
-#define DAC_ZERO 0x85B2
-#define DAC_POS_MAX 0x0000
-#define DAC_NEG_MAX 0xFFFF
 static uint16_t DACUserCode = 0x0000;
 
 static uint32_t SampleRateTable[6] = {100, 1000, 10000, 50000, 100000, 1000000};  // 1 =>100 Hz, 10000=>0.01 Hz
-static uint32_t SampleRate_counter = 1;
 
 // record value for IV curve to calculate average current
 static uint8_t DiscardIVFirstData = 1;
 static uint16_t   avg_number          = 0;
 static long long ADCRealCurrent_long = 0;
 
-// Step time macro
-#define STEPTIME_HALF_SEC 5000
-#define STEPTIME_ONE_SEC 10000
-#define STEPTIME_TWO_SEC 20000
-
 // Constant Current Mode function
 static uint8_t CCModeDACEnable = 0;
 static int32_t CCModeReadCurrent();
 static int32_t CCModeVoltOut();
-static void SetCCModeGain();
 static void CCCurrent2IUC();
-static int32_t IUC2RealnA();
-static int32_t IUC2RealpA();
 
 // for DPVCurve SWVCurve
 static uint16_t Amplitude;
@@ -636,16 +624,25 @@ static uint16_t PulseWidth_16;
 static uint8_t  PulsePeriod;
 static uint16_t PulsePeriod_16;
 
-static uint16_t StepTimeCounter = 1;
+struct _CT{
+    uint32_t SampleRate_counter;
+    uint16_t StepTimeCounter;
+    uint16_t NotifyCounter;
+    uint32_t StandByCounter;
+}CT = {0};
 
+static void InitFlag();
+static void InitCT();
+
+#include "EliteWorkData.h"
 // real instruction fxn
-static uint16_t VoltScan();                   // used in I-V and cyclic
+static uint16_t VoltScan(WorkMode *WorkModeData);       // used in I-V and cyclic
 static void     DACCode2Real2Notify(uint16_t DACcode);  // send notify voltage after VoltScan()
 
 //static void    VOLT_OUTPUT();
-static void    ZT_Plot();
-static void    VT_Plot();
-static int32_t IT_Plot();
+static void    ZT_Plot(RTMode *RT);
+static void    VT_Plot(VTMode *VT);
+static int32_t IT_PlotIT_Plot(WorkMode *WorkModeData);
 
 // the following fxn do the same thing
 // IVCurve_T is called if Vorigin > Vfinal, vice versa
@@ -655,11 +652,11 @@ static uint8_t  OldStep2NewStep(uint8_t OldStep);
 static uint16_t OldStep2NewStepTime(uint8_t StepTime);
 static uint8_t  IVdone = 0;
 
-static uint16_t OneWayVoltScan();
+static uint16_t OneWayVoltScan(IVMode *IV);
 static void     ramp_test();
-static uint16_t DPVCurve();
-static uint16_t CVCurve();
-static uint16_t SWVCurve();
+static uint16_t DPVCurve(WorkMode *WorkModeData);
+static uint16_t CVCurve(CVMode *CV);
+static uint16_t SWVCurve(WorkMode *WorkModeData);
 
 static void reset();
 static void Eliteinterrupt();
@@ -670,6 +667,7 @@ static void SendNotify();
 static bool If10Von = false;
 static void TurnOn10V();
 
+
 #include "EliteInstruction.h"
 #include "EliteADC.h"
 #include "EliteDAC.h"
@@ -682,6 +680,7 @@ static void TurnOn10V();
 
 #include "EliteDeviceCorrection.h"
 #include "EliteNotify.h"
+#include "EliteFlagCTInit.h"
 #include "EliteReset.h"
 #include "EliteLED.h"
 #include "EliteKeyDetect.h"
@@ -737,7 +736,7 @@ static void update_ZM_instruction(uint8 *ins) {
         }
 
         case DIFFERENTIAL_PULSE_VOLTAMMETRY: {
-            CleanBuffer();
+//            CleanBuffer();
             INSTRUCTION.eliteFxn = DIFFERENTIAL_PULSE_VOLTAMMETRY;
             DACReset             = true;
 
@@ -772,7 +771,7 @@ static void update_ZM_instruction(uint8 *ins) {
         }
 
         case SQUARE_WAVE_VOLTAMMETRY: {
-            CleanBuffer();
+//            CleanBuffer();
             INSTRUCTION.eliteFxn = SQUARE_WAVE_VOLTAMMETRY;
             DACReset             = true;
 
@@ -832,12 +831,9 @@ static void update_ZM_instruction(uint8 *ins) {
             break;
         }
 
-
         case VOLT_OUTPUT: {
             INSTRUCTION.eliteFxn = VOLT_OUTPUT;
             INSTRUCTION.VoltConstant = ( ((uint16_t)(ins[3])) << 8) | (uint16_t)(ins[4]);
-            DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoltConstant));
-//            DAC_outputV(INSTRUCTION.VoltConstant);
             break;
         }
 
@@ -866,7 +862,7 @@ static void update_ZM_instruction(uint8 *ins) {
         case SET_SAMPLE_RATE: {
             INSTRUCTION.SampleRateIndex = ins[3];
             INSTRUCTION.SampleRate = SampleRateTable[INSTRUCTION.SampleRateIndex];
-            SampleRate_counter = 1;
+            CT.SampleRate_counter = 1;
             break;
         }
         case POTENTIAL_STATE: {
@@ -883,8 +879,9 @@ static void update_ZM_instruction(uint8 *ins) {
 
         case CONSTANT_CURRENT:{
             INSTRUCTION.eliteFxn = CONSTANT_CURRENT;
-            INSTRUCTION.SampleRate = 2;
+            INSTRUCTION.SampleRate = 6;
             INSTRUCTION.ConstantCurrent = ( (uint32_t) (ins[3])<<24 | (uint32_t) (ins[4])<<16 | (uint32_t) (ins[5])<<8 | (uint32_t) (ins[6]) );
+            INSTRUCTION.NotifyRate = 1000;
 //            GetInstructionParameter(ins+2);
 //            CCCurrent2IUC();
             break;

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

@@ -19,8 +19,9 @@
 // header
 #include <ti/drivers/PIN.h>
 #include "board.h"
+#include "EliteWorkData.h"
 
-static void SimpleBLEPeripheral_performPeriodicTask(void *WorkModeData);
+static void SimpleBLEPeripheral_performPeriodicTask(WorkMode *WorkModeData);
 
 static void SimpleBLEPeripheral_clockHandler(UArg arg) {
     // Store the event.
@@ -89,45 +90,70 @@ static void DACCode2Real2Notify(uint16_t DACcode) {
  *
  * @return  None.
  */
-static void SimpleBLEPeripheral_performPeriodicTask(void *WorkModeData) {
+static void SimpleBLEPeripheral_performPeriodicTask(WorkMode *WorkModeData) {
     if ( IsPeriodicMode() ){
 
-        if (StepTimeCounter == INSTRUCTION.StepTime){
-            StepTimeCounter = 1;
+        // DAC counter
+        if (CT.StepTimeCounter == INSTRUCTION.StepTime){
+            CT.StepTimeCounter = 1;
         }
         else{
-            StepTimeCounter++;
+            CT.StepTimeCounter++;
         }
 
-        if (SampleRate_counter == INSTRUCTION.SampleRate){
-            SampleRate_counter = 1;
+        // ADC counter
+        if (CT.SampleRate_counter == INSTRUCTION.SampleRate){
+            CT.SampleRate_counter = 1;
         }
         else{
-            SampleRate_counter++;
+            CT.SampleRate_counter++;
+        }
+
+        // notify counter
+        if (CT.NotifyCounter == INSTRUCTION.NotifyRate){
+            CT.NotifyCounter = 1;
+        }
+        else{
+            CT.NotifyCounter ++;
         }
 
         /** Periodic Event **/
-        // Default working mode is DAC out -> ADC read -> send notify
+        // Default working flow is DAC out -> ADC read -> send notify
         // We will need a flag to control DAC, if we want to exchange to ADC -> DAC -> notify
-        // This flag can be named by FxnNameReset
+        // This flag can be named by FxnNameDACReset
 
         // In IV, CV, and func-gen mode, DAC will output voltage
         // else DAC do nothing.
-        EliteDACControl(*WorkModeData);
+        EliteDACControl(WorkModeData);
 
         // Control ADC to sample rate
-        EliteADCControl(*WorkModeData);
+        EliteADCControl(WorkModeData);
 
         // Notify control, check if we need to send notify
         EliteNotifyControl();
     }
+
+    else if(INSTRUCTION.eliteFxn == VOLT_OUTPUT){
+        // assign WorkModeData->VO  = INSTRUCTION.VoltConstant
+        WorkModeData->VO->_VoltOut = INSTRUCTION.VoltConstant;
+
+        // UserCode -> DAC code -> DAC out
+        DAC_outputV(Usercode_Correction_to_DAC(WorkModeData->VO->_VoltOut));
+        FreeWorkMode(WorkModeData);
+        PeriodicEvent = false;
+        InitPeriodicEvent = true;
+    }
+    else{
+        PeriodicEvent = false;
+    }
 }
 
-static void EliteDACControl(void *WorkModeData) {
+static void EliteDACControl(WorkMode *WorkModeData) {
     if ((INSTRUCTION.eliteFxn == IV_CURVE) || (INSTRUCTION.eliteFxn == CV_CURVE)) {
         // output a certain voltage and put it into NotifyVolt
-        DACCode2Real2Notify(VoltScan());
+        DACCode2Real2Notify(VoltScan(WorkModeData));
     }
+
     else if (INSTRUCTION.eliteFxn == ZT_CURVE){
         if(INSTRUCTION.ResisterMeter == RESISTER_METER_SMALL){
             // output 1V
@@ -151,7 +177,7 @@ static void EliteDACControl(void *WorkModeData) {
             DAC_outputV(Usercode_Correction_to_DAC(25000));
             DACReset = false;
         }
-        CCModeVoltOut(WorkModeData);
+        CCModeVoltOut(WorkModeData->CC);
     }
 
     else{
@@ -160,35 +186,37 @@ static void EliteDACControl(void *WorkModeData) {
     }
 }
 
-static void EliteADCControl(uint32_t **WorkModeData) {
-    if (SampleRate_counter == INSTRUCTION.SampleRate-1) {
+static void EliteADCControl(WorkMode *WorkModeData) {
+    if (CT.SampleRate_counter == INSTRUCTION.SampleRate - 1) {
         switch (INSTRUCTION.eliteFxn) {
             case IV_CURVE:{
-                IT_Plot();
+                IT_Plot(WorkModeData);
                 break;
             }
             case CV_CURVE:{
-                IT_Plot();
+                IT_Plot(WorkModeData);
                 break;
             }
             case IT_CURVE:{
-                IT_Plot();
+                IT_Plot(WorkModeData);
                 break;
             }
             case VT_CURVE:{
                 // read volt through ADC and put it into notify buffer
-                VT_Plot();
+                VT_Plot(WorkModeData->VT);
                 break;
             }
             case ZT_CURVE:{
-                ZT_Plot();
+                ZT_Plot(WorkModeData->RT);
                 break;
             }
             case CONSTANT_CURRENT:{
-                CCModeReadCurrent(WorkModeData);
+                CCModeReadCurrent(WorkModeData->CC);
+                CCModeReverseCurrent(WorkModeData->CC);
                 break;
             }
             default:{
+                IT_Plot(WorkModeData);
                 break;
             }
         }
@@ -201,12 +229,16 @@ static void EliteNotifyControl() {
         if (!PeriodicEvent) {
             SendNotify();
             reset();
-        } else if (StepTimeCounter == INSTRUCTION.StepTime - 1) {
+        } else if (CT.StepTimeCounter == INSTRUCTION.StepTime - 1) {
             SendNotify();
         }
     }
-
-    else if (SampleRate_counter == INSTRUCTION.SampleRate) {
+    else if(INSTRUCTION.eliteFxn == CONSTANT_CURRENT){
+        if(CT.NotifyCounter == INSTRUCTION.NotifyRate){
+            SendNotify();
+        }
+    }
+    else if (CT.SampleRate_counter == INSTRUCTION.SampleRate) {
         SendNotify();
     }
 }

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

@@ -529,7 +529,7 @@ static void SimpleBLEPeripheral_init(void) {
 }
 
 
-
+#include "EliteWorkData.h"
 /*********************************************************************
  * @fn      SimpleBLEPeripheral_taskFxn
  *
@@ -551,9 +551,7 @@ static void SimpleBLEPeripheral_taskFxn(UArg a0, UArg a1) {
 
     ZM_init();
     Elite_SPI_init();
-    void *WorkModeData = malloc(sizeof(uint32_t));
-    CURRENT_USER_CODE *CurrentUserCode = InitCurrentUserCode();
-    WorkModeData = &CurrentUserCode;
+    WorkMode *WorkModeData = CreateWorkMode();
 
     uint8_t key         = 0;
     uint16_t counter6994 = 0;
@@ -629,14 +627,26 @@ static void SimpleBLEPeripheral_taskFxn(UArg a0, UArg a1) {
                         counter6994++;
                     }
                     EliteKeyPress(key);
+                    if(Free_Work_Mode){
+                        FreeWorkMode(WorkModeData);
+                        InitEliteInstruction();
+                        ADCGainControl(INSTRUCTION.ADCGainLevel);
+                        DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoltConstant));
+                        Free_Work_Mode = false;
+                    }
                 } else {
                     EliteOn = TurnOnElite(key);
                 }
             }
             // if there is periodic event
             else {
+                if(InitPeriodicEvent){
+                    InitWorkMode(WorkModeData);
+                    InitPeriodicEvent = false;
+                }
+
                 // Perform periodic application task
-                SimpleBLEPeripheral_performPeriodicTask(WorkModeData );
+                SimpleBLEPeripheral_performPeriodicTask(WorkModeData);
 
                 key = PIN_getInputValue(switch_on);
                 EliteKeyPress(key);  // onPress=> key = 0; 1.lighten LED 2.long press shut down 2650