Part Number:MSP432P4111

Hi all, 

I have been working on a project which invovles SPI. I wanted to know how can i poll the UCTXIFG bit.

Regards,

Bhaumik Jain 

Part Number:MSP432P401R

This is my first project with MSP432, and I'm using a custom board.

External 2-channel ADC is connected to eUSCI_B0, and also external 1-channel DAC connected to eUSCI_B1. I'm using external 32MHz HFXT for MCLK and SMCLK.

I should take ADC samples from both channels, do some processing and write the result to DAC. The code below is simplified version - just ADC read and write value of one channel to DAC(no processing still).

The sampling is controlled by timers, TIMER_A0 - interrupt in 32kHz - setting ConversionStart signal for ADC, and running TIMER_A1 to enter CCR0 isr in ~9us (max conversion time of the ADC).

The rest is just ADC result read (4 bytes via SPI) and DAC write (3 bytes via SPI).

This 2 actions last for 80us! I can not reach even sampling frequency speed, not to mention any processing. 

I tried even just a bit set/reset in TIMER_A1 routine (no SPI at all) and that single instruction lasts for 4us!

I would appreciate any help.

Here is the code with SPI:

#include "msp.h"
#include <driverlib.h>
#include <stdio.h>
#include <arm_math.h>
#include "arm_const_structs.h"

#define LFXT_FREQUENCY          32768
#define HFXT_FREQUENCY          32000000
#define SMCLK_FREQUENCY         HFXT_FREQUENCY
#define SPI_CLK_FREQUENCY       SMCLK_FREQUENCY/2


const eUSCI_SPI_MasterConfig spiMasterConfig =
{
  EUSCI_B_SPI_CLOCKSOURCE_SMCLK,                // SMCLK Clock Source
  SMCLK_FREQUENCY,                              // SMCLK = HFXT = 32MHz
  SPI_CLK_FREQUENCY,                            // SPICLK = SMCLK/2 = 16MHz
  EUSCI_B_SPI_MSB_FIRST,                        // MSB First
  EUSCI_B_SPI_PHASE_DATA_CHANGED_ONFIRST_CAPTURED_ON_NEXT,
  EUSCI_B_SPI_CLOCKPOLARITY_INACTIVITY_LOW,     // Low clock polarity
  EUSCI_B_SPI_3PIN                              // 3-wire SPI mode
};


uint16_t X, Y;
uint8_t ConvOver = 0;


void InitADC (void);
void ReadADCResults (void);
void InitDAC (void);
void uWriteDAC (uint16_t value);
void TimerA0_IRQHandler(void);
void TimerA1_IRQHandler(void);

