MSP430 newbie on clocks and interrupts

No answer?

Okay, after some further investigations and readings I found out that I have to use an UpMode-Counter instead of a ContinuousMode-Counter to get the required timing results of the interrupts. So my LED toggles once per second now.

But the more important question remains: what happens with the clocks? Right after hand-stopped 55 seconds LED-toggling stops even when in active mode I think:

I replaced the last four lines

while (1) {
	// LPM0 mit Interrupts
	__bis_SR_register(LPM0_bits | GIE);
	__no_operation();
}

by

for ( ; 1 != 2; ) { cmd = 1 - cmd; }

with

unsigned char cmd = 1;

Btw. I'm using Code Composer Studio v6.

Another "interesting" thing is that the clocks do not seem to disappear when application is run inside the debugger.

I'm looking for your (helpful) responses...

Kind regards
Helmut

In your first program, you made a conceptual mistake. You configured the timer to run with 25kHz. Which means that it increments with 25kHz. Then you used the overflow interrupt, to trigger an interrupt. This isn't wrong. However, the overflow appeared every 65536 ticks, thus every 2.6 seconds. Then you counted to 25000. which means, your action took place every 65536 seconds = 18.2hrs, not every second.

I don't know what changes you did to switch to up mode. Up mode requires CCR0 to be set properly.

If you use up mode and set CCR0 to 25000, then the interrupt will already happen every second, no need to count for 25000 interrupts.

It's possible that you have a racing condition in the changed code, that causes a lock-up.

Btw: it makes not much sense declaring a local variable as volatile (whether static or not). Especially not if it is local to an ISR.
Volatile tells the compiler that the content may change unexpectedly (outside the program flow) which can't happen unless you pass a reference to it to outside the ISR and also let the ISR being interrupted by another ISR that changes this variable through the reference. Definitely not an often used situation :)

Besides this, well, I personally believe that programming a timer by using these function calls is like shooting with cannons on sparrows. Yes, it may be modular, but nobody knows what the code actually does (unless you post it), so it adds another layer of obfuscation and possible bugs.

Hello Jens-Michael,

thank you for the detailled explanation of my conceptual error. What you wrote was exactly the same what I found out.
And yes, after switching to up mode and setting up the CCR0 value properly I got what I wanted...

