MSP430 circuit to measure and trick 1997 Jetta LD Pump

ldpump_tester.c

/* 1997 Volkwagen Jetta LD Pump Circuit tester/bypasser
 * Trevor Bentley, September 2011
 *
 *
 * Operation:
 *  - Displays welcome message on boot
 *  - Dumps 256 bytes of Informational Flash (if UART enabled)
 *  - Enters very low power state while waiting
 *  - Wakes up when a falling edge detected on P1.4, which should go to
 *    the power output of the ECM to the LD Pump solenoid.  This requires
 *    extra circuitry.
 *  - Measures each edge as a 'pump', counts number of pumps.
 *  - Red LED (P1.0) blinks rapidly while pumping
 *  - When reach target number of pumps (PUMP_TARGET), green LED (P1.6) 
 *    turns on, and SENSE line is pulled high (P1.5).  This is held for 
 *    SENSE_LINE_SECONDS.
 *  - Measured total number of pumps, and time to reach target number
 *    of pumps.
 *  - Red and Green LEDs both on while measurements written to Informational
 *    Flash.
 *  - Most recent measurements displayed (if UART enabled)
 *  - Back to very low power state while waiting.
 *
 *
 *
 * EXAMPLE CIRCUIT:
 *
 *                         BAT(-)-----------------------
 *                         BAT(+)-----------[3.3REG]   |
 *                                    |            |   |
 * [C    VCC]--|-^^^|--[  opto  ]--^^^|----[P1.4        ]
 * [A       ]  _    >  [isolator]          [        P1.0] - Red LED
 * [R       ]  ^    >  [        ]          [        P1.6] - Green LED
 * [        ]  |    >  [        ]          [            ]
 * [E    GND]--|----|--[        ]          [      MSP430]
 * [C       ]                              [            ]
 * [M  SENSE]---^^^-----[transistor]-------[P1.5        ]
 *                       |  |
 *        BAT(+)----^^^-/    \--BAT(-)
 *
 *
 * MSP430 powered by 3.3V regulator off of constant battery power.
 *
 * Car ECM connects to optoisolator via voltage divider (divide to 3V, 
 * and current limit).  Safety diode from ground to power.  Optoisolator 
 * connects to P1.4, pulled up to constant battery power.  Car ECM will
 * switch either VCC or GND on and off to pump the LD Pump, which this
 * circuit replaces.  This will result in toggling on P1.4.
 *
 * P1.5 controls base of transistor that pulls sense line up to constant
 * battery power.
 *
 */
#include  <msp430x22x2.h>
#include <signal.h>
#include <string.h>

//------------------------------------------------------------------------------
// Hardware-related definitions
//------------------------------------------------------------------------------
#define UART_TXD   0x02      // TXD on P1.1 (Timer0_A.OUT0)
#define UART_RXD   0x04      // RXD on P1.2 (Timer0_A.CCI1A)
#define LDPUMP     0x10      // LDPump detect P1.4               
#define SENSE      0x20      // Sense Line P1.5

#define RED_LED    0x01      // Red LED
#define GREEN_LED  0x40      // Green LED

//#define TEST_VALS
#ifndef TEST_VALS
#define SENSE_LINE_SECONDS 90U  // Seconds to hold SENSE line
#define PUMP_TARGET 30U         // Number of 'pumps' to detect
#else
#define SENSE_LINE_SECONDS 4U
#define PUMP_TARGET 10U
#endif

#define CLOCK_DIV          (10U)
#define MS_PER_TICK        (10*CLOCK_DIV) // Milliseconds per clock interrupt
// Number of clock interrupts to hold SENSE line for.
#define SENSE_TICKS        (SENSE_LINE_SECONDS * (1000 / MS_PER_TICK))

// Base address of Informational Flash
#define INFO_FLASH_BASE     0x1000

//------------------------------------------------------------------------------
// Conditions for 9600 Baud SW UART, SMCLK = 1MHz
//------------------------------------------------------------------------------
#define UART_ENABLED
#ifdef UART_ENABLED
#define UART_TBIT_DIV_2     (1000000U / (9600 * 2))
#define UART_TBIT           (1000000U / 9600)
#endif