void main(void)
{
    /* Halting WDT and disabling master interrupts */
    MAP_WDT_A_holdTimer();
    MAP_Interrupt_disableMaster();

    /* Set the core voltage level to VCORE1 */
    MAP_PCM_setCoreVoltageLevel(PCM_VCORE1);
    MAP_FlashCtl_setWaitState(FLASH_BANK0, 2);
    MAP_FlashCtl_setWaitState(FLASH_BANK1, 2);
    
    /* Initializes Clock System */
    MAP_GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_PJ,
          GPIO_PIN3 | GPIO_PIN2, GPIO_PRIMARY_MODULE_FUNCTION);
    MAP_CS_setExternalClockSourceFrequency(LFXT_FREQUENCY,HFXT_FREQUENCY);
    MAP_CS_startHFXT(false);
    MAP_CS_initClockSignal(CS_MCLK, CS_HFXTCLK_SELECT, CS_CLOCK_DIVIDER_1 );
    MAP_CS_initClockSignal(CS_HSMCLK, CS_HFXTCLK_SELECT,CS_CLOCK_DIVIDER_1 );
    MAP_CS_initClockSignal(CS_SMCLK, CS_HFXTCLK_SELECT,CS_CLOCK_DIVIDER_1 );
    MAP_CS_initClockSignal(CS_ACLK, CS_REFOCLK_SELECT, CS_CLOCK_DIVIDER_1);
    
    

    /* Initialize Peripherals */
    InitADC();
    InitDAC();
    
    
    /* Initialize TimerA0 and map interrupt */   
    TIMER_A0->CCTL[0] &= ~TIMER_A_CCTLN_CCIFG;
    TIMER_A0->CCTL[0] = TIMER_A_CCTLN_CCIE; // TACCR0 interrupt enabled
    TIMER_A0->CCR[0] = 1000 - 1;
    TIMER_A0->CTL = TIMER_A_CTL_SSEL__SMCLK | // SMCLK, UP mode
            TIMER_A_CTL_MC__UP;
    MAP_Interrupt_enableInterrupt(INT_TA0_0);
    
    /* Initialize TimerA1 and map interrupt */   
    TIMER_A1->CCTL[0] &= ~TIMER_A_CCTLN_CCIFG;
    TIMER_A1->CCTL[0] = TIMER_A_CCTLN_CCIE; // TACCR1 interrupt enabled
    TIMER_A1->CCR[0] = 0;
    TIMER_A1->CTL = TIMER_A_CTL_SSEL__SMCLK | // SMCLK, UP mode
            TIMER_A_CTL_MC__UP;
    MAP_Interrupt_enableInterrupt(INT_TA1_0);
    
  
    /* General Interrupt Enable */
    MAP_Interrupt_enableMaster();
        
    while(1)
    {
      while(!ConvOver);
      ConvOver = 0;     
     
      ReadADCResults();          // Will be written to X, Y

        P2->OUT &= ~BIT1;         // CONVST = 0

      uWriteDAC(X);
    }
}

void InitADC (void)
{
  // * Port init for ADC SPI communication
    // P1.5 - SCLK - SPI output
    GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_P1,GPIO_PIN5, GPIO_PRIMARY_MODULE_FUNCTION);
    // P1.7 - SDATA - SOMI - SPI input
    GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1,GPIO_PIN7, GPIO_PRIMARY_MODULE_FUNCTION);    
    // P2.1 - CONVST - GPIO output
    GPIO_setAsOutputPin(GPIO_PORT_P2, GPIO_PIN1);
    GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN1);
  
  // * Initialize USCI_B0 for SPI master operation
    SPI_initMaster(EUSCI_B0_BASE, &spiMasterConfig);
    SPI_enableModule(EUSCI_B0_BASE);
    SPI_clearInterruptFlag(EUSCI_B0_BASE, EUSCI_SPI_RECEIVE_INTERRUPT);
}

void ReadADCResults (void)
{
  X = 0;
  Y = 0;
  
  Interrupt_disableMaster();
  
  SPI_clearInterruptFlag(EUSCI_B0_BASE, EUSCI_SPI_RECEIVE_INTERRUPT);
  
  while (!(EUSCI_B0->IFG & EUSCI_B_IFG_TXIFG));
  SPI_transmitData(EUSCI_B0_BASE, 0xFF);
  while (!(EUSCI_B0->IFG & EUSCI_B_IFG_TXIFG));
  Y = SPI_receiveData(EUSCI_B0_BASE);
  Y = Y<<8;
  while (!(EUSCI_B0->IFG & EUSCI_B_IFG_TXIFG));
  SPI_transmitData(EUSCI_B0_BASE, 0xFF);
  while (!(EUSCI_B0->IFG & EUSCI_B_IFG_TXIFG));
  Y += SPI_receiveData(EUSCI_B0_BASE);
  
  while (!(EUSCI_B0->IFG & EUSCI_B_IFG_TXIFG));
  SPI_transmitData(EUSCI_B0_BASE, 0xFF);
  while (!(EUSCI_B0->IFG & EUSCI_B_IFG_TXIFG));
  X = SPI_receiveData(EUSCI_B0_BASE);
  X = X<<8;
  while (!(EUSCI_B0->IFG & EUSCI_B_IFG_TXIFG));
  SPI_transmitData(EUSCI_B0_BASE, 0xFF);
  while (!(EUSCI_B0->IFG & EUSCI_B_IFG_TXIFG));
  X += SPI_receiveData(EUSCI_B0_BASE);
  
  Interrupt_enableMaster();
}

