Msp430g2452 SPI digital potentiometer issue

Hey Erik!

I wrote a short program that hopefully helps to get your potentiometer running. I do not have one of those potentiometers, so I could not test it with real hardware and I do not know what type of digital potentiometer you are using, so this is more a basic approach. The code is written for the MSP430G2452 on the MSP-EXP430G2 LaunchPad. I now assumed your potentiometer has 10 bits of resolution and does not need any further command / register bits. For more information please read the comment at the top of my source code.

#FreeSampleCode

// Dennis Eichmann
// TI E2E

#include "msp430g2452.h"
#include "stdint.h"

// P1.0 output LED1 (red) on the G2 LaunchPad
// P1.1 chip select from digital potentiometer

// The program sends data to an external digital potentiometer connected via SPI using the USI module of the MSP430G2452.
// A timer interrupt is generated every 100ms - a variable inside the ISR extends the time for an action by a user selectable value that is a multiple of 100ms.
// The USI module sends 16 bits of data out of the timer ISR every second. For each next transfer, the value for the potentiometer is altered.
// Potentiometer data limits and cycle step can be set by user. The program loops incrementing and decrementing the data to it's set limits and by it's set step.
// The LED1 (red) at P1.0 on the G2 LaunchPad indicates the start of a new transmission.
//
// Note: The code assumes that the potentiometer expects a 16 bit data word with data being right aligned.
//       For a 10 bit digital potentiometer, the data is: XXXX XXMD DDDD DDDL where X is don't care, M is the MSB, L is the LSB and D are the data bits in between.
//       If there are additional command or register bits required, OR (|=) the additional data to the appropriate line inside the timer ISR.

#define POT_MIN_VAL     0                         // Minimum value
#define POT_MAX_VAL     1023                      // Maximum value for 10 bits
#define POT_STEP        64                        // 16 steps at 10 bit

#define TIMER_X_100MS   10                        // 10 x 100ms = 1s

volatile int32_t pot_value = POT_MIN_VAL;         // Digital potentiometer value

void main( void )                                 // Main
{
  WDTCTL    = (WDTPW | WDTHOLD);                  // Stop watchdog timer

  BCSCTL1   = CALBC1_1MHZ;                        // Set DCO range
  DCOCTL    = CALDCO_1MHZ;                        // Set DCO step and modulation

  P1SEL     = (0x20 | 0x40);                      // P1.5 (SCLK) and P1.6 (SDO) to USI function
  P1SEL2    = 0x00;                               // P1SEL2 bits all cleared
  P1OUT     = 0x02;                               // Set P1.1 high (deselect potentiometer), others low
  P1DIR     = (0x01 | 0x02);                      // Set P1.0 and P1.1 to output (P1.5 and P1.6 controlled from USI), others input

  USICTL0   = USISWRST;                           // Set USI module in reset state
  USICTL0  |= (USIPE6 | USIPE5 | USIMST | USIOE); // SDO, SCLK, master, output enable
  USICTL1   = (USICKPH | USIIE);                  // Data captured on 1st edge, changed on 2nd
  USICKCTL  = USISSEL_2;                          // No divider, SMCLK, inactive clock low
  USICNT    = USI16B;                             // 16 bit shift register
  USICTL0  &= ~USISWRST;                          // Release USI module from reset state
  USICTL1  &= ~USIIFG;                            // Clear pending flag

  TA0CCTL1  = CCIE;                               // Enable compare interrupt
  TA0CCR1   = 12500;                              // Compare value: 12500 results in 100ms interrupt @ 1MHz with divider 8
  TA0CTL    = (TASSEL_2 | ID_3 | MC_2 | TACLR);   // SMCLK, divider 8, continuous mode, clear

  __bis_SR_register( GIE );                       // Enable global interrupts

  while( 1 )                                      // Endless-loop (main-program)
  {
                                                  // Do nothing - all interrupt driven
  }
}


// Timer 0 A1 interrupt service routine
#pragma vector = TIMER0_A1_VECTOR
__interrupt void Timer0_A1_ISR( void )
{
  static uint8_t  cycle_counter = 0;              // Additional prescaler for timer interrupt
  static uint8_t  direction     = 1;              // Up (1) or down (0)
         uint16_t pot_data;                       // Data that is sent to the potentiometer

  switch( TA0IV )                                 // Reading TA0IV clears highest pending flag
  {
    case 2:                                       // TA0CCR1
    {
      TA0CCR1 += 12500;                           // Add CCR1 value for next interrupt
      P1OUT   &= ~0x01;                           // LED off 100ms after transmission started

      if( ++cycle_counter >= TIMER_X_100MS )      // Cycle counter reached desired count
      {
        cycle_counter = 0;                        // Clear cycle counter

        pot_data = pot_value;                     // Copy potentiometer value to potentiometer data variable

        if( direction )                           // Cycle up
        {
          pot_value += POT_STEP;                  // Increment potentiometer value by defined step

          if( pot_value >= POT_MAX_VAL )          // Reached maximum
          {
            pot_value = POT_MAX_VAL;              // Limit to maximum
            direction = 0;                        // Next cycle down
          }
        }
        else                                      // Cycle down
        {
          pot_value -= POT_STEP;                  // Decrement potentiometer value by defined step

          if( pot_value <= POT_MIN_VAL )          // Reached minimum
          {
            pot_value = POT_MIN_VAL;              // Limit to minimum
            direction = 1;                        // Next cycle up
          }
        }

        //pot_data |= <any_command>;              // Add command or register data if necessary

        P1OUT  |= 0x01;                           // LED on to signal start of data transfer
        P1OUT  &= ~0x02;                          // Chip select of potentiometer low (selected)
        USISR   = pot_data;                       // Copy potentiometer data to shift register
        USICNT |= 16;                             // Start sending 16 bits
      }

      break;
    }

    default: break;
  }
}


// USI interrupt service routine
#pragma vector = USI_VECTOR
__interrupt void USI_ISR( void )
{
  USICTL1 &= ~USIIFG;                             // Clear pending flag
  P1OUT   |= 0x02;                                // Chip select of potentiometer high (deselected)
}

The code works, as I can see from the oscilloscope pictures, but I do not know if your potentiometer just needs the value without any further command or register address, so this might not be plug and play for you.

The yellow trace is the red LED1 on P1.0 that is set each time a transmission starts. It turns off after 100ms (interval of the timer interrupt) which is much longer than the transmission, so you do not see it turn off on the scope screen. The blue trace is chip select on P1.1, the purple trace is the clock signal and the green trace is SDO. In this picture the value 768d (0000 0011 0000 0000) is transmitted.

The following two pictures show only LED1 at P1.0 and you can see that a) a transmission starts every second and b) the LED1 turns on for 100ms each time a transmission is started.

Dennis