Belonging to that volatile thing, I was desperate and so I even tried really senseless things too :-(

But one question to your notice "using these function calls is like shooting with cannons on sparrows": Do you refer to the TIMER_...() functions? They are part of TIs MSP430-API and not of my own. So I would expect a correct implementation and for a newbie their usage is much more comfortable than juggling directly with register flags.

#include <msp430.h>
/*
#include <driverlib.h>
#include <stdio.h>
#include <string.h>
*/

// #define SWITCH_ON_INIT


#define SUPPORT_LV_INT			0x01
#define SUPPORT_COMPARATOR_D	0x02
#define SUPPORT_FEEDBACK		0x80


#define MAX_MSEC	60000


/*
 * Die Liste der definierten Statuscodes
 */
enum {
	ST_OK = 0,
	ST_INFO_COUNTER_FIXED = 0,
	ST_INFO_UNUSED_BITS_NONZERO,
	ST_WARN_DOUBLE_LOW_VOLTAGE_DETECTION,
	ST_ERR_COUNTER_CORRUPT,
	ST_ERR_INVALID_POSITION_NUMBER,
};
#define MK_STATUS(x) (1 << (x))


// ============================================================================
// === Beginn der Werte im FRAM
// ============================================================================

#pragma SET_DATA_SECTION(".myFramVars")

/*
 * Die Konstante 'ucNumPositions' enthält verfügbare Anzahl von Schalterstellungen.
 * Default: 4         Offset 80, Länge 1
 */
const unsigned char ucNumPositions = 4;

/*
 * Die Konstante 'ucFeatureSet' zeigt an, welche Möglichkeiten das Relais bietet.
 *  - SUPPORT_FEEDBACK
 *  	das Relais kann die aktuelle Schalterstellung an eigenen Pins signalisieren
 *  - SUPPORT_COMPARATOR_D
 *  	am Eingang CD13 des Comparators wird erkannt, ob die Versorgungsspannung
 *  	in Ordnung ist oder unter einen zulässigen Wert abgesunken ist
 *  - SUPPORT_LV_INT
 *  	am Port 4.1 signalisiert ein externer Comparator, dass die Versorgungsspannung
 *  	zu niedrig ist
 */
// const unsigned char ucFeatureSet = SUPPORT_FEEDBACK | SUPPORT_COMPARATOR_D;
const unsigned char ucFeatureSet = SUPPORT_FEEDBACK | SUPPORT_LV_INT;
// const unsigned char ucFeatureSet = SUPPORT_FEEDBACK | SUPPORT_COMPARATOR_D | SUPPORT_LV_INT;

// Offset 82, Länge 1
const unsigned char ucDummy3 = 0;
// Offset 83, Länge 1
const unsigned char ucDummy4 = 0;

/*
 * Die Konstante 'ulMaxCounter' enthält die maximal zulässige Anzahl von Schaltzyklen.
 * Default: 5.000.000 Offset 84, Länge 4
 */
const unsigned long ulMaxCounter = 5000000;

/*
 * Die Variablen 'swCount1' bis 'swCount4' enthalten die aktuelle Anzahl aller (bisherigen) Schaltzyklen.
 * Der Wert ist direkt im FRAM abgelegt.
 * <p>Die Werte werden bei jedem erfolgreichen Schaltzyklus inkrementiert und sollten im Idealfall stets
 * gleich sein. Durch hartes Ausschalten bzw. Stromausfall könnte es sein, dass es Unterschiede bei den
 * Zählerständen gibt. Diese dürfen jedoch nicht größer als eins sein.
 */
volatile unsigned long swCount1;
volatile unsigned long swCount2;
volatile unsigned long swCount3;
volatile unsigned long swCount4;

/*
 * Die Variable 'swPosition' enthält die aktuelle Schalterstellung.
 */
volatile unsigned char swPosition;

/*
 * Die Variable 'swUptime' enthält die gesamte Betriebsdauer in Sekunden.
 */
volatile unsigned long swUptime;

#pragma SET_DATA_SECTION()

// ============================================================================
// === Ende des FRAM-Bereichs
// ============================================================================



/*
 * Diese Variable enthält den Systemstatus beim Einschalten.
 */
unsigned long ulStatus = 0;

unsigned char ucOutputPins = 0;
unsigned char ucFeedbackPins = 0;

// ============================================================================
// === "echte" Konstanten
// ============================================================================

/*
 * Arrays für das Positions-Mapping je nach Switch-Kapazitäten
 */
const unsigned char SP2T[7] = { 0, 1, 2, 0, 0, 0, 0 };
const unsigned char SP4T[7] = { 0, 2, 3, 5, 6, 0, 0 };
const unsigned char SP6T[7] = { 0, 1, 2, 3, 4, 5, 6 };

const unsigned char ucPositionMapper[7] = { 0, 0, 0, 0, 0, 0, 0 };


// ============================================================================
// === Forward-Deklarationen der Unter-Routinen
// ============================================================================


void	initBasics();
void	initTimings();
void	initGPIO();

unsigned char doSwitch(unsigned char ucContact, unsigned char ucForce);
unsigned char doHwSwitch(unsigned char ucContact);
unsigned char checkSuccess(unsigned char ucPinMask);



// ============================================================================
// === Beginn aller Funktions-Definitionen
// ============================================================================

/*
 * Main-Routine
 */
int main(void) {
	unsigned char cmd = 0, rc = 1;
	int i;

	// Watchdog Timer anhalten
	WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT
	// WDT_A_hold(WDT_A_BASE);			// Stop watchdog timer

	// Initialisierungen durchführen
	initBasics();
	initGPIO();
	initTimings();

	P2DIR |= BIT2;
	P2OUT &= ~BIT2;
	// GPIO_setAsOutputPin(GPIO_PORT_P2, GPIO_PIN2);
	// GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN2);

	// Endlos-Schleife
	while (rc != 0) {
		for (cmd = ucNumPositions; cmd > 0; cmd--) {
			rc = doSwitch(cmd, 0);
			if (rc == 0)
				break;

			__delay_cycles(480000);

//			sSleep(2);
		}
	}

	// signalisiere Error
	for (i = 0; i < 3; i++) {
		for (cmd = 1; cmd <= ucNumPositions; cmd++) {
			rc = doSwitch(cmd, 0);
			__delay_cycles(230000);
		}
	}
	// LPM0 mit Interrupts
	__bis_SR_register(LPM0_bits | GIE);

}


/*
 * Initialisierung von Clocks und Timern
 */
void initTimings() {

	CSCTL0_H = 0xA5;

	// DCO-Frequenz auf 8 MHz
	CSCTL1 = DCOFSEL0 + DCOFSEL1;             // Set max. DCO setting
    // CS_setDCOFreq(CS_DCORSEL_0, CS_DCOFSEL_3);

    //  MCLK: nutzt DCOCLK (8 MHz, Teiler 1)
	CSCTL2 = SELA_1 + SELS_3 + SELM_3;        // set ACLK = VLO, SMCLK = MCLK = DCO
	CSCTL3 = DIVA_0 + DIVS_3 + DIVM_3;        // set all dividers: ACLK = 1, SMCLK = MCLK = 8
    // CS_clockSignalInit(CS_MCLK,  CS_DCOCLK_SELECT, CS_CLOCK_DIVIDER_8);

	CSCTL0_H = 0;
}


/*
 * Basis-Initialisierung
 */
void initBasics() {
	ulStatus = ST_OK;

	// Prüfe eingestelltes FeatureSet
	if (ucFeatureSet & ~(SUPPORT_FEEDBACK | SUPPORT_COMPARATOR_D | SUPPORT_LV_INT)) {
		ulStatus |= MK_STATUS(ST_INFO_UNUSED_BITS_NONZERO);
	}
	if ((ucFeatureSet & SUPPORT_COMPARATOR_D) && (ucFeatureSet & SUPPORT_LV_INT)) {
		ulStatus |= MK_STATUS(ST_WARN_DOUBLE_LOW_VOLTAGE_DETECTION);
	}

	// Prüfe die Stellungsanzahl und richte das passende Umschalt-Mapping ein
	switch(ucNumPositions) {
		case 2:
			memcpy((void *) ucPositionMapper, SP2T, sizeof(ucPositionMapper));
			ucOutputPins = BIT0 + BIT1;
			break;
		case 4:
			memcpy((void *) ucPositionMapper, SP4T, sizeof(ucPositionMapper));
			ucOutputPins = BIT1 + BIT2 + BIT4 + BIT5;
			break;
		case 6:
			memcpy((void *) ucPositionMapper, SP6T, sizeof(ucPositionMapper));
			ucOutputPins = BIT0 + BIT1 + BIT2 + BIT3 + BIT4 + BIT5;
			break;
		default:
			ulStatus |= MK_STATUS(ST_ERR_INVALID_POSITION_NUMBER);
			break;
	}
	ucFeedbackPins = ucOutputPins << 2;

	// Prüfe Zählerstände
	if (swCount1 == swCount2) {
		if (swCount1 == swCount3) {
			if (swCount1 == swCount4) {
				// alles okay!
			}
			else {
				if ((swCount1 - swCount4) == 1) {
					swCount4 = swCount1;
					ulStatus |= MK_STATUS(ST_INFO_COUNTER_FIXED);
				}
				else {
					ulStatus |= MK_STATUS(ST_ERR_COUNTER_CORRUPT);
				}
			}
		}
		else {
			if ((swCount1 - swCount3) == 1) {
				swCount3 = swCount4 = swCount1;
				ulStatus |= MK_STATUS(ST_INFO_COUNTER_FIXED);
			}
			else {
				ulStatus |= MK_STATUS(ST_ERR_COUNTER_CORRUPT);
			}

		}
	}
	else {
		if ((swCount1 - swCount2) == 1) {
			swCount2 = swCount3 = swCount4 = swCount1;
			ulStatus |= MK_STATUS(ST_INFO_COUNTER_FIXED);
		}
		else {
			ulStatus |= MK_STATUS(ST_ERR_COUNTER_CORRUPT);
		}
	}
}


/*
 * GPIO-Initialisierung für I/O zum Relais
 */
void initGPIO() {
	// Die Pins 0-5 von Port 1 treiben die Relais-Schalter.
	P1DIR |= ucOutputPins;
	P1OUT &= ~ucOutputPins;
	// GPIO_setAsOutputPin(GPIO_PORT_P1, ucOutputPins);
	// GPIO_setOutputLowOnPin(GPIO_PORT_P1, ucOutputPins);


	// Wenn das Relais Indikatoren für die Schalterstellungen besitzt,
	// werden die Pins 2-7 von Port 2 als digitale Eingänge geschaltet.
	if (ucFeatureSet & SUPPORT_FEEDBACK) {
		P2DIR &= ~ucFeedbackPins;
		P2REN |= ucFeedbackPins;
		P2OUT &= ~ucFeedbackPins;
		// GPIO_setAsInputPinWithPullDownresistor(GPIO_PORT_P2, ucFeedbackPins);
	}
}


/*
 * Diese Funktion schaltet das Relais in die gewünschte Stellung sofern möglich,
 * aktualisiert die Laufzeitvariablen und gibt einen entsprechenden Wert zurück.
 */
unsigned char doSwitch(unsigned char ucContact, unsigned char ucForce) {
	unsigned char ucRC = 0;

	if ((ucContact != swPosition) || (ucForce == 1)) {
		// Hardware umschalten
		if (doHwSwitch(ucContact)) {
			// Werte aktualisieren
			swPosition = ucContact;
			swCount1++;
			swCount2++;
			swCount3++;
			swCount4++;

			// Erfolg signalisieren
			ucRC = 1;
		}
	}
	else if (ucContact == swPosition) {
		ucRC = 1;
	}

	return ucRC;
}


/*
 * Diese Funktion übernimmt die physikalische Ansteuerung und Umschaltung des Relais.
 *
 * 'ucContact' ist die "logische" Schalterstellung, welche intern in Abhängigkeit des
 * verwendeten physikalischen Relais in die entsprechende reale Schalterstellung
 * umgewandelt wird und dann für das Schalten und Kontrollieren weiter verwendet wird.
 */
unsigned char doHwSwitch(unsigned char ucContact) {
	unsigned char ucSuccess = 1;

	if ((ucContact > 0) && (ucContact <= ucNumPositions)) {
		unsigned char myContact = ucPositionMapper[ucContact];

		if (myContact == 0) {
			// ungültige Anschlußnummer angegeben!
			ucSuccess = 0;
		}
		else {
			unsigned char pinMask = 1 << (myContact - 1);

			// Schalter aktivieren
			P2OUT |= BIT2;
			// GPIO_setOutputHighOnPin(GPIO_PORT_P2, GPIO_PIN2);

			P1OUT &= ~pinMask;
			P1OUT |= pinMask;
			// GPIO_setOutputLowOnPin(GPIO_PORT_P1, pinMask ^ ucOutputPins);
			// GPIO_setOutputHighOnPin(GPIO_PORT_P1, pinMask);

			// kurz warten (> 15ms)
			__delay_cycles(20000);
			// Schalter wieder deaktivieren
			P1OUT &= ~pinMask;
			// GPIO_setOutputLowOnPin(GPIO_PORT_P1, pinMask);

			// Erfolg prüfen
			ucSuccess = checkSuccess(pinMask);

			P2OUT &= ~BIT2;
			// GPIO_setOutputLowOnPin(GPIO_PORT_P2, GPIO_PIN2);
		}
	}
	else {
		// ungültige Anschlußnummer angegeben!
		ucSuccess = 0;
	}

	return ucSuccess;
}


/*
 * Diese Funktion liest die Monitor-Pins des Relais aus (falls das Relais diese Funktion anbietet)
 * und vergleicht sie mit dem gewünschten Schaltzustand. Bei Erfolg wird eine 1 und bei Unstimmigkeit
 * eine 0 zurückgeliefert. Für Relais ohne Monitor-Pins wird stets Erfolg (1) signalisiert.
 */
unsigned char checkSuccess(unsigned char ucPinMask) {
	unsigned char ucSuccess = 1;

	if (ucFeatureSet & SUPPORT_FEEDBACK) {
		// Wert einlesen und überprüfen
		unsigned char ucInValue = 0, ucFinalValue = 0;

		ucInValue = P2IN;
		ucFinalValue = ucInValue & ucFeedbackPins;

		ucSuccess = (ucFinalValue == (ucPinMask << 2)) ? 1 : 0;
		// ucSuccess = GPIO_getInputPinValue(GPIO_PORT_P2, ucPinMask << 2);
	}

	return ucSuccess;
}

I stripped the application down as shown above to eliminate any race condition due to interrupts or something else. After power-up the application stopps after 27/28 seconds somewhere in the first for(;;) loop by no further relais switching and LED toggling. The second for(;;) loop is not reached.

Could you give me any hint?

Regards Helmut

PS: Your name sounds very german. So you probably can understand the comments very well.

Hello Jens-Michael,

I know that direct register manipulation needs the smallest and fastest code to get the same results. But for the first time it is a bit difficult.

Thank you for your help so far. The reason for the MCU to stop was not the software but a bug in our hardware. After fixing that the program did what I expected. So now I can focus on further application development again.

Once again thank you
Helmut