void InitDAC (void)
{
  // * Port init for DAC SPI communication
    // P6.3 - SCLK - SPI output
    GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_P6, GPIO_PIN3, GPIO_PRIMARY_MODULE_FUNCTION);
    // P6.4 - DATA - SIMO - SPI output
    GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_P6, GPIO_PIN4, GPIO_PRIMARY_MODULE_FUNCTION);
    // P5.7 - SYNC - GPIO output
    GPIO_setAsOutputPin(GPIO_PORT_P5, GPIO_PIN7);
    GPIO_setOutputHighOnPin(GPIO_PORT_P5, GPIO_PIN7);
  
  // * Initialize USCI_B1 for SPI master operation
    SPI_initMaster(EUSCI_B1_BASE, &spiMasterConfig);
    SPI_enableModule(EUSCI_B1_BASE);
    SPI_clearInterruptFlag(EUSCI_B1_BASE, EUSCI_SPI_RECEIVE_INTERRUPT);
}

void uWriteDAC (uint16_t value)
{
  Interrupt_disableMaster();
  
  GPIO_setOutputLowOnPin(GPIO_PORT_P5, GPIO_PIN7);
  
  while (!(EUSCI_B1->IFG & EUSCI_B_IFG_TXIFG));
  SPI_transmitData(EUSCI_B1_BASE, (value>>10)&0x3F);
  while (!(EUSCI_B1->IFG & EUSCI_B_IFG_TXIFG));
  SPI_transmitData(EUSCI_B1_BASE, value>>2);
  while (!(EUSCI_B1->IFG & EUSCI_B_IFG_TXIFG));
  SPI_transmitData(EUSCI_B1_BASE, value<<6);
  while (!(EUSCI_B1->IFG & EUSCI_B_IFG_TXIFG));
  
  GPIO_setOutputHighOnPin(GPIO_PORT_P5, GPIO_PIN7);
  
  Interrupt_enableMaster();
}


/* ISR for TimerA0 */
void TimerA0_IRQHandler(void)
{
  TIMER_A0->CCTL[0] &= ~TIMER_A_CCTLN_CCIFG;

  // Start conversion here
  P2->OUT |= BIT1;              // CONVST = 1
  
  TA1CCR0 = 280;                // Set TimerA1 to max conversion time
}

/* ISR for TimerA1 */
void TimerA1_IRQHandler(void)
{
  TIMER_A1->CCTL[0] &= ~TIMER_A_CCTLN_CCIFG;
  ConvOver = 1;                 // Set Conversion Over Flag
  TA1CCR0 = 0;                  // Halt TimerA1
}

Part Number:MSP430F67641A

Tool/software: Code Composer Studio

I am working with the MSP430F67641 dev kit from www.ti.com/.../tidm-3ph-energy5-esd

The provided example code is written for IAR, but I only have a trial license and we can't justify the large expense for continuing to use IAR - so I've been working to get the code working under Code Composer Studio.

So far I've got it to the point that it compiles and seems to run - but it looks like the ADC10 and/or DMA ISRs don't work properly. When connected to the GUI, I can get correct-looking values for the RMS current (which is processed by the SD24 routines) but the RMS voltage (from the ADC10 routines) is stuck at zero. I set up a simple variable to count the number of times each ISR runs, and the SD24 ISR seems to continue running forever, as expected, but the ADC10 and DMA ISRs stop after around 5,000 runs and do not resume.

Is there something special that the IAR code for the TIDM-3PH-ENERGY5-ESD reference meter does with the ISRs? I've not used MSP430s very much before, is there something tricky about getting the ADC10s to work reliably?

Part Number:MSP-EXP430FR2433

Hello.

Can I identify boxes from Launchpad information(including the information of device memory)?

I would like to check out Launchpad and identify what box it was contained.

Regards,

U-SK

Part Number:MSP432P401R

Hi,

I am reading about setting SPI with DMA based on  dma_eusci_spi_scatter_gather  and I have few questions.

