update cali script

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

simplelink/ble_sdk_2_02_02_25/examples/cc2650em/simple_central/ccs/app/targetConfigs/CC2640F128.ccxml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<configurations XML_version="1.2" id="configurations_0">
+    <configuration XML_version="1.2" id="configuration_0">
+        <instance XML_version="1.2" desc="Texas Instruments XDS100v3 USB Debug Probe" href="connections/TIXDS100v3_Dot7_Connection.xml" id="Texas Instruments XDS100v3 USB Debug Probe" xml="TIXDS100v3_Dot7_Connection.xml" xmlpath="connections"/>
+        <connection XML_version="1.2" id="Texas Instruments XDS100v3 USB Debug Probe">
+            <instance XML_version="1.2" href="drivers/tixds100v2icepick_c.xml" id="drivers" xml="tixds100v2icepick_c.xml" xmlpath="drivers"/>
+            <instance XML_version="1.2" href="drivers/tixds100v2cs_dap.xml" id="drivers" xml="tixds100v2cs_dap.xml" xmlpath="drivers"/>
+            <instance XML_version="1.2" href="drivers/tixds100v2cortexM.xml" id="drivers" xml="tixds100v2cortexM.xml" xmlpath="drivers"/>
+            <property Type="choicelist" Value="2" id="The Converter Usage">
+                <choice Name="Generate 1149.7 2-pin advanced modes" value="enable">
+                    <property Type="choicelist" Value="1" id="The Converter 1149.7 Frequency">
+                        <choice Name="Overclock with user specified value" value="unused">
+                            <property Type="choicelist" Value="5" id="-- Choose a value from 1.0MHz to 50.0MHz"/>
+                        </choice>
+                    </property>
+                    <property Type="choicelist" Value="5" id="The Target Scan Format"/>
+                </choice>
+            </property>
+            <platform XML_version="1.2" id="platform_0">
+                <instance XML_version="1.2" desc="CC2640F128" href="devices/cc2640f128.xml" id="CC2640F128" xml="cc2640f128.xml" xmlpath="devices"/>
+            </platform>
+        </connection>
+    </configuration>
+</configurations>

simplelink/ble_sdk_2_02_02_25/examples/cc2650em/simple_central/ccs/app/targetConfigs/readme.txt

@@ -0,0 +1,9 @@
+The 'targetConfigs' folder contains target-configuration (.ccxml) files, automatically generated based
+on the device and connection settings specified in your project on the Properties > General page.
+
+Please note that in automatic target-configuration management, changes to the project's device and/or
+connection settings will either modify an existing or generate a new target-configuration file. Thus,
+if you manually edit these auto-generated files, you may need to re-apply your changes. Alternatively,
+you may create your own target-configuration file for this project and manage it manually. You can
+always switch back to automatic target-configuration management by checking the "Manage the project's
+target-configuration automatically" checkbox on the project's Properties > General page.

simplelink/ble_sdk_2_02_02_25/examples/cc2650em/simple_central/ccs/stack/targetConfigs/CC2640F128.ccxml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<configurations XML_version="1.2" id="configurations_0">
+    <configuration XML_version="1.2" id="configuration_0">
+        <instance XML_version="1.2" desc="Texas Instruments XDS100v3 USB Debug Probe" href="connections/TIXDS100v3_Dot7_Connection.xml" id="Texas Instruments XDS100v3 USB Debug Probe" xml="TIXDS100v3_Dot7_Connection.xml" xmlpath="connections"/>
+        <connection XML_version="1.2" id="Texas Instruments XDS100v3 USB Debug Probe">
+            <instance XML_version="1.2" href="drivers/tixds100v2icepick_c.xml" id="drivers" xml="tixds100v2icepick_c.xml" xmlpath="drivers"/>
+            <instance XML_version="1.2" href="drivers/tixds100v2cs_dap.xml" id="drivers" xml="tixds100v2cs_dap.xml" xmlpath="drivers"/>
+            <instance XML_version="1.2" href="drivers/tixds100v2cortexM.xml" id="drivers" xml="tixds100v2cortexM.xml" xmlpath="drivers"/>
+            <property Type="choicelist" Value="2" id="The Converter Usage">
+                <choice Name="Generate 1149.7 2-pin advanced modes" value="enable">
+                    <property Type="choicelist" Value="1" id="The Converter 1149.7 Frequency">
+                        <choice Name="Overclock with user specified value" value="unused">
+                            <property Type="choicelist" Value="5" id="-- Choose a value from 1.0MHz to 50.0MHz"/>
+                        </choice>
+                    </property>
+                    <property Type="choicelist" Value="5" id="The Target Scan Format"/>
+                </choice>
+            </property>
+            <platform XML_version="1.2" id="platform_0">
+                <instance XML_version="1.2" desc="CC2640F128" href="devices/cc2640f128.xml" id="CC2640F128" xml="cc2640f128.xml" xmlpath="devices"/>
+            </platform>
+        </connection>
+    </configuration>
+</configurations>

simplelink/ble_sdk_2_02_02_25/examples/cc2650em/simple_central/ccs/stack/targetConfigs/readme.txt

@@ -0,0 +1,9 @@
+The 'targetConfigs' folder contains target-configuration (.ccxml) files, automatically generated based
+on the device and connection settings specified in your project on the Properties > General page.
+
+Please note that in automatic target-configuration management, changes to the project's device and/or
+connection settings will either modify an existing or generate a new target-configuration file. Thus,
+if you manually edit these auto-generated files, you may need to re-apply your changes. Alternatively,
+you may create your own target-configuration file for this project and manage it manually. You can
+always switch back to automatic target-configuration management by checking the "Manage the project's
+target-configuration automatically" checkbox on the project's Properties > General page.

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

@@ -160,6 +160,17 @@ static void ReadCurrent(uint8_t *buf){
     ADC_read(buf);
 }
 
+static void ReadBatVolt(uint8_t *buf){
+    // Read data twice since the first data we get is previous data
+    ADCChannelSelect(ADC_CH_BAT);
+    CPUdelay(10);
+    ADC_read(buf);
+
+    ADCChannelSelect(ADC_CH_BAT);
+    CPUdelay(10);
+    ADC_read(buf);
+}
+
 // theoretical boundary <20, 10~500, >100 (uA)
 #define GAIN_SMALL_BOUNDARY 40000  // 40 uA = 40,000,000 pA
 #define GAIN_MID_BOUNDARY1  20000  // 20 uA = 20,000,000 pA