//------------------------------------------------------------------------------
// Global variables used for full-duplex UART communication
//------------------------------------------------------------------------------
#ifdef UART_ENABLED
unsigned int txData = 0;                        // UART internal variable for TX
unsigned char rxBuffer = 0;                     // Received UART character
#endif

// Structure for storing measurements
typedef struct {
  unsigned int pump_count;
  unsigned int timer_count;
} measure_t;
// Number of elements in measurements[]
#define MEASUREMENT_COUNT (64/sizeof(measure_t))
// Mask for wrapping measurements[] index
#define MEASUREMENT_MASK (MEASUREMENT_COUNT-1)
// Array of measurement readings
measure_t measurements[MEASUREMENT_COUNT];
// Index of current measurement
unsigned int measurement_idx = 0;


// State machine variable
volatile enum tstate {
  WAITING,
  PUMPING,
  HOLDING,
  UARTTX
} timer_state = WAITING;

// LUT for hex characters
unsigned char hexvals[] = {
  '0','1','2','3','4','5','6','7',
  '8','9','A','B','C','D','E','F',
};


volatile unsigned int counter = 0; // Timer interrupt ticks
volatile unsigned int toggles = 0; // Toggles of pumps
volatile unsigned int counter_cycles_until_stop = 0; // IRQ ticks until done


//------------------------------------------------------------------------------
// Function prototypes
//------------------------------------------------------------------------------
void reset_ldpump(void);
void erase_flash(int addr);
void save_byte(char byte, char flash_offset);
void save_measurements(void);
void end_sense_hold(void);
void TimerA_Counter_init(void);
void Port1_ISR(void);
void Timer_A0_ISR(void);

#ifdef UART_ENABLED
void print_values(void);
void uart_isr(void);
void TimerA_UART_init(void);
void TimerA_UART_tx(unsigned char byte);
void TimerA_UART_print(char *string);
void TimerB_ISR(void);
#endif


//------------------------------------------------------------------------------
// main()
//------------------------------------------------------------------------------
void main(void)
{
#ifdef UART_ENABLED
  int temp;
  int i;
  char str[4];
#endif

  // Configure clocks
  WDTCTL = WDTPW | WDTHOLD;               // Stop watchdog timer
  DCOCTL = 0x00;                          // Set DCOCLK to 1MHz
  BCSCTL1 = CALBC1_1MHZ;
  DCOCTL = CALDCO_1MHZ;

  // Configure Port 1
  P1OUT = 0x00;                           // Initialize all GPIO
  P1DIR = 0xFF & ~(UART_RXD | LDPUMP);    // Set all pins but RXD to output
#ifdef UART_ENABLED
  P1SEL = UART_TXD | UART_RXD;            // Timer function for TXD/RXD pins
#endif

  // P1.4 is interrupt -- LD Pump solenoid line
  P1IE  = 0x10; // Turn on P1.4 interrupts
  P1IES = 0x10; // High->low edge detect
  P1REN = 0x10; // Pull-down resistor enabled

  // Clear measurements
  memset(measurements, 0xFF, sizeof(measurements));

  eint(); // Enable interrupts

#ifdef UART_ENABLED
  // Print 256-bytes of informational flash
  TimerA_UART_init();
  TimerA_UART_print("\r\nLDP-TEST\r\n");
  str[2] = ' ';
  str[3] = 0;
  for (i = 0; i < 256; i++) {
    temp = *((volatile char*)INFO_FLASH_BASE+i);
    str[0] = hexvals[temp >> 4 & 0xF];
    str[1] = hexvals[temp & 0xF];
    TimerA_UART_print(str);
  }
  TimerA_UART_print("\r\n$$$%%%$$$\r\n\r\n");
#endif

  // Enable pump detector
  TimerA_Counter_init();

  for (;;)
  {
    // Sleep in super-low-power-mode
    LPM3;
    // Go to moderate-low-power-mode after PIO wakes us up
    LPM0;

    // Awoken after a pump session has finished and written to flash.
    // Print status (if enabled), and reset state machine
#ifdef UART_ENABLED        
    print_values();
#endif
    reset_ldpump();
  }
}

