• State TI Thinks Resolved
  • Locked Locked
  • Replies 22 replies
  • Answers 2 answers
  • Subscribers 83 subscribers
  • Views 791 views
  • Users 0 members are here
Support feedback
Options
Options
Related

This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

TMS320F28388D: ADC B-C-D not sampling

Adrien Thurin
Intellectual 596 points

Part Number: TMS320F28388D
Other Parts Discussed in Thread: SYSCONFIG, TMDSCNCD28388D

Hi,

I am developping a battery charger using an F28388D. However, for some strange reason, I can't get ADC B, C and D to work. I have checked everything I can think of, and I don't see any significant configuration difference between ADCs, and yet only ADC A returns results. I have checked voltage on the pins of the controlcard I am using, the signal is there (and even if it wasn't, I should see some noise on the ADCRESULT).

(Note : despite using an F28388D, I use only core 1, and only run the CPU1 project)

ADC A configuration : 

image.png

ADC B configuration : 

image.png

All ADCs are powered : 

image.png

Core allocation of the ADCs : all CPU1

image.png

Any idea what could go wrong ?

Thanks in advance,

Best regards,

Adrien

  • 0
    TI__Expert 8370 points

    Hello,

    Can you share a short format of SysConfig file? I don't see the missing part in the provided screenshots.

    Best Regards,

    Masoud

  • 0 in reply to Masoud Farhadi
    Intellectual 596 points

    Hello,

    Here is the Sysconfig file

    /**
 * These arguments were used when this file was generated. They will be automatically applied on subsequent loads
 * via the GUI or CLI. Run CLI with '--help' for additional information on how to override these arguments.
 * @cliArgs --device "F2838x" --part "F2838x_337bga" --package "337bga" --context "CPU1" --product "C2000WARE@5.04.00.00"
 * @v2CliArgs --device "TMS320F28388D" --package "337bga" --context "CPU1" --product "C2000WARE@5.04.00.00"
 * @versions {"tool":"1.24.1+4189"}
 */

/**
 * Import the modules used in this configuration.
 */
const adc     = scripting.addModule("/driverlib/adc.js");
const adc1    = adc.addInstance();
const adc2    = adc.addInstance();
const adc3    = adc.addInstance();
const adc4    = adc.addInstance();
const asysctl = scripting.addModule("/driverlib/asysctl.js");
const cla     = scripting.addModule("/driverlib/cla.js", {}, false);
const cla1    = cla.addInstance();
const epwm    = scripting.addModule("/driverlib/epwm.js", {}, false);
const epwm1   = epwm.addInstance();
const epwm2   = epwm.addInstance();
const epwm3   = epwm.addInstance();
const epwm4   = epwm.addInstance();
const epwm5   = epwm.addInstance();
const epwm6   = epwm.addInstance();
const flash   = scripting.addModule("/driverlib/flash.js", {}, false);
const flash1  = flash.addInstance();
const gpio    = scripting.addModule("/driverlib/gpio.js", {}, false);
const gpio1   = gpio.addInstance();
const gpio2   = gpio.addInstance();
const gpio3   = gpio.addInstance();
const gpio4   = gpio.addInstance();
const gpio5   = gpio.addInstance();
const gpio6   = gpio.addInstance();
const gpio7   = gpio.addInstance();
const gpio8   = gpio.addInstance();
const gpio9   = gpio.addInstance();
const gpio10  = gpio.addInstance();
const gpio11  = gpio.addInstance();
const gpio12  = gpio.addInstance();
const gpio13  = gpio.addInstance();
const gpio14  = gpio.addInstance();
const gpio15  = gpio.addInstance();
const gpio16  = gpio.addInstance();
const gpio17  = gpio.addInstance();
const gpio18  = gpio.addInstance();
const gpio19  = gpio.addInstance();
const gpio20  = gpio.addInstance();
const gpio21  = gpio.addInstance();
const gpio22  = gpio.addInstance();
const gpio23  = gpio.addInstance();
const gpio24  = gpio.addInstance();
const ipc     = scripting.addModule("/driverlib/ipc.js");
const memcfg  = scripting.addModule("/driverlib/memcfg.js");
const sysctl  = scripting.addModule("/driverlib/sysctl.js");
const sfo     = scripting.addModule("/libraries/calibration/hrpwm/sfo.js", {}, false);
const sfo1    = sfo.addInstance();

/**
 * Write custom configuration values to the imported modules.
 */
adc1.adcClockPrescaler  = "ADC_CLK_DIV_4_0";
adc1.soc0SampleWindow   = 64;
adc1.registerInterrupts = ["1"];
adc1.useInterrupts      = false;
adc1.soc1SampleWindow   = 64;
adc1.soc2SampleWindow   = 64;
adc1.soc2Channel        = "ADC_CH_ADCIN3";
adc1.soc3SampleWindow   = 64;
adc1.soc4Channel        = "ADC_CH_ADCIN4";
adc1.soc4SampleWindow   = 64;
adc1.soc4Trigger        = "ADC_TRIGGER_EPWM5_SOCA";
adc1.soc4Name           = "Vbatlvlp";
adc1.$name              = "MESURE_TENSION_1";
adc1.soc0Channel        = "ADC_CH_ADCIN5";
adc1.soc0Trigger        = "ADC_TRIGGER_EPWM1_SOCA";
adc1.soc1Name           = "V_PFC";
adc1.soc0Name           = "V_AC";
adc1.soc1Channel        = "ADC_CH_ADCIN4";
adc1.soc1Trigger        = "ADC_TRIGGER_EPWM1_SOCA";
adc1.soc2Name           = "V_BAT48";
adc1.soc2Trigger        = "ADC_TRIGGER_EPWM3_SOCA";
adc1.soc3Name           = "V_BAT12";
adc1.soc3Channel        = "ADC_CH_ADCIN2";
adc1.enabledSOCs        = ["ADC_SOC_NUMBER0","ADC_SOC_NUMBER1","ADC_SOC_NUMBER2","ADC_SOC_NUMBER3"];
adc1.soc3Trigger        = "ADC_TRIGGER_EPWM7_SOCA";

adc2.adcClockPrescaler   = "ADC_CLK_DIV_4_0";
adc2.soc2SampleWindow    = 64;
adc2.soc1SampleWindow    = 64;
adc2.soc0SampleWindow    = 64;
adc2.registerInterrupts  = ["1"];
adc2.soc1Name            = "Idp";
adc2.soc1Channel         = "ADC_CH_ADCIN1";
adc2.soc1Trigger         = "ADC_TRIGGER_EPWM5_SOCA";
adc2.soc2Name            = "T_Amb";
adc2.soc2Channel         = "ADC_CH_ADCIN2";
adc2.soc2Trigger         = "ADC_TRIGGER_EPWM4_SOCA";
adc2.soc3Name            = "T_spare";
adc2.soc3Channel         = "ADC_CH_ADCIN3";
adc2.soc3Trigger         = "ADC_TRIGGER_EPWM5_SOCA";
adc2.soc3SampleWindow    = 64;
adc2.enabledInts         = ["ADC_INT_NUMBER1","ADC_INT_NUMBER2"];
adc2.interrupt2SOCSource = "ADC_SOC_NUMBER1";
adc2.soc4Channel         = "ADC_CH_ADCIN4";
adc2.soc4Trigger         = "ADC_TRIGGER_EPWM5_SOCA";
adc2.soc4SampleWindow    = 64;
adc2.$name               = "MESURE_TENSION_2";
adc2.enabledSOCs         = ["ADC_SOC_NUMBER0"];
adc2.soc0Name            = "V_BAT12_LP";
adc2.soc0Channel         = "ADC_CH_ADCIN2";
adc2.useInterrupts       = false;
adc2.adcBase             = "ADCB_BASE";
adc2.soc0Trigger         = "ADC_TRIGGER_EPWM1_SOCA";

adc3.registerInterrupts             = ["1"];
adc3.soc2Trigger                    = "ADC_TRIGGER_EPWM1_SOCA";
adc3.soc3SampleWindow               = 64;
adc3.soc3Trigger                    = "ADC_TRIGGER_EPWM1_SOCA";
adc3.soc3Channel                    = "ADC_CH_ADCIN1";
adc3.$name                          = "MESURE_COURANT";
adc3.soc0Name                       = "I_DP";
adc3.soc0Channel                    = "ADC_CH_ADCIN4";
adc3.soc0Trigger                    = "ADC_TRIGGER_EPWM7_SOCA";
adc3.soc1Name                       = "I_PSFB";
adc3.soc1Channel                    = "ADC_CH_ADCIN3";
adc3.soc1Trigger                    = "ADC_TRIGGER_EPWM3_SOCA";
adc3.soc2Name                       = "I_PFC";
adc3.soc2Channel                    = "ADC_CH_ADCIN2";
adc3.enabledSOCs                    = ["ADC_SOC_NUMBER0","ADC_SOC_NUMBER1","ADC_SOC_NUMBER2"];
adc3.enabledInts                    = ["ADC_INT_NUMBER1","ADC_INT_NUMBER2","ADC_INT_NUMBER3"];
adc3.enableInterrupt1               = true;
adc3.enableInterrupt1ContinuousMode = true;
adc3.enableInterrupt2               = true;
adc3.enableInterrupt2ContinuousMode = true;
adc3.interrupt2SOCSource            = "ADC_SOC_NUMBER1";
adc3.enableInterrupt3               = true;
adc3.enableInterrupt3ContinuousMode = true;
adc3.interrupt3SOCSource            = "ADC_SOC_NUMBER2";
adc3.soc0SampleWindow               = 15;
adc3.soc1SampleWindow               = 15;
adc3.soc2SampleWindow               = 15;
adc3.adcClockPrescaler              = "ADC_CLK_DIV_4_0";
adc3.adcBase                        = "ADCC_BASE";
adc3.adcInt1.interruptHandler       = "INT_Regulation_ISR";
adc3.adcInt1.enableInterrupt        = true;

adc4.adcClockPrescaler  = "ADC_CLK_DIV_4_0";
adc4.enabledSOCs        = ["ADC_SOC_NUMBER0","ADC_SOC_NUMBER1","ADC_SOC_NUMBER2"];
adc4.soc2SampleWindow   = 64;
adc4.soc1SampleWindow   = 64;
adc4.soc0SampleWindow   = 64;
adc4.soc2Trigger        = "ADC_TRIGGER_EPWM1_SOCA";
adc4.soc1Trigger        = "ADC_TRIGGER_EPWM1_SOCA";
adc4.soc0Trigger        = "ADC_TRIGGER_EPWM1_SOCA";
adc4.soc1Name           = "T_Cool_In";
adc4.soc2Name           = "T_Cool_Out";
adc4.enabledInts        = ["ADC_INT_NUMBER1"];
adc4.registerInterrupts = ["1"];
adc4.$name              = "MESURE_TEMPERATURE";
adc4.adcBase            = "ADCD_BASE";
adc4.useInterrupts      = false;
adc4.soc1Channel        = "ADC_CH_ADCIN1";
adc4.soc2Channel        = "ADC_CH_ADCIN2";
adc4.soc0Name           = "T_spare";
adc4.soc0Channel        = "ADC_CH_ADCIN3";

cla1.$name              = "CLA_CPU1";
cla1.enable_CLA_TASK_4  = false;
cla1.enable_CLA_TASK_6  = false;
cla1.enable_CLA_TASK_5  = false;
cla1.enable_CLA_TASK_7  = false;
cla1.cpuint_CLA_TASK_1  = false;
cla1.cpuint_CLA_TASK_2  = false;
cla1.cpuint_CLA_TASK_3  = false;
cla1.cpuint_CLA_TASK_5  = false;
cla1.cpuint_CLA_TASK_4  = false;
cla1.cpuint_CLA_TASK_6  = false;
cla1.cpuint_CLA_TASK_7  = false;
cla1.cpuint_CLA_TASK_8  = false;
cla1.trigger_CLA_TASK_1 = "CLA_TRIGGER_ADCB1";
cla1.trigger_CLA_TASK_2 = "CLA_TRIGGER_ADCB2";
cla1.trigger_CLA_TASK_3 = "CLA_TRIGGER_ADCB3";
cla1.enable_CLA_TASK_3  = false;

const divider14       = system.clockTree["PLL_REFDIV"];
divider14.divideValue = 1;

const mux15       = system.clockTree["OSCCLKSRCSEL"];
mux15.inputSelect = "INTOSC1";

epwm1.copyFrom                                                   = "PWM_PFC";
epwm1.epwmTimebase_emulationMode                                 = "EPWM_EMULATION_FREE_RUN";
epwm1.epwmTimebase_counterMode                                   = "EPWM_COUNTER_MODE_UP_DOWN";
epwm1.epwmTimebase_counterModeAfterSync                          = "EPWM_COUNT_MODE_UP_AFTER_SYNC";
epwm1.epwmTimebase_syncOutPulseMode                              = ["EPWM_SYNC_OUT_PULSE_ON_CNTR_ZERO"];
epwm1.hrpwm_syncSource                                           = "HRPWM_PWMSYNC_SOURCE_ZERO";
epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPB   = "EPWM_AQ_OUTPUT_HIGH";
epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_DOWN_CMPB = "EPWM_AQ_OUTPUT_LOW";
epwm1.epwmEventTrigger_EPWM_SOC_A_triggerEnable                  = true;
epwm1.epwmEventTrigger_EPWM_SOC_A_triggerSource                  = "EPWM_SOC_TBCTR_ZERO";
epwm1.epwmEventTrigger_EPWM_SOC_A_triggerEventPrescalar          = "1";
epwm1.hrpwm_cmpaHR                                               = 50;
epwm1.hrpwm_edgeModeB                                            = "HRPWM_MEP_CTRL_RISING_EDGE";
epwm1.hrpwm_cmpbHR                                               = 50;
epwm1.epwmTimebase_period                                        = 192;
epwm1.$name                                                      = "PWM_DP";
epwm1.epwmCounterCompare_cmpB                                    = 192;
epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_DOWN_CMPA = "EPWM_AQ_OUTPUT_HIGH";
epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA   = "EPWM_AQ_OUTPUT_LOW";
epwm1.hrpwm_edgeModeA                                            = "HRPWM_MEP_CTRL_FALLING_EDGE";
epwm1.epwm.$assign                                               = "EPWM7";
epwm1.epwm.epwm_aPin.$assign                                     = "GPIO12";
epwm1.epwm.epwm_bPin.$assign                                     = "GPIO13";

epwm2.epwmTimebase_emulationMode                                 = "EPWM_EMULATION_FREE_RUN";
epwm2.epwmTimebase_counterMode                                   = "EPWM_COUNTER_MODE_UP_DOWN";
epwm2.epwmTimebase_counterModeAfterSync                          = "EPWM_COUNT_MODE_UP_AFTER_SYNC";
epwm2.epwmTimebase_syncOutPulseMode                              = ["EPWM_SYNC_OUT_PULSE_ON_CNTR_ZERO"];
epwm2.hrpwm_syncSource                                           = "HRPWM_PWMSYNC_SOURCE_ZERO";
epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPB   = "EPWM_AQ_OUTPUT_HIGH";
epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_DOWN_CMPB = "EPWM_AQ_OUTPUT_LOW";
epwm2.epwmTimebase_periodLink                                    = "EPWM_LINK_WITH_EPWM_1";
epwm2.epwmTimebase_period                                        = 384;
epwm2.hrpwm_cmpbHR                                               = 50;
epwm2.epwmEventTrigger_EPWM_SOC_A_triggerEnable                  = true;
epwm2.epwmEventTrigger_EPWM_SOC_A_triggerSource                  = "EPWM_SOC_TBCTR_ZERO";
epwm2.epwmEventTrigger_EPWM_SOC_A_triggerEventPrescalar          = "1";
epwm2.hrpwm_edgeModeB                                            = "HRPWM_MEP_CTRL_RISING_EDGE";
epwm2.epwmCounterCompare_cmpB                                    = 384;
epwm2.$name                                                      = "PWM_PFC_HF";
epwm2.epwmTimebase_hsClockDiv                                    = "EPWM_HSCLOCK_DIVIDER_1";
epwm2.hrpwm_cmpaHR                                               = 50;
epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA   = "EPWM_AQ_OUTPUT_LOW";
epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_DOWN_CMPA = "EPWM_AQ_OUTPUT_HIGH";
epwm2.hrpwm_edgeModeA                                            = "HRPWM_MEP_CTRL_FALLING_EDGE";
epwm2.hrpwm_enable                                               = true;
epwm2.epwm.$assign                                               = "EPWM1";
epwm2.epwm.epwm_aPin.$assign                                     = "GPIO0";
epwm2.epwm.epwm_bPin.$assign                                     = "GPIO1";

epwm3.epwmTimebase_emulationMode                                 = "EPWM_EMULATION_FREE_RUN";
epwm3.epwmTimebase_counterMode                                   = "EPWM_COUNTER_MODE_UP_DOWN";
epwm3.epwmTimebase_counterModeAfterSync                          = "EPWM_COUNT_MODE_UP_AFTER_SYNC";
epwm3.epwmTimebase_syncOutPulseMode                              = ["EPWM_SYNC_OUT_PULSE_ON_CNTR_ZERO"];
epwm3.hrpwm_syncSource                                           = "HRPWM_PWMSYNC_SOURCE_ZERO";
epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA   = "EPWM_AQ_OUTPUT_LOW";
epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_DOWN_CMPA = "EPWM_AQ_OUTPUT_HIGH";
epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPB   = "EPWM_AQ_OUTPUT_HIGH";
epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_DOWN_CMPB = "EPWM_AQ_OUTPUT_LOW";
epwm3.epwmEventTrigger_EPWM_SOC_A_triggerEnable                  = true;
epwm3.epwmEventTrigger_EPWM_SOC_A_triggerSource                  = "EPWM_SOC_TBCTR_ZERO";
epwm3.epwmEventTrigger_EPWM_SOC_A_triggerEventPrescalar          = "1";
epwm3.hrpwm_edgeModeA                                            = "HRPWM_MEP_CTRL_FALLING_EDGE";
epwm3.hrpwm_cmpaHR                                               = 50;
epwm3.hrpwm_edgeModeB                                            = "HRPWM_MEP_CTRL_RISING_EDGE";
epwm3.hrpwm_cmpbHR                                               = 50;
epwm3.copyFrom                                                   = "PWM_TDC_2";
epwm3.epwmTimebase_counterValue                                  = 1;
epwm3.$name                                                      = "PWM_PSFB_LEAD";
epwm3.epwmTimebase_period                                        = 384;
epwm3.epwmTimebase_syncInPulseSource                             = "EPWM_SYNC_IN_PULSE_SRC_DISABLE";
epwm3.epwmCounterCompare_cmpA                                    = 192;
epwm3.epwmCounterCompare_cmpB                                    = 192;
epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_A_shadowMode            = true;
epwm3.epwmDeadband_polarityFED                                   = "EPWM_DB_POLARITY_ACTIVE_LOW";
epwm3.epwmDeadband_enableRED                                     = true;
epwm3.epwmDeadband_enableFED                                     = true;
epwm3.epwmDeadband_delayRED                                      = 10;
epwm3.epwmDeadband_delayFED                                      = 10;
epwm3.hrpwm_enable                                               = true;
epwm3.hrpwm_autoConv                                             = true;
epwm3.hrpwm_controlModeA                                         = "HRPWM_MEP_PHASE_CTRL";
epwm3.hrpwm_controlModeB                                         = "HRPWM_MEP_PHASE_CTRL";
epwm3.epwmTimebase_forceSyncPulse                                = true;
epwm3.epwm.$assign                                               = "EPWM3";
epwm3.epwm.epwm_aPin.$assign                                     = "GPIO4";
epwm3.epwm.epwm_bPin.$assign                                     = "GPIO5";

epwm4.epwmTimebase_emulationMode                                 = "EPWM_EMULATION_FREE_RUN";
epwm4.epwmTimebase_counterMode                                   = "EPWM_COUNTER_MODE_UP_DOWN";
epwm4.epwmTimebase_syncOutPulseMode                              = ["EPWM_SYNC_OUT_PULSE_ON_CNTR_ZERO"];
epwm4.hrpwm_syncSource                                           = "HRPWM_PWMSYNC_SOURCE_ZERO";
epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA   = "EPWM_AQ_OUTPUT_LOW";
epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_DOWN_CMPA = "EPWM_AQ_OUTPUT_HIGH";
epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPB   = "EPWM_AQ_OUTPUT_HIGH";
epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_DOWN_CMPB = "EPWM_AQ_OUTPUT_LOW";
epwm4.epwmEventTrigger_EPWM_SOC_A_triggerEnable                  = true;
epwm4.epwmEventTrigger_EPWM_SOC_A_triggerSource                  = "EPWM_SOC_TBCTR_ZERO";
epwm4.epwmEventTrigger_EPWM_SOC_A_triggerEventPrescalar          = "1";
epwm4.hrpwm_edgeModeA                                            = "HRPWM_MEP_CTRL_FALLING_EDGE";
epwm4.hrpwm_cmpaHR                                               = 50;
epwm4.hrpwm_edgeModeB                                            = "HRPWM_MEP_CTRL_RISING_EDGE";
epwm4.hrpwm_cmpbHR                                               = 50;
epwm4.copyFrom                                                   = "PWM_TDC_2";
epwm4.epwmTimebase_counterValue                                  = 1;
epwm4.epwmTimebase_period                                        = 384;
epwm4.epwmCounterCompare_cmpA                                    = 192;
epwm4.epwmCounterCompare_cmpB                                    = 192;
epwm4.epwmActionQualifier_EPWM_AQ_OUTPUT_A_shadowMode            = true;
epwm4.epwmDeadband_polarityFED                                   = "EPWM_DB_POLARITY_ACTIVE_LOW";
epwm4.epwmDeadband_enableRED                                     = true;
epwm4.epwmDeadband_enableFED                                     = true;
epwm4.epwmDeadband_delayRED                                      = 10;
epwm4.epwmDeadband_delayFED                                      = 10;
epwm4.hrpwm_controlModeA                                         = "HRPWM_MEP_PHASE_CTRL";
epwm4.hrpwm_controlModeB                                         = "HRPWM_MEP_PHASE_CTRL";
epwm4.$name                                                      = "PWM_PSFB_DELAYED";
epwm4.epwmTimebase_syncInPulseSource                             = "EPWM_SYNC_IN_PULSE_SRC_SYNCOUT_EPWM3";
epwm4.epwmTimebase_periodLink                                    = "EPWM_LINK_WITH_EPWM_3";
epwm4.epwmTimebase_forceSyncPulse                                = true;
epwm4.epwmTimebase_phaseEnable                                   = true;
epwm4.epwmTimebase_phaseShift                                    = 1;
epwm4.hrpwm_phaseLoadEnable                                      = true;
epwm4.hrpwm_enable                                               = true;
epwm4.hrpwm_tbphsHR                                              = 1;
epwm4.hrpwm_autoConv                                             = true;
epwm4.epwm.$assign                                               = "EPWM4";
epwm4.epwm.epwm_aPin.$assign                                     = "GPIO6";
epwm4.epwm.epwm_bPin.$assign                                     = "GPIO7";

epwm5.epwmTimebase_emulationMode                                 = "EPWM_EMULATION_FREE_RUN";
epwm5.epwmTimebase_counterMode                                   = "EPWM_COUNTER_MODE_UP_DOWN";
epwm5.epwmTimebase_syncOutPulseMode                              = ["EPWM_SYNC_OUT_PULSE_ON_CNTR_ZERO"];
epwm5.hrpwm_syncSource                                           = "HRPWM_PWMSYNC_SOURCE_ZERO";
epwm5.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA   = "EPWM_AQ_OUTPUT_LOW";
epwm5.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_DOWN_CMPA = "EPWM_AQ_OUTPUT_HIGH";
epwm5.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPB   = "EPWM_AQ_OUTPUT_HIGH";
epwm5.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_DOWN_CMPB = "EPWM_AQ_OUTPUT_LOW";
epwm5.epwmEventTrigger_EPWM_SOC_A_triggerEnable                  = true;
epwm5.epwmEventTrigger_EPWM_SOC_A_triggerSource                  = "EPWM_SOC_TBCTR_ZERO";
epwm5.epwmEventTrigger_EPWM_SOC_A_triggerEventPrescalar          = "1";
epwm5.hrpwm_edgeModeA                                            = "HRPWM_MEP_CTRL_FALLING_EDGE";
epwm5.hrpwm_cmpaHR                                               = 50;
epwm5.hrpwm_edgeModeB                                            = "HRPWM_MEP_CTRL_RISING_EDGE";
epwm5.hrpwm_cmpbHR                                               = 50;
epwm5.epwmTimebase_phaseEnable                                   = true;
epwm5.copyFrom                                                   = "PWM_TDC_2";
epwm5.epwmTimebase_phaseShift                                    = 1;
epwm5.epwmTimebase_counterValue                                  = 1;
epwm5.epwmTimebase_period                                        = 384;
epwm5.epwmCounterCompare_cmpA                                    = 192;
epwm5.epwmCounterCompare_cmpB                                    = 192;
epwm5.epwmActionQualifier_EPWM_AQ_OUTPUT_A_shadowMode            = true;
epwm5.epwmDeadband_polarityFED                                   = "EPWM_DB_POLARITY_ACTIVE_LOW";
epwm5.epwmDeadband_enableRED                                     = true;
epwm5.epwmDeadband_enableFED                                     = true;
epwm5.epwmDeadband_delayRED                                      = 10;
epwm5.epwmDeadband_delayFED                                      = 10;
epwm5.hrpwm_controlModeA                                         = "HRPWM_MEP_PHASE_CTRL";
epwm5.hrpwm_controlModeB                                         = "HRPWM_MEP_PHASE_CTRL";
epwm5.epwmTimebase_syncInPulseSource                             = "EPWM_SYNC_IN_PULSE_SRC_SYNCOUT_EPWM3";
epwm5.$name                                                      = "PWM_PSFB_SEC_1";
epwm5.epwmTimebase_periodLink                                    = "EPWM_LINK_WITH_EPWM_3";
epwm5.epwmTimebase_forceSyncPulse                                = true;
epwm5.hrpwm_phaseLoadEnable                                      = true;
epwm5.hrpwm_enable                                               = true;
epwm5.hrpwm_autoConv                                             = true;
epwm5.epwm.$assign                                               = "EPWM5";
epwm5.epwm.epwm_aPin.$assign                                     = "GPIO8";
epwm5.epwm.epwm_bPin.$assign                                     = "GPIO9";

epwm6.epwmTimebase_emulationMode                                 = "EPWM_EMULATION_FREE_RUN";
epwm6.epwmTimebase_counterMode                                   = "EPWM_COUNTER_MODE_UP_DOWN";
epwm6.epwmTimebase_syncOutPulseMode                              = ["EPWM_SYNC_OUT_PULSE_ON_CNTR_ZERO"];
epwm6.hrpwm_syncSource                                           = "HRPWM_PWMSYNC_SOURCE_ZERO";
epwm6.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA   = "EPWM_AQ_OUTPUT_LOW";
epwm6.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_DOWN_CMPA = "EPWM_AQ_OUTPUT_HIGH";
epwm6.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPB   = "EPWM_AQ_OUTPUT_HIGH";
epwm6.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_DOWN_CMPB = "EPWM_AQ_OUTPUT_LOW";
epwm6.epwmEventTrigger_EPWM_SOC_A_triggerEnable                  = true;
epwm6.epwmEventTrigger_EPWM_SOC_A_triggerSource                  = "EPWM_SOC_TBCTR_ZERO";
epwm6.epwmEventTrigger_EPWM_SOC_A_triggerEventPrescalar          = "1";
epwm6.hrpwm_edgeModeA                                            = "HRPWM_MEP_CTRL_FALLING_EDGE";
epwm6.hrpwm_cmpaHR                                               = 50;
epwm6.hrpwm_edgeModeB                                            = "HRPWM_MEP_CTRL_RISING_EDGE";
epwm6.hrpwm_cmpbHR                                               = 50;
epwm6.epwmTimebase_phaseEnable                                   = true;
epwm6.copyFrom                                                   = "PWM_TDC_2";
epwm6.epwmTimebase_phaseShift                                    = 1;
epwm6.epwmTimebase_counterValue                                  = 1;
epwm6.epwmTimebase_period                                        = 384;
epwm6.epwmCounterCompare_cmpA                                    = 192;
epwm6.epwmCounterCompare_cmpB                                    = 192;
epwm6.epwmActionQualifier_EPWM_AQ_OUTPUT_A_shadowMode            = true;
epwm6.epwmDeadband_polarityFED                                   = "EPWM_DB_POLARITY_ACTIVE_LOW";
epwm6.epwmDeadband_enableRED                                     = true;
epwm6.epwmDeadband_enableFED                                     = true;
epwm6.epwmDeadband_delayRED                                      = 10;
epwm6.epwmDeadband_delayFED                                      = 10;
epwm6.hrpwm_controlModeA                                         = "HRPWM_MEP_PHASE_CTRL";
epwm6.hrpwm_controlModeB                                         = "HRPWM_MEP_PHASE_CTRL";
epwm6.epwmTimebase_syncInPulseSource                             = "EPWM_SYNC_IN_PULSE_SRC_SYNCOUT_EPWM3";
epwm6.$name                                                      = "PWM_PSFB_SEC_2";
epwm6.epwmTimebase_periodLink                                    = "EPWM_LINK_WITH_EPWM_3";
epwm6.epwmTimebase_forceSyncPulse                                = true;
epwm6.hrpwm_phaseLoadEnable                                      = true;
epwm6.hrpwm_enable                                               = true;
epwm6.hrpwm_autoConv                                             = true;
epwm6.epwm.$assign                                               = "EPWM6";
epwm6.epwm.epwm_aPin.$assign                                     = "GPIO10";
epwm6.epwm.epwm_bPin.$assign                                     = "GPIO11";

flash1.$name = "myFMC0";

gpio1.direction         = "GPIO_DIR_MODE_OUT";
gpio1.writeInitialValue = true;
gpio1.$name             = "CMD_RLY_32A";
gpio1.gpioPin.$assign   = "GPIO14";

gpio2.$name             = "CMD_RLY_PRECH";
gpio2.direction         = "GPIO_DIR_MODE_OUT";
gpio2.writeInitialValue = true;
gpio2.gpioPin.$assign   = "GPIO15";

gpio3.$name             = "DRIVER_ENABLE";
gpio3.direction         = "GPIO_DIR_MODE_OUT";
gpio3.writeInitialValue = true;
gpio3.gpioPin.$assign   = "GPIO39";

gpio4.$name           = "OVP_VAC";
gpio4.gpioPin.$assign = "GPIO75";

gpio5.$name           = "OVP_VBAT48";
gpio5.gpioPin.$assign = "GPIO76";

gpio6.$name           = "OVP_VBAT12";
gpio6.gpioPin.$assign = "GPIO77";

gpio7.$name           = "OCP_IAC";
gpio7.gpioPin.$assign = "GPIO78";

gpio8.$name           = "OCP_IPSFB";
gpio8.gpioPin.$assign = "GPIO79";

gpio9.$name           = "OCP_IHB";
gpio9.gpioPin.$assign = "GPIO80";

gpio10.$name           = "OTP";
gpio10.gpioPin.$assign = "GPIO81";

gpio11.$name             = "FAULT_CLEAR";
gpio11.direction         = "GPIO_DIR_MODE_OUT";
gpio11.writeInitialValue = true;
gpio11.gpioPin.$assign   = "GPIO82";

gpio12.$name             = "LED_ORANGE_1";
gpio12.direction         = "GPIO_DIR_MODE_OUT";
gpio12.writeInitialValue = true;
gpio12.gpioPin.$assign   = "GPIO50";

gpio13.$name             = "LED_ORANGE_2";
gpio13.direction         = "GPIO_DIR_MODE_OUT";
gpio13.writeInitialValue = true;
gpio13.gpioPin.$assign   = "GPIO51";

gpio14.$name             = "LED_JAUNE_1";
gpio14.direction         = "GPIO_DIR_MODE_OUT";
gpio14.writeInitialValue = true;
gpio14.gpioPin.$assign   = "GPIO52";

gpio15.$name             = "LED_JAUNE_2";
gpio15.direction         = "GPIO_DIR_MODE_OUT";
gpio15.writeInitialValue = true;
gpio15.gpioPin.$assign   = "GPIO53";

gpio16.$name             = "LED_VERTE_1";
gpio16.direction         = "GPIO_DIR_MODE_OUT";
gpio16.writeInitialValue = true;
gpio16.gpioPin.$assign   = "GPIO54";

gpio17.$name             = "LED_VERTE_2";
gpio17.direction         = "GPIO_DIR_MODE_OUT";
gpio17.writeInitialValue = true;
gpio17.controllerCore    = "GPIO_CORE_CPU2";
gpio17.gpioPin.$assign   = "GPIO55";

gpio18.$name             = "LED_ROUGE_1";
gpio18.direction         = "GPIO_DIR_MODE_OUT";
gpio18.writeInitialValue = true;
gpio18.gpioPin.$assign   = "GPIO56";

gpio19.$name             = "LED_ROUGE_2";
gpio19.direction         = "GPIO_DIR_MODE_OUT";
gpio19.writeInitialValue = true;
gpio19.gpioPin.$assign   = "GPIO63";

gpio20.direction         = "GPIO_DIR_MODE_OUT";
gpio20.writeInitialValue = true;
gpio20.$name             = "PWM_PFC_LF_HS";
gpio20.gpioPin.$assign   = "GPIO2";

gpio21.$name           = "PWM_PFC_LF_LS";
gpio21.direction       = "GPIO_DIR_MODE_OUT";
gpio21.gpioPin.$assign = "GPIO3";

gpio22.$name             = "CMD_VENT";
gpio22.direction         = "GPIO_DIR_MODE_OUT";
gpio22.writeInitialValue = true;
gpio22.gpioPin.$assign   = "GPIO92";

gpio23.$name           = "HVIL_E";
gpio23.gpioPin.$assign = "GPIO23";

gpio24.$name           = "HVIL_R";
gpio24.gpioPin.$assign = "GPIO24";

memcfg.init_MEMCFG_SECT_MSGCPUTOCLA1 = true;
memcfg.init_MEMCFG_SECT_MSGCLA1TOCPU = true;
memcfg.init_MEMCFG_SECT_MSGCPUTOCPU0 = true;
memcfg.init_MEMCFG_SECT_MSGCLA1TODMA = true;
memcfg.init_MEMCFG_SECT_MSGDMATOCLA1 = true;
memcfg.init_MEMCFG_SECT_MSGCPUTOCPU1 = true;
memcfg.init_MEMCFG_SECT_MSGCPUTOCM0  = true;
memcfg.init_MEMCFG_SECT_MSGCPUTOCM1  = true;
memcfg.config_MEMCFG_SECT_LS0        = "CLA_data";
memcfg.config_MEMCFG_SECT_LS1        = "CLA_data";
memcfg.config_MEMCFG_SECT_LS5        = "CLA_prog";
memcfg.config_MEMCFG_SECT_GS0        = "MEMCFG_GSRAMCONTROLLER_CPU2";
memcfg.config_MEMCFG_SECT_GS14       = "MEMCFG_GSRAMCONTROLLER_CPU2";

sysctl.enable_SYSCTL_PERIPH_CLK_TIMER1    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_TIMER2    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CPUBGCRC  = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CLA1BGCRC = false;
sysctl.enable_SYSCTL_PERIPH_CLK_ERAD      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EMIF1     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EMIF2     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_ECAP1     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_ECAP2     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_ECAP3     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_ECAP4     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_ECAP5     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_ECAP6     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_ECAP7     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EQEP1     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EQEP2     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EQEP3     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_SD1       = false;
sysctl.enable_SYSCTL_PERIPH_CLK_SD2       = false;
sysctl.enable_SYSCTL_PERIPH_CLK_SCIA      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_SCIB      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_SCIC      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_SCID      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_SPIA      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_SPIB      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_SPIC      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_SPID      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_I2CA      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_I2CB      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CANA      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CANB      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_MCANA     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_MCBSPA    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_MCBSPB    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_USBA      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CMPSS1    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CMPSS2    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CMPSS3    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CMPSS4    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CMPSS5    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CMPSS6    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CMPSS7    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CMPSS8    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_DACC      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CLB1      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CLB2      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CLB3      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CLB4      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CLB5      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CLB6      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CLB7      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CLB8      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_FSITXA    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_FSITXB    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_FSIRXA    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_FSIRXB    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_FSIRXC    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_FSIRXD    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_FSIRXE    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_FSIRXF    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_FSIRXG    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_FSIRXH    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_PMBUSA    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_MPOSTCLK  = false;
sysctl.enable_SYSCTL_PERIPH_CLK_ECAT      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_DCC0      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_DCC1      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_DCC2      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EPWM8     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EPWM9     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EPWM10    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EPWM11    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EPWM12    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EPWM13    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EPWM14    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EPWM15    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EPWM16    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_TBCLKSYNC = true;

sfo1.$name = "mySFO0";

    Best regards,

    Adrien

  • 0 in reply to Adrien Thurin
    TI__Expert 8370 points

    Hello Adrien,

    Thanks for sharing more details. The configuration looks similar and symmetrical to me. Also, all ADCs are enabled. If I want to try systematically debug this issue, I would start by temporarily changing all SOC triggers to ADC_TRIGGER_SW_ONLY and trigger manually:

    ADC_forceSOC(ADCB_BASE, ADC_SOC_NUMBER0);
DEVICE_DELAY_US(10);
result = ADC_readResult(ADCBRESULT_BASE, ADC_SOC_NUMBER0);

    If this returns a valid result, it means the ADC itself works and the issue is with trigger/event timing.

    Also can you confirm how do you reading each ADC result? Each ADC instance has a separate result register base (ADCARESULT_BASE, ADCBRESULT_BASE, ...).

    Let me know if this is helps.

    Best Regards,

    Masoud

  • 0 in reply to Masoud Farhadi
    Intellectual 596 points

    Hello Masoud,

    Masoud Farhadi said:
    Also can you confirm how do you reading each ADC result? Each ADC instance has a separate result register base (ADCARESULT_BASE, ADCBRESULT_BASE, ...).

    I'm old school ;-) I've worked for many years on older parts (starting with F2802x), I'm used to how things were before driverlib. I look at the registers in the debug watch window (AdcaResultRegs, AdcbResultRegs, ...)

    Here is a really strange part, now that I think about it (after I have been confronted with the issue, when changing SOC triggers to SW only) : ADC C SOC0 triggers the main control interrupt on EOC, and the interrupt does happen. Which means that the conversion probably happens ? and yet the result is 0 LSB.

    So I set all SOCs (except the interrupt triggering one) to SW only, and trigger all SOCs in software.

    ADC_forceSOC(MESURE_TENSION_1_BASE, ADC_FORCE_SOC0);
ADC_forceSOC(MESURE_TENSION_1_BASE, ADC_FORCE_SOC1);
ADC_forceSOC(MESURE_TENSION_1_BASE, ADC_FORCE_SOC2);
ADC_forceSOC(MESURE_TENSION_1_BASE, ADC_FORCE_SOC3);
ADC_forceSOC(MESURE_TENSION_2_BASE, ADC_FORCE_SOC0);
ADC_forceSOC(MESURE_TENSION_2_BASE, ADC_FORCE_SOC1);
ADC_forceSOC(MESURE_COURANT_BASE, ADC_FORCE_SOC1);
ADC_forceSOC(MESURE_COURANT_BASE, ADC_FORCE_SOC2);
ADC_forceSOC(MESURE_TEMPERATURE_BASE, ADC_FORCE_SOC0);
ADC_forceSOC(MESURE_TEMPERATURE_BASE, ADC_FORCE_SOC1);
ADC_forceSOC(MESURE_TEMPERATURE_BASE, ADC_FORCE_SOC2);

    I get the same result : ADC A results are correct, all others are 0 without even the slightest noise.

    I forgot to mention that this looked so weird I purchased a second control card, in case the target got damaged, but the issue is the same with the brand new control card.

    Best regards,

    Adrien

  • 0 in reply to Adrien Thurin
    TI__Expert 8370 points

    Hi Adrien,

    This is kind of odd. Could you check out one of our reference examples to see if you see the results on ADC B-D? If you do, then with short format of project, we can try debugging there.

    Best Regards,

    Masoud

  • 0 in reply to Masoud Farhadi
    Intellectual 596 points

    Hi Masoud,

    I tried a super minimalist program, and the Adc B-D get results.

    Now why would the SOC force in the minimalist program yield results when soc for in the full code doesn't ?

    I am really lost there.

    Best regards,

    Adrien

  • 0 in reply to Adrien Thurin
    TI__Expert 8370 points

    This means hardware can work and strongly suggests the issue lies in the trigger/timing. When you forced via software, you got zero for B–D in the full code, but results in the minimalist code. Meaning in the full system maybe the SOCs are being overwritten or reset, or the trigger source is being overridden by something else. Even though the SOC trigger is configured but the digital trigger event may never occur or is masked/disabled, the conversion may still “complete” (and generate EOC interrupt) but produce 0 because nothing was sampled (or the sample window was incorrectly configured).

    At this step, I would bring out ADC SoCs on a GPIO pins and confirm the digital trigger event actually happening.

    Best Regards,

    Masoud

  • 0 in reply to Masoud Farhadi
    Intellectual 596 points

    Hi Masoud,

    I will try as you suggest.

    However, I forgot to mention earlier that the issue is only present when using the evaluation board (controlcard). All the ADCs work as expected when used on the application board.

    Best regards,

    Adrien

  • 0 in reply to Masoud Farhadi
    Intellectual 596 points

    Hi Masoud,

    How can I bring out the ADC SoC on a GPIO pin ? I can't figure out how to do so.

    Thanks in advance,
    Adrien

  • 0 in reply to Adrien Thurin
    TI__Expert 8370 points

    Hi Adrien,

    Say, if you're ePWM1 SoCA as ADC trigger source:

    Then, you can enable ADC SOCA output in EPMW1 tab:

    Finally, you should enable the respective GPIO as:

    Best Regards,

    Masoud

  • 0 in reply to Masoud Farhadi
    Intellectual 596 points

    Hi Masoud,

    I would never have guessed / found out this. I was looking around the output Xbar.

    I confirm that all SOCs are visible when on a GPIO output (active low signal).

    I have tried to reduce the sampling time to the minimum, it doesn't seem to help.

    Considering that the issue is on the control card and not on the application board (with the same configuration), any idea what else cause the issue ?

    Thanks in advance,

    Adrien

  • 0 in reply to Adrien Thurin
    TI__Expert 8370 points

    Hi Adrien,

    To summarize: ADC A is working fine; ADCs B, C and D return 0 (no noise or real readings) on that control card. On the same part (with same firmware/config) the ADCs B–D do work when you move to your application board (so the issue appears isolated to the control card). When you explicitly force SOC triggers via software in a minimalist program, the ADC B–D also work. But in your full code + control card combination, the triggers/config seem set up symmetrically for the ADCs, and yet B–D still show zero.

    From your file, ADCA is not generating any interrupt. Meanwhile, ADCB, ADCC, and ADCD all have.

    When using ePWM-triggered conversions, the ADC result registers themselves will still be updated even if interrupts are disabled. However, if your main control loop or ISR logic depends on an ADC interrupt to process or read results, then ADC A’s conversions might still complete silently (no ISR called). ADC B/C/D will fire interrupts and may immediately clear or overwrite the results before you read them. This mismatch can easily create the illusion that only some ADC modules are working depending on how your software reads and services each ADC.

    Moreover, if the CLA is triggered by ADCB events, as your file shows:


    cla1.trigger_CLA_TASK_1 = "CLA_TRIGGER_ADCB1";
cla1.trigger_CLA_TASK_2 = "CLA_TRIGGER_ADCB2";
cla1.trigger_CLA_TASK_3 = "CLA_TRIGGER_ADCB3";

    then ADCB’s interrupt is routed to the CLA, not CPU1. This can leave CPU1 waiting for ADC results that never arrive there (because the CLA is taking them).

    Can you disable interrupts for all ADCs and poll the result registers manually (useful for debugging)? This removes ISR/CLA interference and tests raw sampling.

    Please try injecting a known analog voltage (e.g., 1 V) into the pin and see if the result changes. This will verify the path from pin → ADC is working.

    Best Regards,

    Masoud

  • 0 in reply to Masoud Farhadi
    Intellectual 596 points

    Hi Masoud,

    I confirm your summary.

    I have simplified my syscfg file : no more interrupt C28, SW trigger for CLA tasks, a single ePWM trigger for all SOCs, SOC pulse visualised ... and still nothing in the AdcXResultRegs with X=b, c, d.

    Here is the simplified syscfg file :

    /**
 * These arguments were used when this file was generated. They will be automatically applied on subsequent loads
 * via the GUI or CLI. Run CLI with '--help' for additional information on how to override these arguments.
 * @cliArgs --device "F2838x" --part "F2838x_176pin" --package "176pin" --context "CPU1" --product "C2000WARE@5.04.00.00"
 * @v2CliArgs --device "TMS320F28388D" --package "176pin" --context "CPU1" --product "C2000WARE@5.04.00.00"
 * @versions {"tool":"1.24.1+4189"}
 */

/**
 * Import the modules used in this configuration.
 */
const adc         = scripting.addModule("/driverlib/adc.js");
const adc1        = adc.addInstance();
const adc2        = adc.addInstance();
const adc3        = adc.addInstance();
const adc4        = adc.addInstance();
const asysctl     = scripting.addModule("/driverlib/asysctl.js");
const cla         = scripting.addModule("/driverlib/cla.js", {}, false);
const cla1        = cla.addInstance();
const epwm        = scripting.addModule("/driverlib/epwm.js", {}, false);
const epwm1       = epwm.addInstance();
const epwm2       = epwm.addInstance();
const epwm3       = epwm.addInstance();
const flash       = scripting.addModule("/driverlib/flash.js", {}, false);
const flash1      = flash.addInstance();
const memcfg      = scripting.addModule("/driverlib/memcfg.js");
const other       = scripting.addModule("/driverlib/other.js", {}, false);
const other1      = other.addInstance();
const outputxbar  = scripting.addModule("/driverlib/outputxbar.js", {}, false);
const outputxbar1 = outputxbar.addInstance();
const sync        = scripting.addModule("/driverlib/sync.js");
const sysctl      = scripting.addModule("/driverlib/sysctl.js");
const sfo         = scripting.addModule("/libraries/calibration/hrpwm/sfo.js", {}, false);
const sfo1        = sfo.addInstance();

/**
 * Write custom configuration values to the imported modules.
 */
adc1.adcClockPrescaler  = "ADC_CLK_DIV_4_0";
adc1.soc0SampleWindow   = 64;
adc1.registerInterrupts = ["1"];
adc1.useInterrupts      = false;
adc1.soc1SampleWindow   = 64;
adc1.soc2SampleWindow   = 64;
adc1.soc3SampleWindow   = 64;
adc1.soc4Channel        = "ADC_CH_ADCIN4";
adc1.soc4SampleWindow   = 64;
adc1.soc4Trigger        = "ADC_TRIGGER_EPWM5_SOCA";
adc1.soc4Name           = "Vbatlvlp";
adc1.$name              = "MESURE_TENSION_1";
adc1.soc0Trigger        = "ADC_TRIGGER_EPWM1_SOCA";
adc1.soc1Name           = "V_PFC";
adc1.soc0Name           = "V_AC";
adc1.soc1Trigger        = "ADC_TRIGGER_EPWM1_SOCA";
adc1.soc2Name           = "V_BAT48";
adc1.soc3Name           = "V_BAT12";
adc1.enabledSOCs        = ["ADC_SOC_NUMBER0","ADC_SOC_NUMBER1","ADC_SOC_NUMBER2","ADC_SOC_NUMBER3"];
adc1.soc1Channel        = "ADC_CH_ADCIN1";
adc1.soc2Channel        = "ADC_CH_ADCIN2";
adc1.soc3Channel        = "ADC_CH_ADCIN3";
adc1.soc3Trigger        = "ADC_TRIGGER_EPWM1_SOCA";
adc1.soc2Trigger        = "ADC_TRIGGER_EPWM1_SOCA";

adc2.adcClockPrescaler   = "ADC_CLK_DIV_4_0";
adc2.soc2SampleWindow    = 64;
adc2.soc1SampleWindow    = 64;
adc2.soc0SampleWindow    = 64;
adc2.registerInterrupts  = ["1"];
adc2.soc1Name            = "Idp";
adc2.soc1Channel         = "ADC_CH_ADCIN1";
adc2.soc2Name            = "T_Amb";
adc2.soc2Channel         = "ADC_CH_ADCIN2";
adc2.soc3Name            = "T_spare";
adc2.soc3Channel         = "ADC_CH_ADCIN3";
adc2.soc3SampleWindow    = 64;
adc2.interrupt2SOCSource = "ADC_SOC_NUMBER1";
adc2.soc4Channel         = "ADC_CH_ADCIN4";
adc2.soc4Trigger         = "ADC_TRIGGER_EPWM5_SOCA";
adc2.soc4SampleWindow    = 64;
adc2.$name               = "MESURE_TENSION_2";
adc2.soc0Name            = "V_BAT12_LP";
adc2.useInterrupts       = false;
adc2.adcBase             = "ADCB_BASE";
adc2.enabledSOCs         = ["ADC_SOC_NUMBER0","ADC_SOC_NUMBER1","ADC_SOC_NUMBER2","ADC_SOC_NUMBER3"];
adc2.soc0Trigger         = "ADC_TRIGGER_EPWM1_SOCA";
adc2.soc1Trigger         = "ADC_TRIGGER_EPWM1_SOCA";
adc2.soc2Trigger         = "ADC_TRIGGER_EPWM1_SOCA";
adc2.soc3Trigger         = "ADC_TRIGGER_EPWM1_SOCA";

adc3.registerInterrupts             = ["1"];
adc3.soc2Trigger                    = "ADC_TRIGGER_EPWM1_SOCA";
adc3.soc3SampleWindow               = 64;
adc3.soc3Trigger                    = "ADC_TRIGGER_EPWM1_SOCA";
adc3.soc3Channel                    = "ADC_CH_ADCIN1";
adc3.$name                          = "MESURE_COURANT";
adc3.soc0Name                       = "I_DP";
adc3.soc0Channel                    = "ADC_CH_ADCIN4";
adc3.soc1Name                       = "I_PSFB";
adc3.soc1Channel                    = "ADC_CH_ADCIN3";
adc3.soc2Name                       = "I_PFC";
adc3.soc2Channel                    = "ADC_CH_ADCIN2";
adc3.enabledSOCs                    = ["ADC_SOC_NUMBER0","ADC_SOC_NUMBER1","ADC_SOC_NUMBER2"];
adc3.enableInterrupt1               = true;
adc3.enableInterrupt1ContinuousMode = true;
adc3.enableInterrupt2               = true;
adc3.enableInterrupt2ContinuousMode = true;
adc3.interrupt2SOCSource            = "ADC_SOC_NUMBER1";
adc3.enableInterrupt3               = true;
adc3.enableInterrupt3ContinuousMode = true;
adc3.interrupt3SOCSource            = "ADC_SOC_NUMBER2";
adc3.soc0SampleWindow               = 15;
adc3.soc1SampleWindow               = 15;
adc3.soc2SampleWindow               = 15;
adc3.adcClockPrescaler              = "ADC_CLK_DIV_4_0";
adc3.adcBase                        = "ADCC_BASE";
adc3.soc0Trigger                    = "ADC_TRIGGER_EPWM1_SOCA";
adc3.soc1Trigger                    = "ADC_TRIGGER_EPWM1_SOCA";
adc3.useInterrupts                  = false;

adc4.adcClockPrescaler  = "ADC_CLK_DIV_4_0";
adc4.enabledSOCs        = ["ADC_SOC_NUMBER0","ADC_SOC_NUMBER1","ADC_SOC_NUMBER2"];
adc4.soc2SampleWindow   = 64;
adc4.soc1SampleWindow   = 64;
adc4.soc0SampleWindow   = 64;
adc4.soc2Trigger        = "ADC_TRIGGER_EPWM1_SOCA";
adc4.soc1Trigger        = "ADC_TRIGGER_EPWM1_SOCA";
adc4.soc0Trigger        = "ADC_TRIGGER_EPWM1_SOCA";
adc4.soc1Name           = "T_Cool_In";
adc4.soc2Name           = "T_Cool_Out";
adc4.registerInterrupts = ["1"];
adc4.$name              = "MESURE_TEMPERATURE";
adc4.adcBase            = "ADCD_BASE";
adc4.useInterrupts      = false;
adc4.soc1Channel        = "ADC_CH_ADCIN1";
adc4.soc2Channel        = "ADC_CH_ADCIN2";
adc4.soc0Name           = "T_spare";

cla1.$name              = "CLA_CPU1";
cla1.enable_CLA_TASK_4  = false;
cla1.enable_CLA_TASK_6  = false;
cla1.enable_CLA_TASK_5  = false;
cla1.enable_CLA_TASK_7  = false;
cla1.cpuint_CLA_TASK_1  = false;
cla1.cpuint_CLA_TASK_2  = false;
cla1.cpuint_CLA_TASK_3  = false;
cla1.cpuint_CLA_TASK_5  = false;
cla1.cpuint_CLA_TASK_4  = false;
cla1.cpuint_CLA_TASK_6  = false;
cla1.cpuint_CLA_TASK_7  = false;
cla1.cpuint_CLA_TASK_8  = false;
cla1.trigger_CLA_TASK_3 = "CLA_TRIGGER_ADCB3";
cla1.enable_CLA_TASK_3  = false;

const divider3       = system.clockTree["AUX_REFDIV"];
divider3.divideValue = 1;

const divider14       = system.clockTree["PLL_REFDIV"];
divider14.divideValue = 1;

const mux1       = system.clockTree["AUXOSCCLKSRCSEL"];
mux1.inputSelect = "INTOSC2";

const mux15       = system.clockTree["OSCCLKSRCSEL"];
mux15.inputSelect = "INTOSC1";

const mux18       = system.clockTree["XTAL_OR_X1"];
mux18.inputSelect = "XTAL";

epwm1.copyFrom                                                   = "PWM_PFC";
epwm1.epwmTimebase_emulationMode                                 = "EPWM_EMULATION_FREE_RUN";
epwm1.epwmTimebase_counterMode                                   = "EPWM_COUNTER_MODE_UP_DOWN";
epwm1.epwmTimebase_counterModeAfterSync                          = "EPWM_COUNT_MODE_UP_AFTER_SYNC";
epwm1.epwmTimebase_syncOutPulseMode                              = ["EPWM_SYNC_OUT_PULSE_ON_CNTR_ZERO"];
epwm1.hrpwm_syncSource                                           = "HRPWM_PWMSYNC_SOURCE_ZERO";
epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPB   = "EPWM_AQ_OUTPUT_HIGH";
epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_DOWN_CMPB = "EPWM_AQ_OUTPUT_LOW";
epwm1.epwmEventTrigger_EPWM_SOC_A_triggerEnable                  = true;
epwm1.epwmEventTrigger_EPWM_SOC_A_triggerSource                  = "EPWM_SOC_TBCTR_ZERO";
epwm1.epwmEventTrigger_EPWM_SOC_A_triggerEventPrescalar          = "1";
epwm1.hrpwm_cmpaHR                                               = 50;
epwm1.hrpwm_edgeModeB                                            = "HRPWM_MEP_CTRL_RISING_EDGE";
epwm1.hrpwm_cmpbHR                                               = 50;
epwm1.epwmTimebase_period                                        = 192;
epwm1.$name                                                      = "PWM_DP";
epwm1.epwmCounterCompare_cmpB                                    = 192;
epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_DOWN_CMPA = "EPWM_AQ_OUTPUT_HIGH";
epwm1.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA   = "EPWM_AQ_OUTPUT_LOW";
epwm1.hrpwm_edgeModeA                                            = "HRPWM_MEP_CTRL_FALLING_EDGE";
epwm1.epwm.$assign                                               = "EPWM7";
epwm1.epwm.epwm_aPin.$assign                                     = "GPIO12";
epwm1.epwm.epwm_bPin.$assign                                     = "GPIO13";

epwm2.epwmTimebase_emulationMode                                 = "EPWM_EMULATION_FREE_RUN";
epwm2.epwmTimebase_counterMode                                   = "EPWM_COUNTER_MODE_UP_DOWN";
epwm2.epwmTimebase_counterModeAfterSync                          = "EPWM_COUNT_MODE_UP_AFTER_SYNC";
epwm2.epwmTimebase_syncOutPulseMode                              = ["EPWM_SYNC_OUT_PULSE_ON_CNTR_ZERO"];
epwm2.hrpwm_syncSource                                           = "HRPWM_PWMSYNC_SOURCE_ZERO";
epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPB   = "EPWM_AQ_OUTPUT_HIGH";
epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_DOWN_CMPB = "EPWM_AQ_OUTPUT_LOW";
epwm2.epwmTimebase_periodLink                                    = "EPWM_LINK_WITH_EPWM_1";
epwm2.epwmTimebase_period                                        = 384;
epwm2.hrpwm_cmpbHR                                               = 50;
epwm2.epwmEventTrigger_EPWM_SOC_A_triggerEnable                  = true;
epwm2.epwmEventTrigger_EPWM_SOC_A_triggerSource                  = "EPWM_SOC_TBCTR_ZERO";
epwm2.epwmEventTrigger_EPWM_SOC_A_triggerEventPrescalar          = "1";
epwm2.hrpwm_edgeModeB                                            = "HRPWM_MEP_CTRL_RISING_EDGE";
epwm2.epwmCounterCompare_cmpB                                    = 384;
epwm2.$name                                                      = "PWM_PFC_HF";
epwm2.hrpwm_cmpaHR                                               = 50;
epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA   = "EPWM_AQ_OUTPUT_LOW";
epwm2.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_DOWN_CMPA = "EPWM_AQ_OUTPUT_HIGH";
epwm2.hrpwm_edgeModeA                                            = "HRPWM_MEP_CTRL_FALLING_EDGE";
epwm2.hrpwm_enable                                               = true;
epwm2.epwm.$assign                                               = "EPWM1";
epwm2.epwm.epwm_aPin.$assign                                     = "GPIO0";
epwm2.epwm.epwm_bPin.$assign                                     = "GPIO1";

epwm3.epwmTimebase_emulationMode                                 = "EPWM_EMULATION_FREE_RUN";
epwm3.epwmTimebase_counterMode                                   = "EPWM_COUNTER_MODE_UP_DOWN";
epwm3.epwmTimebase_counterModeAfterSync                          = "EPWM_COUNT_MODE_UP_AFTER_SYNC";
epwm3.epwmTimebase_syncOutPulseMode                              = ["EPWM_SYNC_OUT_PULSE_ON_CNTR_ZERO"];
epwm3.hrpwm_syncSource                                           = "HRPWM_PWMSYNC_SOURCE_ZERO";
epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_UP_CMPA   = "EPWM_AQ_OUTPUT_LOW";
epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_A_ON_TIMEBASE_DOWN_CMPA = "EPWM_AQ_OUTPUT_HIGH";
epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_UP_CMPB   = "EPWM_AQ_OUTPUT_HIGH";
epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_B_ON_TIMEBASE_DOWN_CMPB = "EPWM_AQ_OUTPUT_LOW";
epwm3.epwmEventTrigger_EPWM_SOC_A_triggerEnable                  = true;
epwm3.epwmEventTrigger_EPWM_SOC_A_triggerSource                  = "EPWM_SOC_TBCTR_ZERO";
epwm3.epwmEventTrigger_EPWM_SOC_A_triggerEventPrescalar          = "1";
epwm3.hrpwm_edgeModeA                                            = "HRPWM_MEP_CTRL_FALLING_EDGE";
epwm3.hrpwm_cmpaHR                                               = 50;
epwm3.hrpwm_edgeModeB                                            = "HRPWM_MEP_CTRL_RISING_EDGE";
epwm3.hrpwm_cmpbHR                                               = 50;
epwm3.copyFrom                                                   = "PWM_TDC_2";
epwm3.epwmTimebase_counterValue                                  = 1;
epwm3.$name                                                      = "PWM_PSFB_LEAD";
epwm3.epwmTimebase_syncInPulseSource                             = "EPWM_SYNC_IN_PULSE_SRC_DISABLE";
epwm3.epwmActionQualifier_EPWM_AQ_OUTPUT_A_shadowMode            = true;
epwm3.epwmDeadband_polarityFED                                   = "EPWM_DB_POLARITY_ACTIVE_LOW";
epwm3.epwmDeadband_enableRED                                     = true;
epwm3.epwmDeadband_enableFED                                     = true;
epwm3.epwmDeadband_delayRED                                      = 10;
epwm3.epwmDeadband_delayFED                                      = 10;
epwm3.hrpwm_enable                                               = true;
epwm3.hrpwm_autoConv                                             = true;
epwm3.hrpwm_controlModeA                                         = "HRPWM_MEP_PHASE_CTRL";
epwm3.hrpwm_controlModeB                                         = "HRPWM_MEP_PHASE_CTRL";
epwm3.epwmTimebase_forceSyncPulse                                = true;
epwm3.epwmTimebase_hsClockDiv                                    = "EPWM_HSCLOCK_DIVIDER_1";
epwm3.epwmTimebase_period                                        = 480;
epwm3.epwmCounterCompare_cmpA                                    = 240;
epwm3.epwmCounterCompare_cmpB                                    = 240;
epwm3.epwm.$assign                                               = "EPWM3";
epwm3.epwm.epwm_aPin.$assign                                     = "GPIO4";
epwm3.epwm.epwm_bPin.$assign                                     = "GPIO5";

flash1.$name = "myFMC0";

memcfg.init_MEMCFG_SECT_MSGCPUTOCLA1 = true;
memcfg.init_MEMCFG_SECT_MSGCLA1TOCPU = true;
memcfg.init_MEMCFG_SECT_MSGCPUTOCPU0 = true;
memcfg.init_MEMCFG_SECT_MSGCLA1TODMA = true;
memcfg.init_MEMCFG_SECT_MSGDMATOCLA1 = true;
memcfg.init_MEMCFG_SECT_MSGCPUTOCPU1 = true;
memcfg.init_MEMCFG_SECT_MSGCPUTOCM0  = true;
memcfg.init_MEMCFG_SECT_MSGCPUTOCM1  = true;
memcfg.config_MEMCFG_SECT_LS0        = "CLA_data";
memcfg.config_MEMCFG_SECT_LS1        = "CLA_data";
memcfg.config_MEMCFG_SECT_LS5        = "CLA_prog";
memcfg.config_MEMCFG_SECT_GS0        = "MEMCFG_GSRAMCONTROLLER_CPU2";
memcfg.config_MEMCFG_SECT_GS14       = "MEMCFG_GSRAMCONTROLLER_CPU2";

other1.$name                       = "myOTHER0";
other1.other.$assign               = "OTHER";
other1.other.adcsocaoPin.$assign   = "GPIO8";
other1.other.adcsocboPin.$assign   = "GPIO10";
other1.other.extsyncoutPin.$assign = "GPIO6";

outputxbar1.$name                            = "myOUTPUTXBAR0";
outputxbar1.useSourceSelect                  = true;
outputxbar1.mux13Config                      = "XBAR_OUT_MUX13_ADCSOCA";
outputxbar1.mux0Config                       = "XBAR_OUT_MUX00_ADCAEVT1";
outputxbar1.mux2Config                       = "XBAR_OUT_MUX02_ADCAEVT2";
outputxbar1.mux3Config                       = "XBAR_OUT_MUX03_ADCCEVT2";
outputxbar1.mux1Config                       = "XBAR_OUT_MUX01_CLB1_OUT4";
outputxbar1.sourceSignals                    = ["ADCBEVT1","ADCBEVT4","ADCSOCB"];
outputxbar1.outputxbar.outputxbarPin.$assign = "GPIO15";

sync.ADCSOCAOutputSelect = ["SYSCTL_ADCSOC_SRC_PWM1SOCA"];

sysctl.enable_SYSCTL_PERIPH_CLK_TIMER1    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_TIMER2    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CPUBGCRC  = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CLA1BGCRC = false;
sysctl.enable_SYSCTL_PERIPH_CLK_ERAD      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EMIF1     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EMIF2     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_ECAP1     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_ECAP2     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_ECAP3     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_ECAP4     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_ECAP5     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_ECAP6     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_ECAP7     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EQEP1     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EQEP2     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EQEP3     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_SD1       = false;
sysctl.enable_SYSCTL_PERIPH_CLK_SD2       = false;
sysctl.enable_SYSCTL_PERIPH_CLK_SCIA      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_SCIB      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_SCIC      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_SCID      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_SPIA      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_SPIB      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_SPIC      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_SPID      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_I2CA      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_I2CB      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CANA      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CANB      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_MCANA     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_MCBSPA    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_MCBSPB    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_USBA      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CMPSS1    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CMPSS2    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CMPSS3    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CMPSS4    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CMPSS5    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CMPSS6    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CMPSS7    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CMPSS8    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_DACC      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CLB1      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CLB2      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CLB3      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CLB4      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CLB5      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CLB6      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CLB7      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_CLB8      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_FSITXA    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_FSITXB    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_FSIRXA    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_FSIRXB    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_FSIRXC    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_FSIRXD    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_FSIRXE    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_FSIRXF    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_FSIRXG    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_FSIRXH    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_PMBUSA    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_MPOSTCLK  = false;
sysctl.enable_SYSCTL_PERIPH_CLK_ECAT      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_DCC0      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_DCC1      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_DCC2      = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EPWM8     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EPWM9     = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EPWM10    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EPWM11    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EPWM12    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EPWM13    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EPWM14    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EPWM15    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_EPWM16    = false;
sysctl.enable_SYSCTL_PERIPH_CLK_TBCLKSYNC = true;

sfo1.$name = "mySFO0";

/**
 * Pinmux solution for unlocked pins/peripherals. This ensures that minor changes to the automatic solver in a future
 * version of the tool will not impact the pinmux you originally saw.  These lines can be completely deleted in order to
 * re-solve from scratch.
 */
other1.other.xclkoutPin.$suggestSolution = "GPIO73";
outputxbar1.outputxbar.$suggestSolution  = "OUTPUTXBAR4";

    The setup has the same voltage (~1.3V) on all inputs (A0-A3, B0-B3, D0-1). Pins on Adc C are floating, so I would expect some amount of noise. And yet :

    Is there anything controlcard-specific that could cause the issue ?

    Best regards,

    Adrien

  • 0 in reply to Adrien Thurin
    TI__Expert 8370 points

    For the ADC, the S3 and S4 switches are the settings specific to the ControlCard that allow you to select the ADC references. Could you also verify if the ADC references are accurate?

    Best Regards,

    Masoud

  • 0 in reply to Masoud Farhadi
    Intellectual 596 points

    The result values change in ADC A when I flip the switches (because ref 3.0V vs 3.3V supply), but still 0 on the output of ADC B,C,D.

    Best regards,

    Adrien

  • 0 in reply to Adrien Thurin
    TI__Expert 8370 points

    I have sampled a ControlCard for myself and if you share the short version of program, I'll try to recreate and debug the issue.

    Best Regards,

    Masoud

  • 0 in reply to Adrien Thurin
    TI__Expert 8370 points

    Hi Adrien,

    I've got the code, and as soon as I receive the Control Card, I'll share the debugged version.

    Best Regards,

    Masoud

  • 0 in reply to Masoud Farhadi
    TI__Expert 8370 points

    Hello,

    I just received the TMDSCNCD28388D ControlCard and tested ADC B, C and D and it's working as expected. I'm attaching the sample project for your reference. You can simply run the code and watch:

    myADC_B_Results; // B0 - HSEC pin 12

    myADC_C_Results; // C5 - HSEC pin 39

    myADC_D_Results; // D0 - HSEC pin 28

    in watch window.

    Best Regards,

    Masoud

    ADC_B_C_D_test.zip

  • 0 in reply to Masoud Farhadi
    TI__Expert 8370 points

    I also remember you shared a couple of project over email. I have did edited one of them to read the ADC B,C, and D results. I have attached that project too for your reference.

    Best Regards,

    Masoud

    Minimal_PWM_test.zip

  • 0 in reply to Masoud Farhadi
    Intellectual 596 points

    Hi Masoud,

    Thinks keep getting weirder...

    Regarding the ADC_B_C_D_test project, I do get some results ... but only with a breakpoint. Continuous refresh and continuous run return a permanent 0.

    With breakpoint :

    No breakpoint, continuous refresh :

    I switched to the Minimal_PWM_test project, and in this one, it is 0 all the time, including with a breakpoint.

    Of course, I am not touching / changing in any way the hardware that is connected to the controlcad (including voltages applied to the ADCs).

    Do both projects work properly on your end ?

    Best regards,

    Adrien

  • 0 in reply to Adrien Thurin
    TI__Expert 8370 points

    Yes, both projects working on my side without any break point on continuous refresh. Here is the picture of ControlCard to double check the switch positions on CC (every switch is in default mode).

    Best Regards,

    Masoud

  • 0 in reply to Masoud Farhadi
    Intellectual 596 points

    Hi Masoud,

    Sorry for the delayed response, the last couple of weeks have been very busy.

    I have checked the switches for the voltage reference, tried both positions, and the results are the same.

    Best regards,

    Adrien