@@ -180,14 +191,46 @@ static int32_t AutoGainReadCurrent(uint8_t *buf){
     }
 
     if(INSTRUCTION.ADCGainLevel == GAIN_200R){
-        ReadCurrent(spi_ADC_rxbuf);
-        Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+        uint8_t CurrentCount1 = 0;
+        while(CurrentCount1 < 5){
+            ReadCurrent(spi_ADC_rxbuf);
+            CurrentCount1++;
+            if(CurrentCount1 == 5){
+                ReadCurrent(spi_ADC_rxbuf);
+                Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+                break;
+            }
+        }
 
         // switch to mid range current
         if(Real_Current < GAIN_LARGE_BOUNDARY && Real_Current > -1*GAIN_LARGE_BOUNDARY){
-            INSTRUCTION.ADCGainLevel = GAIN_10K;
-            ReadCurrent(spi_ADC_rxbuf);
-            Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+            uint8_t CurrentCount = 0;
+            // switch to small range current
+            if (Real_Current < GAIN_MID_BOUNDARY1 && Real_Current > -1*GAIN_MID_BOUNDARY1){
+                INSTRUCTION.ADCGainLevel = GAIN_200K;
+                while(CurrentCount < 5){
+                    ReadCurrent(spi_ADC_rxbuf);
+                    CurrentCount++;
+                    if(CurrentCount == 5){
+                        ReadCurrent(spi_ADC_rxbuf);
+                        Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+                        break;
+                    }
+                }
+            }else{
+                CurrentCount = 0;
+                INSTRUCTION.ADCGainLevel = GAIN_10K;
+                while(CurrentCount < 5){
+                    ReadCurrent(spi_ADC_rxbuf);
+                    CurrentCount++;
+                    if(CurrentCount == 5){
+                        ReadCurrent(spi_ADC_rxbuf);
+                        Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+                        break;
+                    }
+                }
+            }
+
 //            LED_color(DARKLED, 0x00, 0xFF, 0x00);
 
 //            // switch to small range current
@@ -200,32 +243,90 @@ static int32_t AutoGainReadCurrent(uint8_t *buf){
         }
     }
     else if(INSTRUCTION.ADCGainLevel == GAIN_10K){
-        ReadCurrent(spi_ADC_rxbuf);
-        Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+        uint8_t CurrentCount1 = 0;
+        while(CurrentCount1 < 3){
+            ReadCurrent(spi_ADC_rxbuf);
+            CurrentCount1++;
+            if(CurrentCount1 == 3){
+                ReadCurrent(spi_ADC_rxbuf);
+                Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+                break;
+            }
+        }
 
         // switch to large range current
         if(Real_Current > GAIN_MID_BOUNDARY2 || Real_Current < -1*GAIN_MID_BOUNDARY2){
+            uint8_t CurrentCount = 0;
             INSTRUCTION.ADCGainLevel = GAIN_200R;
-            ReadCurrent(spi_ADC_rxbuf);
-            Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+            while(CurrentCount < 3){
+                ReadCurrent(spi_ADC_rxbuf);
+                CurrentCount++;
+                if(CurrentCount == 3){
+                    ReadCurrent(spi_ADC_rxbuf);
+                    Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+                    break;
+                }
+            }
         }
 
         // switch to small range current
         else if (Real_Current < GAIN_MID_BOUNDARY1 && Real_Current > -1*GAIN_MID_BOUNDARY1){
+            uint8_t CurrentCount = 0;
             INSTRUCTION.ADCGainLevel = GAIN_200K;
-            ReadCurrent(spi_ADC_rxbuf);
-            Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+            while(CurrentCount < 3){
+                ReadCurrent(spi_ADC_rxbuf);
+                CurrentCount++;
+                if(CurrentCount == 3){
+                    ReadCurrent(spi_ADC_rxbuf);
+                    Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+                    break;
+                }
+            }
         }
     }
     else if(INSTRUCTION.ADCGainLevel == GAIN_200K){
-        ReadCurrent(spi_ADC_rxbuf);
-        Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+        uint8_t CurrentCount1 = 0;
+        while(CurrentCount1 < 5){
+            ReadCurrent(spi_ADC_rxbuf);
+            CurrentCount1++;
+            if(CurrentCount1 == 5){
+                ReadCurrent(spi_ADC_rxbuf);
+                Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+                break;
+            }
+        }
+        //Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
 
         // switch to mid range current
         if(Real_Current > GAIN_SMALL_BOUNDARY || Real_Current < -1*GAIN_SMALL_BOUNDARY){
-            INSTRUCTION.ADCGainLevel = GAIN_10K;
-            ReadCurrent(spi_ADC_rxbuf);
-            Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+            uint8_t CurrentCount = 0;
+            // switch to large range current
+            if(Real_Current > GAIN_MID_BOUNDARY2 || Real_Current < -1*GAIN_MID_BOUNDARY2){
+                INSTRUCTION.ADCGainLevel = GAIN_200R;
+                while(CurrentCount < 5){
+                    ReadCurrent(spi_ADC_rxbuf);
+                    CurrentCount++;
+                    if(CurrentCount == 5){
+                        ReadCurrent(spi_ADC_rxbuf);
+                        Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+                        break;
+                    }
+                }
+            }else{
+                CurrentCount = 0;
+                INSTRUCTION.ADCGainLevel = GAIN_10K;
+                while(CurrentCount < 5){
+                    ReadCurrent(spi_ADC_rxbuf);
+                    CurrentCount++;
+                    if(CurrentCount == 5){
+                        ReadCurrent(spi_ADC_rxbuf);
+                        Real_Current = DecodeADCValue(INSTRUCTION.ADCGainLevel, ADC_CH_CURRENT, spi_ADC_rxbuf);
+                        break;
+                    }
+                }
+            }
+
+
            // switch to large range current
 //           if(Real_Current > GAIN_MID_BOUNDARY2 || Real_Current < -1*GAIN_MID_BOUNDARY2){
 //               INSTRUCTION.ADCGainLevel = GAIN_200R;

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

@@ -136,10 +136,10 @@ 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
-
+    static bool firstADCData;           //firstADCdata=true,when min<x<max,cyclenumber--
     // reset origin volt at the begin
     if (DACReset) {
-        DACUserCode = CV->_VOrigin;
+        INSTRUCTION.VoltConstant = CV->_VOrigin;
         if (CV->_VStop > CV->_VOrigin) {
             direction_up         = true;
             current_direction_up = true;
@@ -148,64 +148,157 @@ static uint16_t CVCurve(CVMode *CV) {
             current_direction_up = false;
         }
 
-        DACOutCode = Usercode_Correction_to_DAC(DACUserCode);
+        DACOutCode = Usercode_Correction_to_DAC(INSTRUCTION.VoltConstant);
         DAC_outputV(DACOutCode);    // output VOLT_ORIGIN
         DACReset   = false;
-
+        firstADCData = true;
         return DACOutCode;
     }
 
     if (CT.StepTimeCounter == CV->_StepTime) {
-
         // Decide next direction
         if (CV->_VoVi_Switch == 0x00){   //user see Vout
             if (direction_up) {
-                if (DACUserCode >= CV->_VStop) {
+                if (INSTRUCTION.VoltConstant >= CV->_VStop) {
                     current_direction_up = false;  // problem occurs when origin == 0000 final == ffff!!!!!!
-                } else if (DACUserCode <= CV->_VOrigin) {
+                    firstADCData = false;
+                }
+                else if (INSTRUCTION.VoltConstant <= CV->_VOrigin) {
                     current_direction_up = true;
+                    firstADCData = false;
                     if (CV->_CycleNumber == 0) {
                         PeriodicEvent = false;  // periodic event end
                         DACReset      = true;
                     }
                     CV->_CycleNumber--;
                 }
+
+
+                else if(current_direction_up){
+                    if(INSTRUCTION.VoltConstant + CV->_Step > CV->_VStop){
+                        current_direction_up = false;
+                    }
+                }
+                else if(!current_direction_up){
+                    if(INSTRUCTION.VoltConstant - CV->_Step < CV->_VOrigin){
+                        current_direction_up = true;
+                        if (CV->_CycleNumber == 0) {
+                            PeriodicEvent = false;  // periodic event end
+                            DACReset      = true;
+                        }
+                        CV->_CycleNumber--;
+                    }
+                }
+                if (firstADCData){
+                    CV->_CycleNumber--;
+                    firstADCData = false;
+                }
+
             } else {
-                if (DACUserCode <= CV->_VStop) {
+                if (INSTRUCTION.VoltConstant < CV->_VStop) {
                     current_direction_up = true;  // problem occurs when origin == 0000 final == ffff!!!!!!
-                } else if (DACUserCode >= CV->_VOrigin) {
+                    firstADCData = false;
+                }
+                else if (INSTRUCTION.VoltConstant > CV->_VOrigin) {
                     current_direction_up = false;
+                    firstADCData = false;
                     if (CV->_CycleNumber == 0) {
                         PeriodicEvent = false;  // periodic event end
                         DACReset      = true;
                     }
                     CV->_CycleNumber--;
                 }
+                else if(current_direction_up){
+                    if(INSTRUCTION.VoltConstant + CV->_Step > CV->_VOrigin){
+                        current_direction_up = false;
+                        if (CV->_CycleNumber == 0) {
+                            PeriodicEvent = false;  // periodic event end
+                            DACReset      = true;
+                        }
+                        CV->_CycleNumber--;
+                    }
+                }
+                else if(!current_direction_up){
+                    if(INSTRUCTION.VoltConstant - CV->_Step < CV->_VStop){
+                        current_direction_up = true;
+                    }
+                }
+                if (firstADCData){//first data =2899mv,CV->_CycleNumber--;
+                    CV->_CycleNumber--;
+                    firstADCData = false;
+                }
             }
         }
         else if (CV->_VoVi_Switch == 0x01){     //user see Vin
             if (direction_up) {
-                if (CV->MeasureVolt >= ((int32_t)(CV->_VStop) - DAC_ZERO)/5) {
+                if (INSTRUCTION.VoltConstant >= CV->_VStop) {
                     current_direction_up = false;  // problem occurs when origin == 0000 final == ffff!!!!!!
-                } else if (CV->MeasureVolt <= ((int32_t)(CV->_VOrigin) - DAC_ZERO)/5) {
+                    firstADCData = false;
+                }
+                else if (INSTRUCTION.VoltConstant <= CV->_VOrigin) {
                     current_direction_up = true;
+                    firstADCData = false;
                     if (CV->_CycleNumber == 0) {
                         PeriodicEvent = false;  // periodic event end
                         DACReset      = true;
                     }
                     CV->_CycleNumber--;
                 }
+
+
+                else if(current_direction_up){
+                    if(INSTRUCTION.VoltConstant + CV->_Step > CV->_VStop){
+                        current_direction_up = false;
+                    }
+                }
+                else if(!current_direction_up){
+                    if(INSTRUCTION.VoltConstant - CV->_Step < CV->_VOrigin){
+                        current_direction_up = true;
+                        if (CV->_CycleNumber == 0) {
+                            PeriodicEvent = false;  // periodic event end
+                            DACReset      = true;
+                        }
+                        CV->_CycleNumber--;
+                    }
+                }
+                if (firstADCData){
+                    CV->_CycleNumber--;
+                    firstADCData = false;
+                }
+
             } else {
-                if (CV->MeasureVolt <= ((int32_t)(CV->_VStop) - DAC_ZERO)/5) {
+                if (INSTRUCTION.VoltConstant < CV->_VStop) {
                     current_direction_up = true;  // problem occurs when origin == 0000 final == ffff!!!!!!
-                } else if (CV->MeasureVolt >= ((int32_t)(CV->_VOrigin) - DAC_ZERO)/5){
+                    firstADCData = false;
+                }
+                else if (INSTRUCTION.VoltConstant > CV->_VOrigin){
                     current_direction_up = false;
+                    firstADCData = false;
                     if (CV->_CycleNumber == 0) {
                         PeriodicEvent = false;  // periodic event end
                         DACReset      = true;
                     }
                     CV->_CycleNumber--;
                 }
+                else if(current_direction_up){
+                    if(INSTRUCTION.VoltConstant + CV->_Step > CV->_VOrigin){
+                        current_direction_up = false;
+                        if (CV->_CycleNumber == 0) {
+                            PeriodicEvent = false;  // periodic event end
+                            DACReset      = true;
+                        }
+                        CV->_CycleNumber--;
+                    }
+                }
+                else if(!current_direction_up){
+                    if(INSTRUCTION.VoltConstant - CV->_Step < CV->_VStop){
+                        current_direction_up = true;
+                    }
+                }
+                if (firstADCData){//first data =2899mv,CV->_CycleNumber--;
+                    CV->_CycleNumber--;
+                    firstADCData = false;
+                }
             }
         }
 //        if (current_direction_up == true){
@@ -220,53 +313,80 @@ static uint16_t CVCurve(CVMode *CV) {
             if (direction_up) {
                 if (current_direction_up) {
                     // DACUserCode overflow ?
-                    if (DACUserCode + CV->_Step < DACUserCode) {
-                        DACUserCode = CV->_VStop;
+                    if (INSTRUCTION.VoltConstant + CV->_Step < INSTRUCTION.VoltConstant) {
+                        INSTRUCTION.VoltConstant = CV->_VStop;
                     }
                     // reach Vfinal ?
-                    else if (DACUserCode + CV->_Step > CV->_VStop) {
-                        DACUserCode =CV->_VStop;
+                    else if (INSTRUCTION.VoltConstant + CV->_Step > CV->_VStop) {
+                        INSTRUCTION.VoltConstant =CV->_VStop;
+                    }
+                    else if (INSTRUCTION.VoltConstant >= CV->_VStop){
+                        INSTRUCTION.VoltConstant =CV->_VStop;
                     }
                     else {
-                        DACUserCode = DACUserCode + CV->_Step;
+                        INSTRUCTION.VoltConstant = INSTRUCTION.VoltConstant + CV->_Step;
                     }
                 }
                 else {
                     // DACUserCode underflow ?
-                    if (DACUserCode - CV->_Step > DACUserCode) {
-                        DACUserCode = CV->_VOrigin;
+                    if (INSTRUCTION.VoltConstant - CV->_Step > INSTRUCTION.VoltConstant) {
+                        INSTRUCTION.VoltConstant = CV->_VOrigin;
                     }
-
                     // reach Vorigin ?
-                    else if (DACUserCode - CV->_Step <  CV->_VOrigin) {
-                        DACUserCode = CV->_VOrigin;
+                    else if (INSTRUCTION.VoltConstant - CV->_Step <  CV->_VOrigin) {
+                        INSTRUCTION.VoltConstant = CV->_VOrigin;
+                    }
+                    else if (INSTRUCTION.VoltConstant <= CV->_VOrigin){
+                        INSTRUCTION.VoltConstant = CV->_VOrigin;
                     }
                     else {
-                        DACUserCode = DACUserCode - CV->_Step;
+                        INSTRUCTION.VoltConstant = INSTRUCTION.VoltConstant - CV->_Step;
+                        if(INSTRUCTION.VoltConstant > 60000){
+                            INSTRUCTION.VoltConstant = 0;
+                            current_direction_up = true;
+                            if (CV->_CycleNumber == 0) {
+                                PeriodicEvent = false;  // periodic event end
+                                DACReset      = true;
+                            }
+                            CV->_CycleNumber--;
+                        }
                     }
                 }
             }
             else {
                 if (current_direction_up) {
-                    if (DACUserCode + CV->_Step < DACUserCode) {
-                        DACUserCode = CV->_VOrigin;
+
+                    if (INSTRUCTION.VoltConstant + CV->_Step < INSTRUCTION.VoltConstant) {
+                        INSTRUCTION.VoltConstant = CV->_VOrigin;
                     }
-                    else if (DACUserCode + CV->_Step >  CV->_VOrigin) {
-                        DACUserCode = CV->_VOrigin;
+
+                    else if (INSTRUCTION.VoltConstant + CV->_Step >  CV->_VOrigin) {
+                        INSTRUCTION.VoltConstant = CV->_VOrigin;
+                    }
+                    else if (INSTRUCTION.VoltConstant >= CV->_VOrigin){
+                        INSTRUCTION.VoltConstant = CV->_VOrigin;
                     }
                     else {
-                        DACUserCode = DACUserCode + CV->_Step;
+                        INSTRUCTION.VoltConstant = INSTRUCTION.VoltConstant + CV->_Step;
                     }
                 }
                 else {
-                    if (DACUserCode - CV->_Step > DACUserCode) {
-                        DACUserCode = CV->_VStop ;
+                    if (INSTRUCTION.VoltConstant - CV->_Step > INSTRUCTION.VoltConstant) {
+                        INSTRUCTION.VoltConstant = CV->_VStop ;
                     }
-                    else if (DACUserCode - CV->_Step < CV->_VStop) {
-                        DACUserCode = CV->_VStop;
+                    else if (INSTRUCTION.VoltConstant - CV->_Step < CV->_VStop) {
+                        INSTRUCTION.VoltConstant = CV->_VStop;
+                    }
+                    else if(INSTRUCTION.VoltConstant <= CV->_VStop){
+                        INSTRUCTION.VoltConstant = CV->_VStop;
                     }
                     else {
-                        DACUserCode = DACUserCode - CV->_Step;
+                        INSTRUCTION.VoltConstant = INSTRUCTION.VoltConstant - CV->_Step;
+
+                        if(INSTRUCTION.VoltConstant > 60000){
+                            INSTRUCTION.VoltConstant = 0;
+                            current_direction_up = true;
+                        }
                     }
                 }
             }
@@ -275,59 +395,92 @@ static uint16_t CVCurve(CVMode *CV) {
             if (direction_up) {
                 if (current_direction_up) {
                     // DACUserCode overflow ?
-                    if (DACUserCode + CV->_Step < DACUserCode) {
-                        DACUserCode = CV->_VStop;
+                    if (INSTRUCTION.VoltConstant + CV->_Step < INSTRUCTION.VoltConstant) {
+                        INSTRUCTION.VoltConstant = CV->_VStop;
                     }
                     // reach Vfinal ?
-                    else if (CV->MeasureVolt + ((int32_t)(CV->_Step) - DAC_ZERO)/5 > ((int32_t)(CV->_VStop) - DAC_ZERO)/5) {
-                        DACUserCode =CV->_VStop;
+                    else if (INSTRUCTION.VoltConstant + CV->_Step > CV->_VStop) {
+                        INSTRUCTION.VoltConstant =CV->_VStop;
+                    }
+                    else if (INSTRUCTION.VoltConstant >= CV->_VStop){
+                        INSTRUCTION.VoltConstant =CV->_VStop;
                     }
                     else {
-                        DACUserCode = DACUserCode + CV->_Step;
+                        INSTRUCTION.VoltConstant = INSTRUCTION.VoltConstant + CV->_Step;
                     }
                 }
                 else {
                     // DACUserCode underflow ?
-                    if (DACUserCode - CV->_Step > DACUserCode) {
-                        DACUserCode = CV->_VOrigin;
+                    if (INSTRUCTION.VoltConstant - CV->_Step > INSTRUCTION.VoltConstant) {
+                        INSTRUCTION.VoltConstant = CV->_VOrigin;
                     }
-
                     // reach Vorigin ?
-                    else if (CV->MeasureVolt - ((int32_t)(CV->_Step) - DAC_ZERO)/5 < ((int32_t)(CV->_VOrigin) - DAC_ZERO)/5) {
-                        DACUserCode = CV->_VOrigin;
+                    else if (INSTRUCTION.VoltConstant - CV->_Step < CV->_VOrigin) {
+                        INSTRUCTION.VoltConstant = CV->_VOrigin;
+                    }
+                    else if (INSTRUCTION.VoltConstant <= CV->_VOrigin){
+                        INSTRUCTION.VoltConstant = CV->_VOrigin;
                     }
                     else {
-                        DACUserCode = DACUserCode - CV->_Step;
+                        INSTRUCTION.VoltConstant = INSTRUCTION.VoltConstant - CV->_Step;
+                        if(INSTRUCTION.VoltConstant > 60000){
+                            INSTRUCTION.VoltConstant = 0;
+                            current_direction_up = true;
+                            if (CV->_CycleNumber == 0) {
+                                PeriodicEvent = false;  // periodic event end
+                                DACReset      = true;
+                            }
+                            CV->_CycleNumber--;
+                        }
                     }
                 }
             }
             else {
                 if (current_direction_up) {
-                    if (DACUserCode + CV->_Step < DACUserCode) {
-                        DACUserCode = CV->_VOrigin;
+                    // DACUserCode overflow ?
+                    if (INSTRUCTION.VoltConstant + CV->_Step < INSTRUCTION.VoltConstant) {
+                        INSTRUCTION.VoltConstant = CV->_VOrigin;
                     }
-                    else if (CV->MeasureVolt + ((int32_t)(CV->_Step) - DAC_ZERO)/5 > ((int32_t)(CV->_VOrigin) - DAC_ZERO)/5) {
-                        DACUserCode = CV->_VOrigin;
+                    // ex:command 3->1V ,when 1 to 3V, 2.99+0.1 > 3V
+                    else if (INSTRUCTION.VoltConstant + CV->_Step > CV->_VOrigin) {
+                        INSTRUCTION.VoltConstant = CV->_VOrigin;
+                    }
+                    else if (INSTRUCTION.VoltConstant >= CV->_VOrigin){
+                        INSTRUCTION.VoltConstant = CV->_VOrigin;
                     }
                     else {
-                        DACUserCode = DACUserCode + CV->_Step;
+                        INSTRUCTION.VoltConstant = INSTRUCTION.VoltConstant + CV->_Step;
                     }
                 }
                 else {
-                    if (DACUserCode - CV->_Step > DACUserCode) {
-                        DACUserCode = CV->_VStop ;
+                    if (INSTRUCTION.VoltConstant - CV->_Step > INSTRUCTION.VoltConstant) {
+                        INSTRUCTION.VoltConstant = CV->_VStop ;
                     }
-                    else if (CV->MeasureVolt - ((int32_t)(CV->_Step) - DAC_ZERO)/5 < ((int32_t)(CV->_VStop) - DAC_ZERO)/5) {
-                        DACUserCode = CV->_VStop;
+                    else if (INSTRUCTION.VoltConstant - CV->_Step < CV->_VStop) {
+                        INSTRUCTION.VoltConstant = CV->_VStop;
+                    }
+                    else if(INSTRUCTION.VoltConstant <= CV->_VStop){
+                        INSTRUCTION.VoltConstant = CV->_VStop;
                     }
                     else {
-                        DACUserCode = DACUserCode - CV->_Step;
+                        INSTRUCTION.VoltConstant = INSTRUCTION.VoltConstant - CV->_Step;
+
+                        if(INSTRUCTION.VoltConstant > 60000){
+                            INSTRUCTION.VoltConstant = 0;
+                            current_direction_up = true;
+                        }
                     }
                 }
             }
         }
-        
-        DACOutCode = Usercode_Correction_to_DAC(DACUserCode);
+
+//        NotifyImpedance[0] = 0x00;
+//        NotifyImpedance[1] = 0x00;
+//        NotifyImpedance[2] = (uint8_t)((DACOutCode & 0xFF00) >> 8);
+//        NotifyImpedance[3] = (uint8_t)(DACOutCode & 0x00FF);
+
+
+        DACOutCode = Usercode_Correction_to_DAC(INSTRUCTION.VoltConstant);
         DAC_outputV(DACOutCode);
     }
     return DACOutCode;
@@ -380,7 +533,7 @@ static void CV_Plot(CVMode *CV){
 //    }
     else if(VoltCurrentSwitch < 9){
         if(CV->_VoVi_Switch == 0x01){
-            // read volt
+            // read vin volt
             ReadVolt(spi_ADC_rxbuf);
         }else if(CV->_VoVi_Switch == 0x00){
              // read vout volt
@@ -390,19 +543,31 @@ static void CV_Plot(CVMode *CV){
     }
     else if(VoltCurrentSwitch == 9){
         if(CV->_VoVi_Switch == 0x01){
-            /** read battery voltage **/
+            // read vin volt
             ReadVolt(spi_ADC_rxbuf);
             ADC_measure = (uint16_t) (spi_ADC_rxbuf[0] << 8) | (uint16_t) (spi_ADC_rxbuf[1]);
             //CV->MeasureVolt = 20000;
             CV->MeasureVolt = DecodeADCVolt(ADC_measure);
         }else if(CV->_VoVi_Switch == 0x00){
-           /** read vout voltage **/
+           // read vout volt
             ReadVoutVolt(spi_ADC_rxbuf);
             ADC_measure = (uint16_t) (spi_ADC_rxbuf[0] << 8) | (uint16_t) (spi_ADC_rxbuf[1]);
             CV->MeasureVolt = DecodeADCVoutVolt(ADC_measure);
         }
         VoltCurrentSwitch++;
     }
+//    else if (VoltCurrentSwitch < 13){
+//             ReadBatVolt(spi_ADC_rxbuf);
+//             VoltCurrentSwitch ++;
+//    }
+//    else if (VoltCurrentSwitch == 13){
+//         // read battery volt
+//         ReadBatVolt(spi_ADC_rxbuf);
+//         ADC_measure = (uint16_t) (spi_ADC_rxbuf[0] << 8) | (uint16_t) (spi_ADC_rxbuf[1]);
+//         CV->_MeasureBatvolt = DecodeADCBatVolt(ADC_measure);
+//         CV->_MeasureBatvolt = CV->_MeasureBatvolt/10 - 250; // (5.00V) 5000->250 usercode
+//         VoltCurrentSwitch ++;
+//    }
     else{
         VoltCurrentSwitch = 0;
     }
@@ -413,11 +578,20 @@ static void CV_Plot(CVMode *CV){
     NotifyCurrent[3] = (uint8_t) (CV->_MeasureData & 0x000000FF);
 
     if ((CV->_VoVi_Switch == 0x01) || (CV->_VoVi_Switch == 0x00)){        //user see Vin || user see Vout
-        NotifyVolt[0] = (uint8_t) (CV->MeasureVolt >> 24);
-        NotifyVolt[1] = (uint8_t) ((CV->MeasureVolt & 0x00FF0000) >> 16);
-        NotifyVolt[2] = (uint8_t) ((CV->MeasureVolt & 0x0000FF00) >> 8);
-        NotifyVolt[3] = (uint8_t) (CV->MeasureVolt & 0x000000FF);
+//        NotifyVolt[0] = (uint8_t) (CV->MeasureVolt >> 24);
+//        NotifyVolt[1] = (uint8_t) ((CV->MeasureVolt & 0x00FF0000) >> 16);
+//        NotifyVolt[2] = (uint8_t) ((CV->MeasureVolt & 0x0000FF00) >> 8);
+//        NotifyVolt[3] = (uint8_t) (CV->MeasureVolt & 0x000000FF);
+
+        int32_t RealV;
+        RealV = (int32_t)(INSTRUCTION.VoltConstant - 25000)*1000/5;
+        NotifyVolt[0] = (uint8_t)((RealV & 0xFF000000) >> 24);
+        NotifyVolt[1] = (uint8_t)((RealV & 0x00FF0000) >> 16);
+        NotifyVolt[2] = (uint8_t)((RealV & 0x0000FF00) >> 8);
+        NotifyVolt[3] = (uint8_t)(RealV & 0x000000FF);
     }
+
+//    NotifyBatVolt = (uint8_t) (CV->_MeasureBatvolt & 0x000000FF);
 }
 
 

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

@@ -29,7 +29,7 @@
 */
 
 
-#define BOARD_KUMA
+#define BOARD_ANGUS
 
 typedef struct _formula{
 
@@ -313,23 +313,23 @@ struct _correction{
 
 #ifdef BOARD_517
 {
-.ADC_volt.coeff = (-6244769),
-.ADC_volt.offset = 101714685687,
+.ADC_volt.coeff = (-6242316),
+.ADC_volt.offset = 101695491616,
 
-.ADC_current[0].coeff = 30919726,
-.ADC_current[0].offset = (-503489101786),
+.ADC_current[0].coeff = 31169316,
+.ADC_current[0].offset = (-507589234000),
 
-.ADC_current[1].coeff = 654824495,
-.ADC_current[1].offset = (-10660542778914),
+.ADC_current[1].coeff = 657889599,
+.ADC_current[1].offset = (-10712745285212),
 
-.ADC_current[2].coeff = 31376265,
-.ADC_current[2].offset = (-510797752348),
+.ADC_current[2].coeff = 31568312650,
+.ADC_current[2].offset = (-514058403190859),
 
 .DAC2RealV.coeff = (-18690126),
 .DAC2RealV.offset = 564319610294 ,
 
-.Usercode2DAC.coeff = (-10500774),
-.Usercode2DAC.offset = 560779455904,
+.Usercode2DAC.coeff = (-10498485),
+.Usercode2DAC.offset = 560797798529,
 
 .Gain0Boundary[0] = 0x5E2F,
 .Gain0Boundary[1] = 0x5E96,
@@ -537,23 +537,23 @@ struct _correction{
 
 #ifdef BOARD_VENUS
 {
-.ADC_volt.coeff = (-6268996),
-.ADC_volt.offset = 102204055818,
+.ADC_volt.coeff = (-6269185),
+.ADC_volt.offset = 102228792306,
 
-.ADC_current[0].coeff = 31131930,
-.ADC_current[0].offset = (-507382432547),
+.ADC_current[0].coeff = 31229744,
+.ADC_current[0].offset = (-509240005160),
 
-.ADC_current[1].coeff = 654620883,
-.ADC_current[1].offset = (-10668953588943),
+.ADC_current[1].coeff = 671245720,
+.ADC_current[1].offset = (-10939750446252),
 
-.ADC_current[2].coeff = 31245260000,
-.ADC_current[2].offset = (-509181085054000),
+.ADC_current[2].coeff = 35220821945,
+.ADC_current[2].offset = (-574099564362474),
 
 .DAC2RealV.coeff = (-19009388),
 .DAC2RealV.offset = 567032653061,
 
-.Usercode2DAC.coeff = (-10521117),
-.Usercode2DAC.offset = 561308254899,
+.Usercode2DAC.coeff = (-10524891),
+.Usercode2DAC.offset = 561393946495,
 
 .Gain0Boundary[0] = 0x5D96,
 .Gain0Boundary[1] = 0x5DD9,
@@ -621,8 +621,8 @@ struct _correction{
 
 #ifdef BOARD_SATURN
 {
-.ADC_volt.coeff = (-6262993),
-.ADC_volt.offset = 101996256499,
+.ADC_volt.coeff = (-6262258),
+.ADC_volt.offset = 101986379869,
 
 .ADC_current[0].coeff = 31482854,
 .ADC_current[0].offset = (-513080696050),
@@ -630,14 +630,14 @@ struct _correction{
 .ADC_current[1].coeff = 660069824,
 .ADC_current[1].offset = (-10757047907091),
 
-.ADC_current[2].coeff = 31599480301,
-.ADC_current[2].offset = (-514997796786064),
+.ADC_current[2].coeff = 31692010534,
+.ADC_current[2].offset = (-516553361701835),
 
 .DAC2RealV.coeff = (-19009388),
 .DAC2RealV.offset = 567032653061,
 
-.Usercode2DAC.coeff = (-10482326),
-.Usercode2DAC.offset = 558931155711,
+.Usercode2DAC.coeff = (-10484502),
+.Usercode2DAC.offset = 558944670693,
 
 .Gain0Boundary[0] = 0x5D96,
 .Gain0Boundary[1] = 0x5DD9,
@@ -792,8 +792,8 @@ struct _correction{
 .ADC_volt.coeff = (-6242774),
 .ADC_volt.offset = 101201319007,
 
-.ADC_current[0].coeff = 31322380,
-.ADC_current[0].offset = -507484324313,
+.ADC_current[0].coeff = 31462554,
+.ADC_current[0].offset = -509881330352,
 
 .ADC_current[1].coeff = 659514123,
 .ADC_current[1].offset = -10687831492393,
@@ -815,14 +815,632 @@ struct _correction{
 };
 #endif
 
+#ifdef BOARD_ANGUS
+{
+.ADC_volt.coeff = (-6243800),
+.ADC_volt.offset = 101198174953,
+
+.ADC_current[0].coeff = 31174733,
+.ADC_current[0].offset = -505246715963,
+
+.ADC_current[1].coeff = 655540713,
+.ADC_current[1].offset = -10622652066340,
+
+.ADC_current[2].coeff = 31416986708,
+.ADC_current[2].offset = -509094727775962,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10556932),
+.Usercode2DAC.offset = 561269201380,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+
+#ifdef BOARD_C5F3
+{
+.ADC_volt.coeff = (-6249801),
+.ADC_volt.offset = 101577560497,
+
+.ADC_current[0].coeff = 31333145,
+.ADC_current[0].offset = -509202021996,
+
+.ADC_current[1].coeff = 655056917,
+.ADC_current[1].offset = -10647726030826,
+
+.ADC_current[2].coeff = 31407894492,
+.ADC_current[2].offset = -510516121023653,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10489696),
+.Usercode2DAC.offset = 559743808452,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+
+#ifdef BOARD_C7A7
+{
+.ADC_volt.coeff = (-6260414),
+.ADC_volt.offset = 101368153805,
+
+.ADC_current[0].coeff = 31152640,
+.ADC_current[0].offset = -506323045036,
+
+.ADC_current[1].coeff = 653922673,
+.ADC_current[1].offset = -10628474486965,
+
+.ADC_current[2].coeff = 31393868429,
+.ADC_current[2].offset = -510314295937946,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10547274),
+.Usercode2DAC.offset = 561050097141,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+
+#ifdef BOARD_POCA
+{
+.ADC_volt.coeff = (-6241861),
+.ADC_volt.offset = 101629864562,
+
+.ADC_current[0].coeff = 31256579,
+.ADC_current[0].offset = -508530535142,
+
+.ADC_current[1].coeff = 658820355,
+.ADC_current[1].offset = -10720633637013,
+
+.ADC_current[2].coeff = 31445401561,
+.ADC_current[2].offset = -511730149870324,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10572079),
+.Usercode2DAC.offset = 564222895808,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+
+#ifdef BOARD_D429
+{
+.ADC_volt.coeff = (-6238779),
+.ADC_volt.offset = 101605334434,
+
+.ADC_current[0].coeff = 31071846,
+.ADC_current[0].offset = -505811219439,
+
+.ADC_current[1].coeff = 656609367,
+.ADC_current[1].offset = -10692060258062,
+
+.ADC_current[2].coeff = 31524582021,
+.ADC_current[2].offset = -513367397453127,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10507806),
+.Usercode2DAC.offset = 562068643815,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+
+#ifdef BOARD_C60D
+{
+.ADC_volt.coeff = (-6257164),
+.ADC_volt.offset = 102239515470,
+
+.ADC_current[0].coeff = 31270905,
+.ADC_current[0].offset = -510840730706,
+
+.ADC_current[1].coeff = 654407812,
+.ADC_current[1].offset = -10691708695136,
+
+.ADC_current[2].coeff = 31370764564,
+.ADC_current[2].offset = -512563422208737,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10505677),
+.Usercode2DAC.offset = 561896606772,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+
+#ifdef BOARD_MILKY
+{
+.ADC_volt.coeff = (-6245296),
+.ADC_volt.offset = 101930135585,
+
+.ADC_current[0].coeff = 31234538,
+.ADC_current[0].offset = -510079528824,
+
+.ADC_current[1].coeff = 655637591,
+.ADC_current[1].offset = -10704987805680,
+
+.ADC_current[2].coeff = 31674775010,
+.ADC_current[2].offset = -517270192436237,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10537872),
+.Usercode2DAC.offset = 562523723374,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+
+#ifdef BOARD_C673
+{
+.ADC_volt.coeff = (-6250835),
+.ADC_volt.offset = 102137137483,
+
+.ADC_current[0].coeff = 31377840,
+.ADC_current[0].offset = -513157633310,
+
+.ADC_current[1].coeff = 656775773,
+.ADC_current[1].offset = -10735818498628,
+
+.ADC_current[2].coeff = 31564418269,
+.ADC_current[2].offset = -515846860363218,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10589134),
+.Usercode2DAC.offset = 566193811359,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+
+#ifdef BOARD_C5E0
+{
+.ADC_volt.coeff = (-6245327),
+.ADC_volt.offset = 101307483012,
+
+.ADC_current[0].coeff = 31354974,
+.ADC_current[0].offset = -507194879524,
+
+.ADC_current[1].coeff = 658451900,
+.ADC_current[1].offset = -10677456008545,
+
+.ADC_current[2].coeff = 31568312650,
+.ADC_current[2].offset = -511943326243316,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-21557794),
+.Usercode2DAC.offset = 1122382223883,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+
+#ifdef BOARD_C64C
+{
+.ADC_volt.coeff = (-6260844),
+.ADC_volt.offset = 101746271485,
+
+
+.ADC_current[0].coeff = 31234762,
+.ADC_current[0].offset = -509025107922,
+
+.ADC_current[1].coeff = 660737512,
+.ADC_current[1].offset = -10739681096143,
+
+.ADC_current[2].coeff = 31446881444,
+.ADC_current[2].offset = -511179540163754,
+
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10547083),
+.Usercode2DAC.offset = 562398595911,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+
+#ifdef BOARD_C6F1
+{
+.ADC_volt.coeff = (-6247180),
+.ADC_volt.offset = 102054272790,
+
+.ADC_current[0].coeff = 30976281,
+.ADC_current[0].offset = -505757488419,
+
+.ADC_current[1].coeff = 655631961,
+.ADC_current[1].offset = -10714280118989,
+
+.ADC_current[2].coeff = 31377993512,
+.ADC_current[2].offset = -512826236956373,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10535141),
+.Usercode2DAC.offset = 562486477211,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+#ifdef BOARD_C5A7
+{
+.ADC_volt.coeff = (-6261077),
+.ADC_volt.offset = 101626420148,
+
+.ADC_current[0].coeff = 31238670,
+.ADC_current[0].offset = -508954779962,
+
+.ADC_current[1].coeff = 655018286,
+.ADC_current[1].offset = -10624775781189,
+
+.ADC_current[2].coeff = 31254713545,
+.ADC_current[2].offset = -506913323208609,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10486554),
+.Usercode2DAC.offset = 558961930417,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+
+#ifdef BOARD_C5BC
+{
+.ADC_volt.coeff = (-6247591),
+.ADC_volt.offset = 101907211036,
+
+.ADC_current[0].coeff = 31127907,
+.ADC_current[0].offset = -509404424258,
+
+.ADC_current[1].coeff = 657090640,
+.ADC_current[1].offset = -10708439489521,
+
+.ADC_current[2].coeff = 31323762927,
+.ADC_current[2].offset = -510639983237350,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10500262),
+.Usercode2DAC.offset = 561352279115,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+
+#ifdef BOARD_C61B
+{
+.ADC_volt.coeff = (-6240181),
+.ADC_volt.offset = 101555032590,
+
+.ADC_current[0].coeff = 31453336,
+.ADC_current[0].offset = -512480994335,
+
+.ADC_current[1].coeff = 655791462,
+.ADC_current[1].offset = -10674697458906,
+
+.ADC_current[2].coeff = 31308254406,
+.ADC_current[2].offset = -509597572256835,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10647081),
+.Usercode2DAC.offset = 565878482890,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+
+
+#ifdef BOARD_C73D
+{
+.ADC_volt.coeff = (-6295524),
+.ADC_volt.offset = 102674817855,
+
+.ADC_current[0].coeff = 31655210,
+.ADC_current[0].offset = -516217345046,
+
+.ADC_current[1].coeff = 657366554,
+.ADC_current[1].offset = -10730794522132,
+
+.ADC_current[2].coeff = 31455150257,
+.ADC_current[2].offset = -513437175114578,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10572307),
+.Usercode2DAC.offset = 565374291147,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+
+
+#ifdef BOARD_C635
+{
+.ADC_volt.coeff = (-6253221),
+.ADC_volt.offset = 101809981406,
+
+.ADC_current[0].coeff = 31341845,
+.ADC_current[0].offset = -510459459634,
+
+.ADC_current[1].coeff = 658436945,
+.ADC_current[1].offset = -10717869924356,
+
+.ADC_current[2].coeff = 31308250447,
+.ADC_current[2].offset = -509649688240631,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10515473),
+.Usercode2DAC.offset = 561702427427,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+
+#ifdef BOARD_C682
+{
+.ADC_volt.coeff = (-6255881),
+.ADC_volt.offset = 101770749912,
+
+.ADC_current[0].coeff = 31201404,
+.ADC_current[0].offset = -508138266998,
+
+.ADC_current[1].coeff = 656614595,
+.ADC_current[1].offset = -10686126424043,
+
+.ADC_current[2].coeff = 31414681873,
+.ADC_current[2].offset = -511205882335203,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10526542),
+.Usercode2DAC.offset = 561504215196,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+
+#ifdef BOARD_C688
+{
+.ADC_volt.coeff = (-6258215),
+.ADC_volt.offset = 102154138920,
+
+.ADC_current[0].coeff = 31341184,
+.ADC_current[0].offset = -510715097964,
+
+.ADC_current[1].coeff = 659789967,
+.ADC_current[1].offset = -10771124472519,
+
+.ADC_current[2].coeff = 31519139222,
+.ADC_current[2].offset = -514534188233139,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10537634),
+.Usercode2DAC.offset = 562780854012,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+
+#ifdef BOARD_C758
+{
+.ADC_volt.coeff = (-6243164),
+.ADC_volt.offset = 101637253844,
+
+.ADC_current[0].coeff = 30911246,
+.ADC_current[0].offset = -503647274606,
+
+.ADC_current[1].coeff = 653825342,
+.ADC_current[1].offset = -10648468733909,
+
+.ADC_current[2].coeff = 31170419731,
+.ADC_current[2].offset = -507639789070676,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10486554),
+.Usercode2DAC.offset = 558961930417,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+
+#ifdef BOARD_C5F1
+{
+.ADC_volt.coeff = (-6253958),
+.ADC_volt.offset = 101452368461,
+
+.ADC_current[0].coeff = 30744013,
+.ADC_current[0].offset = -498179836930,
+
+.ADC_current[1].coeff = 654390794,
+.ADC_current[1].offset = -10613673358566,
+
+.ADC_current[2].coeff = 31298803888,
+.ADC_current[2].offset = -507656332800484,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10518181),
+.Usercode2DAC.offset = 560301589307,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+
+#ifdef BOARD_C6D5
+{
+.ADC_volt.coeff = (-6237534),
+.ADC_volt.offset = 101605935716,
+
+.ADC_current[0].coeff = 31115458,
+.ADC_current[0].offset = -507263643623,
+
+.ADC_current[1].coeff = 658403575,
+.ADC_current[1].offset = -10732526947976,
+
+.ADC_current[2].coeff = 31390460797,
+.ADC_current[2].offset = -511690836380334,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10584982),
+.Usercode2DAC.offset = 563383734482,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
+
+#ifdef BOARD_C706
+{
+.ADC_volt.coeff = (-6265060),
+.ADC_volt.offset = 101304934795,
+
+.ADC_current[0].coeff = 31017413,
+.ADC_current[0].offset = -501641612769,
+
+.ADC_current[1].coeff = 657630384,
+.ADC_current[1].offset = -10633992921166,
+
+.ADC_current[2].coeff = 31013727410,
+.ADC_current[2].offset = -501507479075525,
+
+.DAC2RealV.coeff = (-19007867),
+.DAC2RealV.offset = 646316924837,
+
+.Usercode2DAC.coeff = (-10557808),
+.Usercode2DAC.offset = 560287506126,
+
+.Gain0Boundary[0] = 0x5ECD,
+.Gain0Boundary[1] = 0x5F0D,
+
+.Gain1Boundary[0] = 0x5900,
+.Gain1Boundary[1] = 0x64DD
+};
+#endif
 
 // this function turn ADC measure value (0xXXXX) into real voltage
-// unit should be mV
+// unit should be uV
 static int32_t DecodeADCVolt(uint16_t ADC_measure){
     long long ADCRealVolt = 0;
 
     ADCRealVolt = (Correction.ADC_volt.coeff * ADC_measure + Correction.ADC_volt.offset);
-    ADCRealVolt = ADCRealVolt / 1e7;
+    ADCRealVolt = ADCRealVolt / 1e4;
 
     return (int32_t) (ADCRealVolt);
 }
@@ -837,6 +1455,16 @@ static int32_t DecodeADCVoutVolt(uint16_t ADC_measure){
     return (int32_t) (ADCVoutVolt);
 }
 
+// this function turn ADC measure value (0xXXXX) into Battery voltage
+// unit should be mV
+static int32_t DecodeADCBatVolt(uint16_t ADC_measure){
+    long long ADCBatVolt = 0;
+
+    ADCBatVolt = (12571991860 * ADC_measure + 3314058604700);
+    ADCBatVolt = ADCBatVolt / 1e11;
+    return (int32_t) (ADCBatVolt);
+}
+
 // this function turn ADC measure value (0xXXXX) into real current
 // unit should be pA
 static int32_t DecodeADCCurrent(uint8_t ADCGain, uint16_t ADC_measure){
@@ -893,7 +1521,7 @@ static int32_t DecodeResister(uint8_t ADCGainLevel, uint16_t CurrentMeasure, uin
 static int32_t DecodeADCValue(uint8_t ADCGain, uint8_t ADCChannel, uint8_t *ADC_raw){
 
     uint16_t ADC_measure = (uint16_t) (ADC_raw[0] << 8) | (uint16_t) (ADC_raw[1]);
-    int32_t ADCRealVolt = 0, ret = 0, ADCRealCurrent = 0, ADCVoutVolt = 0;;
+    int32_t ADCRealVolt = 0, ret = 0, ADCRealCurrent = 0, ADCVoutVolt = 0, ADCBatVolt = 0;
 
 
     // return real volt to controller
@@ -912,12 +1540,18 @@ static int32_t DecodeADCValue(uint8_t ADCGain, uint8_t ADCChannel, uint8_t *ADC_
         ret = ADCRealCurrent;
     }
 
-    // return real TestVolt to controller
+    // return real VoutVolt to controller
     else if(ADCChannel == ADC_CH_DAC){
         ADCVoutVolt = DecodeADCVoutVolt(ADC_measure);
         ret = ADCVoutVolt;
     }
 
+    // return real Battery Volt to controller
+    else if(ADCChannel == ADC_CH_BAT){
+        ADCBatVolt = DecodeADCBatVolt(ADC_measure);
+        ret = ADCBatVolt;
+    }
+
 
 //        if ( (INSTRUCTION.eliteFxn == IV_CURVE) || (INSTRUCTION.eliteFxn == CV_CURVE)) {
 //        if ( (INSTRUCTION.eliteFxn == CV_CURVE)) {
@@ -1026,9 +1660,9 @@ static int32_t DAC_to_realV(uint16_t DACcode)
 
     usercode_32 = ((DACcode * 1e7) - Correction.Usercode2DAC.offset) / Correction.Usercode2DAC.coeff;
 
-    RealV = (int32_t) (usercode_32 / 5) - 5000;
-
-    // return mV
+    RealV = (int32_t) ((usercode_32 / 5) - 5000) * 1000;
+//    RealV = (int32_t) usercode_32;
+    // return nV
     return RealV;
 }
 

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

@@ -41,7 +41,7 @@ static uint16_t OneWayVoltScan(IVMode *IV) {
     }
 
     if (CT.StepTimeCounter == IV->_StepTime){
-        if (IV->_VOrigin < IV->_VStop) {
+        if (IV->_VOrigin < IV->_VStop) {//4~5V
             // output the next output volt
             INSTRUCTION.VoltConstant = INSTRUCTION.VoltConstant + IV->_Step;
             // Only used in two-wire IV
@@ -76,27 +76,42 @@ static uint16_t OneWayVoltScan(IVMode *IV) {
 ////                reset();
 //            }
         }
-        if (IV->_VoVi_Switch == 0x00){        //user see Vout
-            if (IV->_VOrigin < IV->_VStop) {
-                if(INSTRUCTION.VoltConstant >= IV->_VStop){
-                    PeriodicEvent = false;
-                    DACReset      = true;
-                }
-            }
-            else{
-                if(INSTRUCTION.VoltConstant <= IV->_VStop){
-                    PeriodicEvent = false;
-                    DACReset      = true;
-                }
-            }
-        }
 
-        int32_t RealV;
-        RealV = DAC_to_realV(DACOutCode);
-        NotifyVolt[0] = (uint8_t)((RealV & 0xFF000000) >> 24);
-        NotifyVolt[1] = (uint8_t)((RealV & 0x00FF0000) >> 16);
-        NotifyVolt[2] = (uint8_t)((RealV & 0x0000FF00) >> 8);
-        NotifyVolt[3] = (uint8_t)(RealV & 0x000000FF);
+//        if (IV->_VoVi_Switch == 0x00 || IV->_VoVi_Switch == 0x01){        //user see Vout/user see Vin
+//            if (IV->_VOrigin < IV->_VStop) {
+//                if(INSTRUCTION.VoltConstant >= IV->_VStop){
+//                    PeriodicEvent = false;
+//                    DACReset      = true;
+//                }
+//            }
+//            else{
+//                if(INSTRUCTION.VoltConstant <= IV->_VStop){
+//                    PeriodicEvent = false;
+//                    DACReset      = true;
+//                }
+//            }
+//        }
+
+//        int32_t RealV;
+//        RealV = DAC_to_realV(DACOutCode);
+//        NotifyVolt[0] = (uint8_t)((RealV & 0xFF000000) >> 24);
+//        NotifyVolt[1] = (uint8_t)((RealV & 0x00FF0000) >> 16);
+//        NotifyVolt[2] = (uint8_t)((RealV & 0x0000FF00) >> 8);
+//        NotifyVolt[3] = (uint8_t)(RealV & 0x000000FF);
+
+//          int32_t RealV;
+//          RealV = (int32_t)(INSTRUCTION.VoltConstant - 25000)/5*1000;
+//          NotifyVolt[0] = (uint8_t)((RealV & 0xFF000000) >> 24);
+//          NotifyVolt[1] = (uint8_t)((RealV & 0x00FF0000) >> 16);
+//          NotifyVolt[2] = (uint8_t)((RealV & 0x0000FF00) >> 8);
+//          NotifyVolt[3] = (uint8_t)(RealV & 0x000000FF);
+
+
+//        NotifyImpedance[0] = 0x00;
+//        NotifyImpedance[1] = 0x00;
+//        NotifyImpedance[2] = (uint8_t)((INSTRUCTION.VoltConstant & 0xFF00) >> 8);
+//        NotifyImpedance[3] = (uint8_t)(INSTRUCTION.VoltConstant & 0x00FF);
+
             
     }
 
@@ -148,7 +163,7 @@ static void IV_Plot(IVMode *IV) {
 //    }
     else if(VoltCurrentSwitch < 9){
         if(IV->_VoVi_Switch == 0x01){
-            // read volt
+            // read vin volt
             ReadVolt(spi_ADC_rxbuf);
         }else if(IV->_VoVi_Switch == 0x00){
             // read vout volt
@@ -158,18 +173,30 @@ static void IV_Plot(IVMode *IV) {
     }
     else if(VoltCurrentSwitch == 9){
         if(IV->_VoVi_Switch == 0x01){
-            /** read battery voltage **/
+            // read vin volt
             ReadVolt(spi_ADC_rxbuf);
             ADC_measure = (uint16_t) (spi_ADC_rxbuf[0] << 8) | (uint16_t) (spi_ADC_rxbuf[1]);
             IV->MeasureVolt = DecodeADCVolt(ADC_measure);
         }else if(IV->_VoVi_Switch == 0x00){
-            /** read vout voltage **/
+            // read vout volt
             ReadVoutVolt(spi_ADC_rxbuf);
             ADC_measure = (uint16_t) (spi_ADC_rxbuf[0] << 8) | (uint16_t) (spi_ADC_rxbuf[1]);
             IV->MeasureVolt = DecodeADCVoutVolt(ADC_measure);
         }
         VoltCurrentSwitch++;
     }
+//    else if (VoltCurrentSwitch < 13){
+//        ReadBatVolt(spi_ADC_rxbuf);
+//        VoltCurrentSwitch ++;
+//    }
+//    else if (VoltCurrentSwitch == 13){
+//        // read battery volt
+//        ReadBatVolt(spi_ADC_rxbuf);
+//        ADC_measure = (uint16_t) (spi_ADC_rxbuf[0] << 8) | (uint16_t) (spi_ADC_rxbuf[1]);
+//        IV->_MeasureBatvolt = DecodeADCBatVolt(ADC_measure);
+//        IV->_MeasureBatvolt = IV->_MeasureBatvolt/10 - 250; // (5.00V) 5000->250 usercode
+//        VoltCurrentSwitch ++;
+//    }
     else{
         VoltCurrentSwitch = 0;
     }
@@ -181,25 +208,55 @@ static void IV_Plot(IVMode *IV) {
     NotifyCurrent[2] = (uint8_t) ((IV->_MeasureData & 0x0000FF00) >> 8);
     NotifyCurrent[3] = (uint8_t) (IV->_MeasureData & 0x000000FF);
 
-    if((IV->_VoVi_Switch == 0x01) || (IV->_VoVi_Switch == 0x00)){        //user see Vin || user see Vout
-        NotifyVolt[0] = (uint8_t) (IV->MeasureVolt >> 24);
-        NotifyVolt[1] = (uint8_t) ((IV->MeasureVolt & 0x00FF0000) >> 16);
-        NotifyVolt[2] = (uint8_t) ((IV->MeasureVolt & 0x0000FF00) >> 8);
-        NotifyVolt[3] = (uint8_t) (IV->MeasureVolt & 0x000000FF);
+//    if((IV->_VoVi_Switch == 0x01) || (IV->_VoVi_Switch == 0x00)){        //user see Vin || user see Vout
+////        NotifyVolt[0] = (uint8_t) (IV->MeasureVolt >> 24);
+////        NotifyVolt[1] = (uint8_t) ((IV->MeasureVolt & 0x00FF0000) >> 16);
+////        NotifyVolt[2] = (uint8_t) ((IV->MeasureVolt & 0x0000FF00) >> 8);
+////        NotifyVolt[3] = (uint8_t) (IV->MeasureVolt & 0x000000FF);
+//          int32_t RealV;
+//          RealV = (int32_t)(INSTRUCTION.VoltConstant - 25000)/5*1000;
+//          NotifyVolt[0] = (uint8_t)((RealV & 0xFF000000) >> 24);
+//          NotifyVolt[1] = (uint8_t)((RealV & 0x00FF0000) >> 16);
+//          NotifyVolt[2] = (uint8_t)((RealV & 0x0000FF00) >> 8);
+//          NotifyVolt[3] = (uint8_t)(RealV & 0x000000FF);
+//
+//        if (IV->_VOrigin < IV->_VStop) {
+//            if((IV->MeasureVolt/1000) >= ((int32_t) (IV->_VStop) - DAC_ZERO)/5){
+//                PeriodicEvent = false;
+//                DACReset      = true;
+//            }
+//        }
+//        else{
+//            if((IV->MeasureVolt/1000) <= ((int32_t) (IV->_VStop) - DAC_ZERO)/5){
+//                PeriodicEvent = false;
+//                DACReset      = true;
+//            }
+//        }
+//    }
+
+    if (IV->_VoVi_Switch == 0x00 || IV->_VoVi_Switch == 0x01){        //user see Vout/user see Vin
+          int32_t RealV;
+          RealV = (int32_t)(INSTRUCTION.VoltConstant - 25000)*1000/5;
+          NotifyVolt[0] = (uint8_t)((RealV & 0xFF000000) >> 24);
+          NotifyVolt[1] = (uint8_t)((RealV & 0x00FF0000) >> 16);
+          NotifyVolt[2] = (uint8_t)((RealV & 0x0000FF00) >> 8);
+          NotifyVolt[3] = (uint8_t)(RealV & 0x000000FF);
 
         if (IV->_VOrigin < IV->_VStop) {
-            if(IV->MeasureVolt >= ((int32_t) (IV->_VStop) - DAC_ZERO)/5){
+            if(INSTRUCTION.VoltConstant >= IV->_VStop){
                 PeriodicEvent = false;
                 DACReset      = true;
             }
         }
         else{
-            if(IV->MeasureVolt <= ((int32_t) (IV->_VStop) - DAC_ZERO)/5){
+            if(INSTRUCTION.VoltConstant <= IV->_VStop){
                 PeriodicEvent = false;
                 DACReset      = true;
             }
         }
     }
+
+//    NotifyBatVolt = (uint8_t) (IV->_MeasureBatvolt & 0x000000FF);
 }
 
 

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

@@ -24,6 +24,7 @@ static uint32_t not_time_stamp;
 static uint8_t NotifyCurrent[4] = {0};
 static uint8_t NotifyVolt[4] = {0};
 static uint8_t NotifyImpedance[4] = {0};
+static uint8_t NotifyBatVolt = 0;
 
 /**
  * counter of notify send.
@@ -106,6 +107,9 @@ static void SendNotify() {
     // cyclic voltametry cycle number
     not_buf[17] = INSTRUCTION.CycleNumber;
 
+    //battery volt
+    not_buf[18] = NotifyBatVolt;
+
     SimpleProfile_SetParameter(BLE_DAT_BUFF_CHAR, BLE_DAT_BUFF_SIZE, not_buf);
 }
 
@@ -129,6 +133,9 @@ static void FlushNotify(){
     // cyclic voltametry cycle number
     not_buf[17] = 0x00;
 
+    //battery volt
+    not_buf[18] = 0x00;
+
     SimpleProfile_SetParameter(BLE_DAT_BUFF_CHAR, BLE_DAT_BUFF_SIZE, not_buf);
 }
 

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

@@ -195,7 +195,7 @@ typedef struct _RVoutMode{
     MEASURE;
 }RVoutMode;
 
-RVoutMode * InitTVMode(){
+RVoutMode * InitRVoutMode(){
     RVoutMode *ret = malloc(sizeof(RVoutMode));
     ret->_MeasureData = 0;
 //    ret->SetMeasureData = &_SetMeasureData;
@@ -295,6 +295,7 @@ typedef struct _IVMode{
     int32_t MeasureVolt;
     VOUT_PARA;
     LIMIT;
+    int32_t _MeasureBatvolt;
 }IVMode;
 
 IVMode *InitIVMode(){
@@ -309,7 +310,8 @@ IVMode *InitIVMode(){
     ret->_Step  = INSTRUCTION.Step;
     ret->_StepTime = INSTRUCTION.StepTime;
     ret->_CycleNumber = 1;
-    
+    ret->_MeasureBatvolt = 0;
+
 
 //    ret->SetVoltOut = &_SetVoltOut;
 //    ret->GetVoltOut = &_GetVoltOut;
@@ -372,6 +374,7 @@ typedef struct _CVMode{
     MEASURE;
     int32_t MeasureVolt;
     VOUT_PARA;
+    int32_t _MeasureBatvolt;
 }CVMode;
 
 CVMode * InitCVMode(){
@@ -388,7 +391,7 @@ CVMode * InitCVMode(){
     ret->_StepTime = INSTRUCTION.StepTime; // STEPTIME_ONE_SEC
     ret->_CycleNumber = INSTRUCTION.CycleNumber;
     ret->_VoVi_Switch = INSTRUCTION.VoVi_Switch;
-
+    ret->_MeasureBatvolt = 0;
 //    ret->SetVoltOut = &_SetVoltOut;
 //    ret->GetVoltOut = &_GetVoltOut;
 //    ret->SetVOrigin = &_SetVOrigin;
@@ -537,6 +540,7 @@ typedef union _WorkMode{
 //    CCCMode *CCC;
     PSMode *PS;
 
+    //test mode
     RVoutMode *RVout;
 }WorkMode;
 
@@ -572,7 +576,7 @@ void InitWorkMode(WorkMode *WM){
 //            WM->CCC = InitCCCMode();
 //            break;
         case READ_VOUT_VALUE:
-            WM->RVout = InitTVMode();
+            WM->RVout = InitRVoutMode();
             break;
         default:
             WM->VT = InitVTMode();

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

@@ -28,12 +28,12 @@ static void ZT_Plot(RTMode *RT) {
     }
 
 
-    volt_32 = User2Real(INSTRUCTION.VoltConstant)*1e4;
+    volt_32 = User2Real(INSTRUCTION.VoltConstant)*1e5;
 //    ReadVolt(SPIVolt);
 //    VoltMeasure = (uint16_t) (SPIVolt[0] << 8) | (uint16_t) (SPIVolt[1]);
 //    volt_32 = DecodeADCVolt(VoltMeasure)*1e4;
     resister_32 = volt_32 / current_32;
-    volt_32 = volt_32 / 1e4;
+    volt_32 = volt_32 / 1e2; //uV
 
     NotifyVolt[0] = (uint8_t) (volt_32 >> 24);
     NotifyVolt[1] = (uint8_t) ((volt_32 & 0x00FF0000) >> 16);

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

@@ -375,10 +375,11 @@ characteristic change event
 
 // product information
 #define DEVICE_NAME "Elite-ZM-v1.4-re"
-#define MAJOR_PRODUCT_NUMBER 0
-#define MINOR_PRODUCT_NUMBER 2
-#define MAJOR_VERSION_NUMBER 1
-#define MINOR_VERSION_NUMBER 2
+#define MAJOR_PRODUCT_NUMBER 0 //0:Elite ,1:Neulive
+#define MINOR_PRODUCT_NUMBER 2 //1:Elite_legacy(Ori_Neulive)  2:Elite_zm  3:Elite_bat
+#define MAJOR_VERSION_NUMBER 1 //1
+#define MINOR_VERSION_NUMBER 2 //2 (1.2:support 1.2~1.4-re)
+//0310 //bat1.0
 
 #define ELITE_VERSION_1_4
 //#define ELITE_VERSION_1_3
@@ -492,6 +493,7 @@ static uint8 channel_table[CHANNEL_COUNT] = {0};
  */
 static int8    channel_pointer            = -1;
 static uint8_t not_buf[BLE_DAT_BUFF_SIZE] = {0};
+static uint8_t cis_buf[BLE_CIS_BUFF_SIZE] = {0};
 
 /*=====================================
  ==== headstage function prototype ====
@@ -578,6 +580,8 @@ static void set_update_instruction_callback(update_instruction_callback_type cal
 #define VIS_SHIFT_200K 0b10100000
 #define VIS_SHIFT_10K 0b11100000
 #define VIS_SHIFT_200R 0b10000000
+#define VIS_DEVICE_SHINY 0b00010000
+#define VIS_SHINY_DIS 0b00100000
 
 // real instruction
 #define IV_CURVE 0b00010000
@@ -596,6 +600,7 @@ static void set_update_instruction_callback(update_instruction_callback_type cal
 #define CYCLE_CONSTANT_CURRENT 0b11110000
 
 // CIS instruction
+#define CIS_VERSION 0x40
 
 // test instruction
 #define ADC_TEST 0b10010000
@@ -698,6 +703,7 @@ static void TurnOn10V();
 #include "EliteCCCMode.h"
 #include "impedance_meter.h"
 #include "EliteReadVout.h"
+#include "headstage_version.h"
 
 // update instruction for Z meter
 static void update_ZM_instruction(uint8 *ins) {
@@ -733,6 +739,8 @@ static void update_ZM_instruction(uint8 *ins) {
 
             if (ins[7] | ins[8]) {
                 INSTRUCTION.Step = ((uint16_t)(ins[7]) << 8) | (uint16_t)(ins[8]);
+//                NotifyImpedance[2] = (uint8_t)((INSTRUCTION.Step & 0xFF00)>>8);
+//                NotifyImpedance[3] = (uint8_t)(INSTRUCTION.Step & 0x00FF);
                 INSTRUCTION.Step = StepCode2DACcode(INSTRUCTION.Step);
             }
 //            if (ins[9]) {
@@ -741,7 +749,7 @@ static void update_ZM_instruction(uint8 *ins) {
 //            }
 //            if(ins[10]) {
                 //INSTRUCTION.VoVi_Switch = ins[10];
-                INSTRUCTION.VoVi_Switch = 0x00;
+                INSTRUCTION.VoVi_Switch = 0x01;
 //            }
             break;
         }
@@ -822,7 +830,7 @@ static void update_ZM_instruction(uint8 *ins) {
 //            CleanBuffer();
             INSTRUCTION.eliteFxn = CV_CURVE;
             DACReset             = true;
-            INSTRUCTION.SampleRate = 500;
+            INSTRUCTION.SampleRate = 100;
 
 //            if (ins[3] | ins[4]) {
                 INSTRUCTION.VoltOrigin = ((uint16_t)(ins[3]) << 8) | (uint16_t)(ins[4]);
@@ -846,7 +854,7 @@ static void update_ZM_instruction(uint8 *ins) {
             }
 //            if(ins[11]) {
                 //INSTRUCTION.VoVi_Switch = ins[11];
-                INSTRUCTION.VoVi_Switch = 0x00;
+                INSTRUCTION.VoVi_Switch = 0x01;
 //            }
 
             break;
@@ -1076,6 +1084,31 @@ static void update_ZM_instruction(uint8 *ins) {
             break;
         }
 
+        case VIS_DEVICE_SHINY:{
+            LED_color(DARKLED, 0xFF, 0x00, 0xFF);
+//            uint8_t deviceShinySwitch = (ins[2] & 0b11110000) >> 4;//1:open 0:close
+//            if(deviceShinySwitch == 1){
+//                 LED_color(DARKLED, 0xFF, 0x00, 0xFF);
+//            }else if(deviceShinySwitch == 0){
+//                 if(PeriodicEvent){
+//                      WORKLED();
+//                 }else if(!PeriodicEvent){
+//                     LEDPowerON();
+//                 }
+//            }
+            break;
+        }
+
+        case VIS_SHINY_DIS:{
+             if(PeriodicEvent){
+                  WORKLED();
+             }else if(!PeriodicEvent){
+                 LEDPowerON();
+             }
+
+            break;
+        }
+
         default: {
             break;
         }
@@ -1089,6 +1122,19 @@ static void update_ZM_instruction(uint8 *ins) {
             I2CWrite(0x01, 0xAB);
             break;
         }
+
+        case CIS_VERSION:{
+            cis_buf[0] = VERSION_DATE_YEAR;
+            cis_buf[1] = VERSION_DATE_MONTH;
+            cis_buf[2] = VERSION_DATE_DAY;
+            cis_buf[3] = VERSION_DATE_HOUR;
+            cis_buf[4] = VERSION_DATE_MINUTE;
+
+            SimpleProfile_SetParameter(BLE_CIS_BUFF_CHAR, BLE_CIS_BUFF_SIZE, cis_buf);
+            break;
+        }
+
+
         }
         break;
     }

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

@@ -0,0 +1,11 @@
+
+#ifndef VERSION_DATE
+#define VERSION_DATE
+
+#define VERSION_DATE_YEAR       20
+#define VERSION_DATE_MONTH      2
+#define VERSION_DATE_DAY        25
+#define VERSION_DATE_HOUR       18
+#define VERSION_DATE_MINUTE     32
+
+#endif

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

@@ -277,7 +277,7 @@ static void EliteNotifyControl() {
 
 
 static uint16_t StepCode2DACcode(uint16_t StepCode){
-    return (StepCode * 0x0005);
+    return (StepCode * 0x0005 / 10);
 }
 
 static uint16_t OldStep2NewStepTime(uint8_t StepTime) {

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

@@ -632,6 +632,7 @@ static void SimpleBLEPeripheral_taskFxn(UArg a0, UArg a1) {
                         InitEliteInstruction();
                         ADCGainControl(INSTRUCTION.ADCGainLevel);
                         DAC_outputV(Usercode_Correction_to_DAC(INSTRUCTION.VoltConstant));
+
                         Free_Work_Mode = false;
                     }
                 } else {
@@ -648,8 +649,12 @@ static void SimpleBLEPeripheral_taskFxn(UArg a0, UArg a1) {
                 // Perform periodic application task
                 SimpleBLEPeripheral_performPeriodicTask(WorkModeData);
 
+                // Turn off Elite if battery  voltage < 3V
+//                ReadBatVolt(spi_ADC_rxbuf);
+
                 key = PIN_getInputValue(switch_on);
                 EliteKeyPress(key);  // onPress=> key = 0; 1.lighten LED 2.long press shut down 2650
+
             }
         }
 

update_elite_cali_data.sh

@@ -0,0 +1,91 @@
+#!/bin/bash
+
+#input="./Elite_test.txt"
+input="D:/Elite/Calibration_data/$1.txt"
+output="./simplelink/ble_sdk_2_02_02_25/src/examples/simple_peripheral/cc26xx/app/headstage/EliteDeviceCorrection.h"
+
+#variable
+declare -i current_line=79
+declare -i col_index=0
+declare -i row_index=0
+#declare -i coeff=1
+#declare -i offset=0
+
+declare -i current_gain=0
+#declare -i vin_gain=0
+#declare -i vout_gain=0
+MAC="MAC"
+
+#constant
+declare -i ADC_CURRENT_GAIN_NUMBER=3
+declare -i ADC_VOLTAGE_GAIN_NUMBER=1
+declare -i DAC_GAIN_NUMBER=1
+
+while read -r line; do
+    for word in $line; do
+        # get device MAC
+        if [ $row_index -eq 0 ] && [ $col_index -eq 1 ];then
+          MAC=$word
+          sed -i "${current_line} i  {" "$output"
+          sed -i "${current_line} i  \\\n#ifdef BOARD_${MAC}" "$output"
+          sed -i 's/:/_/g' "$output"
+          current_line=$current_line+3
+        fi
+
+        #get ADC current cali data
+        declare -i Iin_range=2+$ADC_CURRENT_GAIN_NUMBER
+        if [ $row_index -gt 1 ] && [ $row_index -lt $Iin_range ];then
+
+          if [ $col_index -eq 1 ];then
+            sed -i "${current_line} i \\\t.ADC_current[${current_gain}].coeff = ($word)," "$output"
+            current_line=$current_line+1
+
+          elif [ $col_index -eq 2 ];then
+            sed -i "${current_line} i \\\t.ADC_current[${current_gain}].offset = ($word)," "$output"
+            current_line=$current_line+1
+
+            if [ $current_gain -lt 2 ];then
+              current_gain=$current_gain+1
+            else
+              current_gain=0
+            fi
+          fi
+
+        #get DAC Vout cali data
+        declare -i Vout_range=$Iin_range+$DAC_GAIN_NUMBER
+        elif [ $row_index -gt 1 ] && [ $row_index -lt $Vout_range ];then
+          if [ $col_index -eq 1 ];then
+            sed -i "${current_line} i \\\t.Usercode2DAC.coeff = ($word)," "$output"
+            current_line=$current_line+1
+
+          elif [ $col_index -eq 2 ];then
+            sed -i "${current_line} i \\\t.Usercode2DAC.offset = ($word)," "$output"
+            current_line=$current_line+1
+          fi
+
+        #get ADC Vin cali data
+        declare -i Vin_range=$Vout_range+$ADC_VOLTAGE_GAIN_NUMBER
+        elif [ $row_index -gt 1 ] && [ $row_index -lt $Vin_range ];then
+          if [ $col_index -eq 1 ];then
+            sed -i "${current_line} i \\\t.ADC_volt.coeff = ($word)," "$output"
+            current_line=$current_line+1
+
+          elif [ $col_index -eq 2 ];then
+            sed -i "${current_line} i \\\t.ADC_volt.offset = ($word)," "$output"
+            current_line=$current_line+1
+          fi
+        fi
+
+        #update index
+        if [ $col_index -lt 2 ];then
+          col_index=$col_index+1
+        else
+          col_index=0
+          row_index=$row_index+1
+        fi
+    done
+done < $input
+
+sed -i "${current_line} i };" "$output"
+current_line=$current_line+1
+sed -i "${current_line} i #endif" "$output"