// Write entire 'measurements' variable to information flash (erases first)
// Manages interrupts itself.  Do NOT disable.
void save_measurements(void) {
  int i;
  static int count = 0;
  static int offset = 0;
  unsigned char *p = (unsigned char*)measurements;

  dint();

  FCTL3 = FWKEY; // Unlock

  FCTL1 = FWKEY | ERASE ; // Erase
  *((volatile char*)(INFO_FLASH_BASE + offset)) = 0;
  FCTL1 = FWKEY | WRT; // Write
  memcpy((void*)(INFO_FLASH_BASE + offset + i), p, 
	 sizeof(measurements));
  FCTL1 = FWKEY; // No-op
  FCTL3 = FWKEY | LOCK; // Lock
  
  // If we've written a full block...
  if (++count == MEASUREMENT_COUNT) {
    count = 0;
    // Clear measurements
    memset(measurements, 0xFF, sizeof(measurements));
    // Next time, write to next block of FLASH.  We have 3 64-byte blocks.
    offset += 0x40;
    if (offset == 0xc0) offset = 0;
  }

  eint();

}

void reset_ldpump(void) {
  // Reset counters and state
  counter = 0;
  toggles = 0;
  counter_cycles_until_stop = 0;
  timer_state = WAITING;
  P1OUT &= ~(RED_LED | GREEN_LED | SENSE); // Disable lights and sense
}

//------------------------------------------------------------------------------
// Turn on timer, interrupt ticks every 10ms
// Interrupt shared with UART, so only one can be enabled at a time.
//------------------------------------------------------------------------------
void TimerA_Counter_init(void) {
  // Configure Timer_A
  // Internal 1MHz timer divided by 8 (ID_3) == 125000 / s
  // (12500 ticks/s) / 100 == 1250 ticks per 10 ms
  // One interrupt per 10*CLOCK_DIV ms.
  TACTL = MC_0; // Disable timer
  TACCR0 = 1250*CLOCK_DIV; // ticks per interrupt
  TACCTL0 = CCIE | OUTMOD_7; // Enable interrupts, reset on overflow
  timer_state = WAITING;
  TACTL = TASSEL_2 | MC_1 | TACLR | ID_3; // Set to 1MHz clock, turn on
}

//------------------------------------------------------------------------------
// Interrupt when edge detected on P1.4, signifying switching
// on LD Pump solenoid line.
//------------------------------------------------------------------------------
interrupt(PORT1_VECTOR) Port1_ISR(void) {
  if (timer_state == WAITING) {
    // We were waiting in super-low-power mode.  Wake up!
    LPM3_EXIT;
    // No longer waiting, it's pump time
    timer_state = PUMPING;
  }
  else if (++toggles == PUMP_TARGET) {
    // We reached our target number of pumps, so trigger SENSE line.
    P1OUT |= SENSE | GREEN_LED;
    P1OUT &= ~(RED_LED);
    counter_cycles_until_stop = SENSE_TICKS;
    timer_state = HOLDING;
  }

  P1IFG = 0x00;
}

void end_sense_hold(void) {
  volatile int i;
  P1OUT |= RED_LED;
  measurements[measurement_idx].pump_count = toggles;
  measurements[measurement_idx].timer_count = counter;
  measurement_idx = (measurement_idx + 1) & MEASUREMENT_MASK;
  save_measurements();
  P1OUT &= ~RED_LED;
}