In the example dma_eusci_spi_scatter_gather.c  the DMA sequence "spiAdcDmaSeq" in line 113, the third task initiates SPI transfer by writing data to "EUSCI_B2_SPI->TXBUF". The fourth task they read the data sent by SPI to the board (master). This process repeated three times. 

Between these tasks, there seems to be no checks mode of the SPI interrupt flags to verify that our data to transmit is staged in steps three, five, and seven. More critically, data received interrupts are not checked prior to reading the data fro the SPI slave in step four, six, and eight. This could result in false data being read from an external peripheral, which is obviously undesirable. 

Is there a way to check these flags before storing? Why has this not been done? Am I missing something?

Last thing, why TI example codes do not have comments. I think if they are commented well we don't get confused and people don't just copy and paste the code from each other. Please please add more comments.

Regards,

Bezak

Part Number:MSP430FR5994

Tool/software: Code Composer Studio

Possible create universal function for hardware?

For examle function for I2C on different eUSCI

for B1

void I2C_init(unsigned int addr,unsigned int count,unsigned int dv){
    UCB1CTLW0 = UCSWRST; // Software reset enabled
    UCB1CTLW0 |= UCMODE_3 | UCMST | UCSYNC | UCSSEL__SMCLK; // I2C mode, Master mode, sync
    UCB1CTLW1 |= UCASTP_2; // Automatic stop generated
    UCB1BRW = dv; // baudrate divider
    UCB1TBCNT = count; // number of bytes to be received
    UCB1I2CSA = addr; // Slave address
    UCB1CTLW0 &= ~UCSWRST; // clear reset register
    UCB1IE |= UCRXIE0 | UCNACKIE; //receive interrupt enable
}

for B0 or A0, or A1 - change only name register

Why create one function for differnet  eUSCI ? if use pointer to map port directly - create variable, up use memory and other overheads 

Part Number:MSP430F1611

Hi there,

we are looking into developing a new version of our product that is based on the MSP430F1611IPM. We hope to extend the battery life of our device, which is mostly used to run FFTs periodically. I was trying to see what kind of advances TI has made since this chip that may help us to reduce the power consumption. We assume that just by the manufacturing advances since its development, we should be able to make some gains.

Unfortunately I could not find any kind of overview of the MSP430 chip generations and their power consumptions nor could I find suggestions for a more modern replacement for our chip. So before I need to dig through all the datasheets to try and calculate some ballpark figures, can you point me to some kind of resource that is presentable to my management, to argue that we could get better battery lifetime with a new chip?

A statement that the our chip is still state of the art would also help.

Cheers,

Olaf

Part Number:MSP430L092

Replay to Mr. James,

Yes, there is some special reason, the ULV, I need to chose the L092.
The main reason that asm programs could not be run in my IAR system may be they are developed from CCS.,though they are all be provided from your company. There are many differences between CCS and IAR for the assembler. Is it right?
By the way, could you provide us some more examples of asm programs developed from IAR and for L092, and some programs showed Its API operation? If so, we will be easy  to master its developing.Thank you very much.
Regards,
Ruan

Appendix:

James Evans replied to Compiler/MSP430L092: How to run asm program and find API functions.

Hello,

Please check out the following threads that are related to this error. I suspect that you started with a C project and imported assembly code into it or vice versa.

Also, I would recommend updating your tools and your device. I would start by using our newest debugger, the MSP-FET, and also trying out our Code Composer Studio (CCS) IDE. Is there a specific reason that you've chosen the L092? We offer much newer, better supported devices, including some exciting ones from our FRAM family, like the MSP430FR2311.

Regards,

James

MSP Customer Applications

Part Number:EVM430-F6779

Hi,

I would like to use the EVM430-F6779 reference design and modify the code to make it compatible with my application. Given that IAR license is not free, do you have any news regarding the posting of the code available in CCS?

Kind regards,

Pau

Part Number:MSP-EXP430FR2433

Tool/software: Code Composer Studio

I need to know if this development kit:

