MSP432P401R: not enaugh space in memory

Hi Mattia,

it is not so easy to write the data to the flash memory. Your definition assumes, that the memory is in the SRAM space, which is to small. You have to define a It depends on your use case how to store the data.

Are you aware of the programming speed in flash for your ADC data?
If you are using flash memory, it is treated like const memory. You have to erase it before you could use it. To write to the memory it will also take a while.

I'm not sure if this is possible in your use case.

Best regards,

Thank you :)

In my project I would like to sample the ADC values and sent it through UART.

Although in this post I asked for sending in batch a lot of samples, my wish is to send each sample in real time, but seems that the UART is too slow, even if I don't understand why.

I set the SMCLK to 48MHz

FlashCtl_setWaitState(FLASH_BANK0, 2);
FlashCtl_setWaitState(FLASH_BANK1, 2);
MAP_PCM_setCoreVoltageLevel(PCM_VCORE1);
CS_setDCOCenteredFrequency(CS_DCO_FREQUENCY_48);

I assigned it to ADC CLOCK (after tested that SMCLK was 48MHz with the function CS_getSMCLK())

MAP_ADC14_initModule(ADC_CLOCKSOURCE_SMCLK, ADC_PREDIVIDER_1, ADC_DIVIDER_1,0);

I configured the ADC sample trigger to be sourced from TIMER_A 

MAP_ADC14_setSampleHoldTrigger(ADC_TRIGGER_SOURCE1, false);

with this parametrisation

/* Timer_A Continuous Mode Configuration Parameter */
const Timer_A_UpModeConfig upModeConfig =
{
        TIMER_A_CLOCKSOURCE_SMCLK,            
        TIMER_A_CLOCKSOURCE_DIVIDER_1,
        3000,
        TIMER_A_TAIE_INTERRUPT_DISABLE,      // Disable Timer ISR, mi serve x ADC
        TIMER_A_CCIE_CCR0_INTERRUPT_DISABLE, // Disable CCR0
        TIMER_A_DO_CLEAR                     // Clear Counter
};

/* Timer_A Compare Configuration Parameter */
const Timer_A_CompareModeConfig compareConfig =
{
        TIMER_A_CAPTURECOMPARE_REGISTER_1,          // Use CCR1
        TIMER_A_CAPTURECOMPARE_INTERRUPT_DISABLE,   // Disable CCR interrupt, mi serve x ADC
        TIMER_A_OUTPUTMODE_SET_RESET,               // Toggle output bit
        3000                                 //CCR1=CCR0 
};

Considered that I would like to sample at 16kHz -> 48Mhz / 3000 = 16kHz, is it right to think that the ADC conversion is done 16.000 times per seconds?

I configured the UART module with the parameters suggested at this link: 

//48MHz clock, 115200 baudrate
const eUSCI_UART_Config uartConfig =
{
    EUSCI_A_UART_CLOCKSOURCE_SMCLK,          // SMCLK Clock Source
    26,                                     // BRDIV = 78
    1,                                       // UCxBRF = 2
    0,                                       // UCxBRS = 0
    EUSCI_A_UART_NO_PARITY,                  // No Parity
    EUSCI_A_UART_LSB_FIRST,                  // MSB First
    EUSCI_A_UART_ONE_STOP_BIT,               // One stop bit
    EUSCI_A_UART_MODE,                       // UART mode
    EUSCI_A_UART_OVERSAMPLING_BAUDRATE_GENERATION  // Oversampling
};

and in the main() I have something like these:

while(1){            
sprintf(str,"%x",myArray[index]);
            MAP_UART_transmitData(EUSCI_A0_BASE, str[0]);
            MAP_UART_transmitData(EUSCI_A0_BASE, str[1]);
            MAP_UART_transmitData(EUSCI_A0_BASE, str[2]);
            MAP_UART_transmitData(EUSCI_A0_BASE, str[3]);
            MAP_UART_transmitData(EUSCI_A0_BASE, str[4]);
            MAP_UART_transmitData(EUSCI_A0_BASE, '\n');
}

I think that with 48Mhz ,against 16kHz of ADC, would have given me enough time to send my adcValue (stored in myArray) between two ADC sampling.

Where Am I wrong?

Thank you!,

Best Regards,

Mattia Ducci