MSP432P401R: ADC Values and Memory

Thank you for your help Bob! I've done some research and I think what I want to do is store the ADC results in RAM, so that they will be erased when the MSP432 is powered down. However, I can't seem to find any resources pointing out how this might be done. Any suggestions?

The example that Bob mentioned shows one method of storing ADC data in an array.

If you're not using driverlib, example (SLAC698D) adc14_06 provides an example as well. (It uses a different mode in the ADC, so just ignore that part.)

Thank you very much! I'm going to try this now, and I'm using Code Composer Studio 7.1.0.

I looked over the example that you suggested and attempted to implement a similar fix yet, when I watch the register values in the debugger I only notice ADC14MEM0 and ADC14MEM2 changing.

The following is my ADC ISR, where I am trying to store the resulting values in different locations based on the pin that triggered the interrupt driving the ADC.

void ADC14_IRQHandler(void) {
  
    if((P3->IFG)&& BIT0){
       SDresults[index] = ADC14->MEM[0];   // Move results, IFG is cleared
    }
    if((P3->IFG) && BIT2){
       WBresults[index] = ADC14->MEM[1];
    }
    if((P3->IFG) && BIT3){
       LTresults[index] = ADC14->MEM[2];
    }
    if((P3->IFG) && BIT5){
       HTresults[index] = ADC14->MEM[3];
    }
    if((P3->IFG) && BIT6){
       BDresults[index] = ADC14->MEM[4];
    }
    index = (index + 1) & 0x0F;          // Increment results index, modulo
    __no_operation();                   // Set Breakpoint1 here
}

Additionally, this is the code where I initialize everything used above.

#define   Num_of_Results   16
volatile uint16_t SDresults[Num_of_Results];
volatile uint16_t WBresults[Num_of_Results];
volatile uint16_t LTresults[Num_of_Results];
volatile uint16_t HTresults[Num_of_Results];
volatile uint16_t BDresults[Num_of_Results];
static uint8_t index;

> if((P3->IFG)&& BIT0){
This doesn't do what you want. It should be more like:
> if((P3->IFG)& BIT0){
------
Except that that isn't what you want either: In order to get out of the port3 ISR, you need to set P3->IFG=0 (for at least the relevant bits), so by the time you get here P3->IFG is (almost) certainly 0.

You probably want to save a copy of P3->IFG ("saved_IFG = P3->IFG;") before you clear it in the port3 ISR, and refer to that when you're fetching the ADC results.

Nyssa,

good that you have mentioned you are using CC v7.1.
I had a short discussion with a good TI guy and he told me that he is using 5 different CSS versions.
The key for a success is to use different workspaces for different CCS's.

Bruce,
could you help Nyssa and me how to deal with different version of CCS's?
It is important for all of us to flexibly move between CCS versions and its tools chains.
An example: I have CCS v7.4 and I cannot install the newest XDStools.

Sooner or later a transition to 64-bit is a must.

Thanks!

> how to deal with different version of CCS's?
This is a bit off topic, but:

I also have multiple versions of CCS, and I keep separate workspaces and separate installation directories. When I install an upgrade, I use it (somewhat lazily) to import/check my older workspace and only then uninstall the previous version. This is mostly superstition at this point -- I haven't encountered an upgrade problem in many years, so I haven't had occasion to go backwards.

It sounds as though Nyssa Backes is doing just fine with 7.1.0, though I expect it would be no problem to upgrade.

It sounds as though you (or XDSTools) need some feature which is only in a newer version, so you need to upgrade.

Thank you again! I've saved a copy of P3->IFG before it gets cleared in the Port 3 ISR and then I use the value in the ADC ISR to determine where the resultant values should be stored. Yet, when I check the values stored for each of the interrupts only the P3.0 interrupts stores accurate values that change for differing input. The other interrupts result in an array of the same value being stored for each input.

For example, the P3.2 interrupt always stores WBresults unsigned short[16] [64,64,64,64,64...] for every input, while the P3.3 interrupt saves LTresults unsigned short[16] [1024,1024,1024,1024,1024...] for every input voltage on the ADC pin.

Thank you again for any assistance that you can provide.

This is the Port 3 ISR.

void PORT3_IRQHandler(void)       //Interrupt handler for Port 3
{
       saved_IFG = P3->IFG;
       button_flag = 1;              //Set flag to signal button press detected
       //configure Timer A0
       TA0CCR0 = 900000;             //Timer length = 300ms
       TA0CCTL0 |= CCIE;
       TA0CTL |= TASSEL_2 | MC_1;
       saved_IFG = P3->IFG;
       P3->IFG = 0;                  //Clear P3.0 pending interrupt flag
       P3->IE  &= ~BIT0;            //Disable interrupt for P3.0 for debouncing
       P3->IE  &= ~BIT2;             //Disable interrupt for P3.0 for debouncing
}



This is the ADC ISR.

void ADC14_IRQHandler(void) {   // ADC14 interrupt service routine

    if(saved_IFG & BIT0){
       SDresults[index] = ADC14->MEM[0];   // Move results, IFG is cleared
    }else if(saved_IFG & BIT2){
       WBresults[index] = ADC14->MEM[1];
    }else if(saved_IFG & BIT3){
       LTresults[index] = ADC14->MEM[2];
    }else if(saved_IFG & BIT5){
       HTresults[index] = ADC14->MEM[3];
    }else if(saved_IFG & BIT6){
       BDresults[index] = ADC14->MEM[4];
    }
    index = (index + 1) & 0x0F;          // Increment results index
}

This is how I initialize everything used above.

//new stuff
#define   Num_of_Results   16
volatile uint16_t SDresults[Num_of_Results];
volatile uint16_t WBresults[Num_of_Results];
volatile uint16_t LTresults[Num_of_Results];
volatile uint16_t HTresults[Num_of_Results];
volatile uint16_t BDresults[Num_of_Results];
static uint8_t index;
volatile int saved_IFG;

Thank you very much! I realized my mistake was trying to save results from MEM[1], MEM[2], etc. when I really only needed to use MEM[0]. Thank you again for all of your help!