1- can be used to work as a stopwatch for time values up to 30 seconds with highest accuracy (for instance 0.00001 s or better);

2- what is the highest accuracy of measurements?

3- it can be adapted a proper display for measured time values (at least the last measured value or the last 5-8 values);

4- it is possible to save at least 40 values?

5- it is possible to transfer these values to a PC?

Please answer to my questions by e-mail

gdf.dragan@gmail.com

I thank you in the advance for help

dragan

Part Number:MSP430F6779A

hello sir,

              i am using TI's 3 phase energy meter module  and load the code which TI provided for msp430f67791A 3 phase meter with 4 mux lcd. but in our design we are going to interface 8 mux lcd in place of yours 4 mux lcd with this 3 phase energy meter design. My problem is that my lcd does not show any display when TI code for energy meter is load in the controller msp430f67791A. here in the given code i have also done the changes for 8 mux in lcd register as shown below in place of 4 mux lcd settings. my lcd is of 36 pin having 8 common and 18 segment lines.

// given below is 4 mux lcd setting

LCDCCTL0 = LCDDIV_31 | LCDPRE_1 | LCD4MUX | LCDON;

//Charge pump generated internally at 2.96V, external bias (V2-V4) generation
//Internal reference for charge pump
LCDCVCTL = LCDCPEN | VLCD_2_60;
REFCTL0 &= ~REFMSTR;

LCDCPCTL0 = 0xFFFF; //Select LCD Segments 4-5
LCDCPCTL1 = 0xFFFF; //
LCDCPCTL2 = 0xFFFF; //;

// given below are 8 mux lcd setting which i have done for lcd display

LCDCCTL0 = LCDDIV_31 | LCDPRE_1 | LCD8MUX | LCDON;

//Charge pump generated internally at 2.96V, external bias (V2-V4) generation
//Internal reference for charge pump
LCDCVCTL = LCDCPEN | VLCD_2_96;
REFCTL0 &= ~REFMSTR;

LCDCPCTL0 = 0xFFFF;  
LCDCPCTL1 = 0x0003;

But on same time this lcd gives proper display when any LCD sample code of msp430f67791A  is load in to it, by just doing register setting for 8 mux display.

please sir suggest me solution for this.

regards,

kinjal

Part Number:EVM430-FR6047

Hello,

I followed the DSP Library example 'transform_ex1_fft_fixed_q15' to implement the use of the fast fourier transformation in my code which is supposed to take measurements and calculate the FFT (with the goal of getting the envelope by Hilbert transformation).

So far everything works fine, but only with a sample size of 128. After flashing it says: 'MSP430: Flash/FRAM usage is 40180 bytes. RAM usage is 4958 bytes.'

But with a sample size of 256 the following error occurs: "../lnk_msp430fr6047.cmd", line 257: error #10099-D: program will not fit into available memory. run placement with alignment fails for section ".leaRAM" size 0xea0 . Available memory ranges:   LEARAM       size: 0xec8       unused: 0xec8       max hole: 0xec8

But shouldn't there be plenty of memory left? The MSP430-FR6047 has 8 kB of RAM with 4 kB being shared between LEA and CPU. Am I overlooking something obvious?

The relevant code snippets would be:

Global:

#define FFTsamples 256

DSPLIB_DATA(input, MSP_ALIGN_FFT_Q15(FFTsamples)) _q15 input[FFTsamples];

In main flow:

// Fill input array with ADC Waveform
uint16_t* pUPSCap16 = (uint16_t*) (USS_getUPSPtr(&gUssSWConfig));
uint16_t c = 0;
while(c < FFTsamples) {
input[c] = *pUPSCap16;
pUPSCap16++;
c++;
}

// FFT
msp_fft_q15_params fftParams;
fftParams.length = FFTsamples;
fftParams.bitReverse = true;
msp_fft_fixed_q15(&fftParams, input);

Another question: I was wondering how, with a FFT sample size of 128 and for example only 160 available ADC samples, this code was capable of generating 128 valid FFT values. Doesn't the FFT of a real vector result in a vector of the same size, but mirrored, so only half of it is supposed to be usable? Is there some kind of interpolation involved or anything?