//------------------------------------------------------------------------------
// Timer_A UART - Transmit Interrupt Handler
//------------------------------------------------------------------------------
enablenested interrupt (TIMERA0_VECTOR) Timer_A0_ISR(void)
{
    static unsigned char txBitCnt = 10;

    switch (timer_state) {
    case WAITING: // Waiting to detect first pump from ECM
      break;
    case PUMPING: // Pumps detected, counting to target number
      // Increment counter, toggle LED
      if (++counter)
	P1OUT ^= RED_LED;
      break;
    case HOLDING: // Target number of pumps reached, holding SENSE line
      if (--counter_cycles_until_stop == 0) {
	end_sense_hold();
	// Wake up main.  It will print status and reset state machine
	LPM0_EXIT;
      }
      break;
#ifdef UART_ENABLED
    case UARTTX:
      goto uart;
#endif
    default:
      break;
    }
    return;

#ifdef UART_ENABLED
 uart:
    TACCR0 += UART_TBIT;                    // Add Offset to CCRx
    if (txBitCnt == 0) {                    // All bits TXed?
        TACCTL0 &= ~CCIE;                   // All bits TXed, disable interrupt
        txBitCnt = 10;                      // Re-load bit counter
    }
    else {
        if (txData & 0x01) {
          TACCTL0 &= ~OUTMOD2;              // TX Mark '1'
        }
        else {
          TACCTL0 |= OUTMOD2;               // TX Space '0'
        }
        txData >>= 1;
        txBitCnt--;
    }
#endif
}      

#ifdef UART_ENABLED
void print_values(void) {
  unsigned char mstr[10];
  TimerA_UART_init();   
  mstr[0] = hexvals[toggles >> 12 & 0xF];
  mstr[1] = hexvals[toggles >>  8 & 0xF];
  mstr[2] = hexvals[toggles >>  4 & 0xF];
  mstr[3] = hexvals[toggles       & 0xF];
  mstr[4] = ' ';
  mstr[5] = hexvals[counter >> 12 & 0xf];
  mstr[6] = hexvals[counter >>  8 & 0xF];
  mstr[7] = hexvals[counter >>  4 & 0xF];
  mstr[8] = hexvals[counter       & 0xF];
  mstr[9] = 0;
  TimerA_UART_print(mstr);
  TimerA_UART_print("\r\n\r\n");
  TimerA_Counter_init();
}

//------------------------------------------------------------------------------
// Function configures Timer_A for full-duplex UART operation
//------------------------------------------------------------------------------
void TimerA_UART_init(void)
{
    TACTL = MC_0; // Disable timer
    TACCTL0 = OUT;                          // Set TXD Idle as Mark = '1'
    TACCTL1 = SCS + CM1 + CAP + CCIE;       // Sync, Neg Edge, Capture, Int
    timer_state = UARTTX;
    TACTL = TASSEL_2 + MC_2 + TACLR;        // SMCLK, start in continuous mode
}

//------------------------------------------------------------------------------
// Outputs one byte using the Timer_A UART
//------------------------------------------------------------------------------
void TimerA_UART_tx(unsigned char byte)
{
    while (TACCTL0 & CCIE);                 // Ensure last char got TX'd
    TACCR0 = TAR;                           // Current state of TA counter
    TACCR0 += UART_TBIT;                    // One bit time till first bit
    TACCTL0 = OUTMOD0 + CCIE;               // Set TXD on EQU0, Int
    txData = byte;                          // Load global variable
    txData |= 0x100;                        // Add mark stop bit to TXData
    txData <<= 1;                           // Add space start bit
}

//------------------------------------------------------------------------------
// Prints a string over using the Timer_A UART
//------------------------------------------------------------------------------
void TimerA_UART_print(char *string)
{
    while (*string) {
        TimerA_UART_tx(*string++);
    }
}
//------------------------------------------------------------------------------
// Timer_A UART - Receive Interrupt Handler
//------------------------------------------------------------------------------
interrupt (TIMERA1_VECTOR) Timer_A1_ISR(void)
{
}
//------------------------------------------------------------------------------
#endif //UART_ENABLED

Makefile

all: default run

default:
	msp430-gcc -I/usr/local/msp430-gcc-4.4.3//msp430/include/ ldpump_tester.c -save-temps -mendup-at=main -mmcu=msp430x2111 -Os

run:
	mspdebug rf2500 "prog a.out"

dump:
	mspdebug rf2500 "md 0x1000 256"

erase_info:
	mspdebug rf2500 "erase segment 0x1000"