Best regards

Daniel

Tool/software: Code Composer Studio

Hello,

I'm not very experience with programming micro-controllers and this is the first time I have worked with the MSP430F5529.

I need to produce a square wave with a frequency of 5MHz to serve as a clock pulse for another piece of equipment that I am working with. I have set the MCLK to 25 MHz and I have raised the voltage to accommodate this clock frequency. However, when I run the following code

for(;;) {

        P2OUT ^= 0x01;


    }

P2.0 is only toggled at a frequency of 1.61 MHz. Is there anyway to iterate through this loop faster? Presumably after that speed is increased, I can set a delay using __delay_cylces() to achieve the precise frequency.

Please help me if possible. I would appreciate any advice or suggestions.

Part Number:MSP430F2274

Tool/software: TI C/C++ Compiler

I am trying to create a dynamic array and populate it with data, but in when debugging the code, the array is never populated with any data. Instead the value is consistently 0000. Attached is the code I am working with, the 

#include <msp430.h>
#include <string.h>
#include <stdlib.h>

void configWDT(void);
void configClocks(void);
void configGPIO(void);
void configTimerA(void);

static volatile unsigned char blink_cnt;
static volatile unsigned short intrp_flg;

int main(void)
{
    blink_cnt = 0;
    intrp_flg = 0;

    configWDT();
    configClocks();
    configGPIO();
    configTimerA();

    int *password = (int *)malloc(128 * sizeof(int));
    unsigned int i;
    for(i = 128; i > 0; i--) {
        password[i] = i;
    }
    __no_operation();

    while(1)
    {
        __bis_SR_register(LPM3_bits + GIE);             // Enter LPM3
        if(blink_cnt)
        {
            P1OUT ^= BIT0;
            free(password);
            __no_operation();
        }
    }
}


void configWDT(void)
{
    WDTCTL = WDTPW + WDTHOLD;
}


void configClocks()
{
    DCOCTL |= DCO1 + DCO0;
    BCSCTL1 |= XT2OFF + DIVA_3 + RSEL2 + RSEL1 + RSEL0;
    BCSCTL2 |= SELM_3 + SELS;
    BCSCTL3 |= XT2S_3;
}


void configGPIO(void)
{
    P1DIR |= 0x03;                            // P1.1 output
    P1SEL |= 0x02;                            // P1.1 option select
}


void configTimerA(void)
{
    TACCTL0 |= OUTMOD_4;                       // TACCR0 toggle mode
    TACCR0 |= 0xFFFF;
    TACTL |= TASSEL_1 + ID_3 + MC_3 + TAIE;    // ACLK, up-downmode
}


// Timer_A3 Interrupt Vector (TAIV) handler
#if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
#pragma vector=TIMERA1_VECTOR
__interrupt void Timer_A(void)
#elif defined(__GNUC__)
void __attribute__ ((interrupt(TIMERA1_VECTOR))) Timer_A (void)
#else
#error Compiler not supported!
#endif
{
    intrp_flg++;
    switch(TAIV)        // Efficient switch-implementation
    {
        case  2:
            break;                        // TACCR1 not used
        case  4:
            break;                        // TACCR2 not used
        case 10:
            if(intrp_flg % 2 == 0) {
                blink_cnt = 1;
                intrp_flg = 0;
                __bic_SR_register_on_exit(LPM3_bits);
            }
            else {
                blink_cnt = 0;
            }
            break;
    }
}

Part Number:MSP430F5529

Programmer's Guide MSP430 USB API states that the API doesn't interrupt the application to tell that a command has been received. The application uses USBMSC_pollCommand() to find that out. A paragraph in 8.5.5, says that any scsi command received by the API will not be handled (?) until USBMSC_pollCommand() is called ... My understanding is that the command IS handled by the API, it's just that if the application doesn't ask, the API will ...get stuck?. I don't know what is the set of scsi commands the API "understands", and I haven't found a listing of them. But then, there is USBMSC_handleBufferEvent(). This function seems to run every time the API has received a buffer command (read or write). So it seems to me that if code is added here to find what operation is required, process it, and modifies the returnCode, USBMSC_pollCommand() would not be required. And probably I'm wrong. Is it possible for somebody to clarify the use of these 2 functions. In the example I analyzed, USBMSC_handleBufferEvent() is empty and always returns a TRUE.

Regards

Part Number:EZ430-RF2500-SEH

Hello, I have the ez430 dev kit and the solar panel part appears to be broken. I removed the jumper, waited for it to harvest some energy, but the voltage on pins is still 0, it cannot supply the End Device. I am afraid that this part is broken. Should I return the kit or is it possible to somehow repair it by myself?

Part Number:MSP430FR5969

I am testing the accuracy of the ADC_12 on A13 using a DC power supply and I have found that the values the ADC is reading varies more than expected. I believe that the expected difference should be around +/- 0.0003 (VREF/2^12), where VREF was set to 1.2V. But I am getting values more like +/- 0.02.

I tried increasing the accuracy by increasing the sample and hold time, but that did not seem to make a visible difference. The values would still fluctuate by +/- 0.02,

The current setup I have includes:

- Sample and Hold source -> ADC12SC bit

- Clock source -> ACLK

- Clock source divider -> /1

- Clock source predivider -> Predivide by 1

- Sample and Hold Time -> 8 ADC12CLK cycles

- Multiple Sample and Conversion-> enables

- Resolution -> 12-bit

- Voltage Reference -> VR+ = VREF buffered, VR- = AVSS

- Conversion Mode Sequence -> Sequence of Channels

Would the internal reference be inaccurate with an external input? In that, would the internal reference not necessarily be stable?

If you had any recommendations or suggestions on how to improve the accuracy of the ADC, that would be appreciated. Thank you!

Part Number:MSP432P401R

Hi,

I tried the out-of-the-box demo with my newly purchased MSP432 P401R (Read) Launchpad Dev Kit. I used the online (dev.ti.com) option, and I could modify LED 2's color and Frequency as mentioned. However, after trying to setup the BoosterPack MKII which resulted in some errors, I went back to trying the out-of-the-box demo. And I observe that the LED 2 no longer turns ON, and I cannot change the color or frequency of it. Could you please let me know why this might be happening and how I can get back to the factory way ?

Attached is the GUI too . 

Please let me know,

Thanks!

Avi

Part Number:MSP-FET

The command line Flasher tool MSP430Flasher.exe can write, read, or verify various memory regions of the MSP430 chips.

The -r ("Read") qualifier is documented as follows:

If you actually specify "RAM", though, (at least for my MSP430F2618), it doesn't read through the normal RAM window (in the address range 0x1100-0x30FF where all 8KB of the RAM can be seen) but instead reads through the low-addressed RAM "mirror" (in the address range the range 0x0200-0x09FF where only 2KB is visible, even on the MSP430F2618 with its 8KB RAM).

This isn't exactly a bug; it's more like a mis-feature. And you CAN work-around it by explicitly specifying the address range to be read:

-r[...,0x1100-0x30FF]

But this came as a a surprise to me; all the other range keywords seem to know exactly how big an area to dump for each chip in the family.

1) Is this the expected behavior and 2) would you consider changing it in a future release?

Part Number:MSP430F5342

MSP430F5342"lockup" does not recover with JTAG reprogram ... But does by powering down for a time ...

I am wondering if my current issue has been seen by anyone else ...

The case on the forum is different, as my current lockup does not recover with JTAG reprogramming ...

e2e.ti.com/.../545430 lockup

... But mine does recover if the board is unplugged for a period of time (5 minutes usually does it, but it can take up to an hour).

If the board is unplugged for a minute or two, the MSP430 still exhibits the lockup.

Any thoughts on what could be causing this would be great, as can happen only once months of development work.

The only other clue is it seems to happen after power cycling the board when everything is running fine (so perhaps powering off at the wrong time triggers it?)

Regards,

Jerry