The Basics

A state machine is a programming paradigm that divides the execution flow into distinct states, each with its specific set of operations. By utilizing a switch statement and an enum to represent states, you can easily differentiate and manage various code execution blocks.

A firmware based on state machine has some advantages:

• Modularity: Break down complex functionalities into manageable states, enhancing code readability and maintainability.
• Efficiency: Switch statements allow for concise, efficient code to handle every state.
• Scalability: Easily incorporate new states or modify existing ones without changing the entire codebase.

Practical Implementation

This is an example of a state machine that initializes two variables, foo1 and foo2. The transition from state A to B occurs if foo1 is a multiple of 3; otherwise, it moves to state C.

int main( void ) {
	// State machine description variable. Initial state is: e_INIT
	static enum { e_INIT,
					  e_STATE_A,
					  e_STATE_B,
					  e_STATE_C
					} xState = e_INIT;
	int foo1, foo2;					// vars used for this example

	while( 1 ) {
		switch( xState ) {
			case e_INIT:			// init state
				foo1 = 5;
				foo2 = 8;
				xState = e_STATE_A;
				break;

			case e_STATE_A:			// state A
				foo1++;

				if( foo1 % 3 == 0 ) {	// multiple of 3
					xState = e_STATE_B;
				}

				else {					// NOT multiple of 3
					xState = e_STATE_C;
				}

				break;

			case e_STATE_B:			// state B
				foo2++;
				xState = e_STATE_A;
				break;

			case e_STATE_C:			// state C
				foo2--;
				xState = e_STATE_A;
				break;

			default:				// safety state
				xState = e_INIT;
				break;
		}
	}

	return;
}

Implementation in a Real-Time Operating System (RTOS)

This state machine strategy is versatile and can be integrated within a single task in an RTOS-based system. Efficient management of complex tasks is achieved by structuring operations through a state machine. This allows each task to run an independent state machine, enhancing modularity and clarity in task execution.

Conclusion

In conclusion, implementing a state machine is a powerful strategy in firmware engineering. It enhances code organization, readability, and scalability, making the firmware robust and efficient.

Understanding Multiplexing

Multiplexing is a method that enables the control of multiple LEDs using fewer pins on a microcontroller or other controlling devices. It involves rapidly switching between different LEDs, creating the illusion that they are all active simultaneously. Two common methods of LED multiplexing are Time Division Multiplexing (TDM) and Single LED multiplexing (also known as “Charlieplexing”).

Practical Implementation

The circuit implementation for both methods (TDM and SLM) is the same.

The firmware implementation is simpler for TDM compared to SLM. Here, you can see how, for SLM, the activation of each individual LED is optimized, resulting in a variable display period for the entire matrix, depending on the number of LEDs to be illuminated.

#define ROW_COUNT 6				// Number of LEDs row
#define TDM_CYCLE_TIME 1000		// Time in microseconds for one TDM cycle

void loop() {					// TDM loop
	for( uint8_t i = 0; i < ROW_COUNT; ++i ) {
		setPIN( ledPins[i], HIGH );				// Activate the current LED
		delay_ms( TDM_CYCLE_TIME / ROW_COUNT );	// Delay for the LED's time slot
		setPIN( ledPins[i], LOW );				// Deactivate the current LED
	}
}

#define ROW_COUNT 6				// Number of LEDs row
#define COL_COUNT 3				// Number of LEDs column
#define LED_COUNT 18			// Number of LEDs
#define SLM_CYCLE_TIME 1000		// Time in microseconds for one SLM cycle

void loop() {					// SLM loop
	for( uint8_t i = 0; i < LED_COUNT; ++i ) {
		for( uint8_t j = 0; j < LED_COUNT; ++j ) {
			if( ledPins[j][i] == true ) {
				setPIN( ledPins[j][i], HIGH );	// Activate the current LED
				delay_ms( SLM_CYCLE_TIME );		// Delay for the LED's time slot
				setPIN( ledPins[j][i], LOW );	// Deactivate the current LED
			}
		}
	}
}

Conclusion

Choosing between TDM and SLM depends on the specific requirements of your application. For low power / high efficiency projects with a limited number of LEDs, SLM might be the go-to choice. On the other hand, for more ambitious projects with a vast array of LEDs, TDM offers a simpler firmware matrix management.

One of the key challenges in designing low power devices is to minimize power consumption, especially in battery-powered applications. The use of Peripheral Module Disable (PMD), that is for example available on the PIC16F18313 microcontroller, is useful to achieve significant power savings in embedded systems.

Understanding PMD

The PMD feature allows users to selectively disable specific hardware modules within the microcontroller. By doing so, all clock and control inputs to the module are suspended, preventing logic transitions and ensuring the module remains inactive. This means that when a module is not in use, it draws virtually no power.

Practical Implementation

Here’s an example (code snippet) of how to implement peripheral management at the driver level for optimal power management.

static void vUtil_Sleep_Management( void ) {
	bool going_to_sleep_flag;				// flag to manage sleep loop exit condition
	pushStat_t pushStat;

	do {									// sleeping loop
		vUtil_TMR0_PrepareForSleep();
		vUtil_StatLED_PrepareForSleep();
		__delay_ms( PUSH_MAX_DETECT_LONG );	// delay before going to sleep to avoid fast re-poweron
		/**/
		SLEEP();							// SLEEP until IRQ occurs on INT0 (PUSH)
		/**/
		__delay_us( 1000 );					// startup time...
		pushStat = xRead_PushButton_Status();

		if( pushStat != e_PUSHSTAT_PRESSED ) {	// if no correct pushbutton status detected...
			going_to_sleep_flag = true;		// go again in sleep mode
		}

		else {								// else pushbutton has correct status
			going_to_sleep_flag = false;	// clear the flag to exit from sleep loop
			vUtil_TMR0_ResumeFromSleep();
			vUtil_StatLED_ResumeFromSleep();
		}
	}
	while( going_to_sleep_flag == true ); 	// loop until going_to_sleep_flag is FALSE

	return;
}

static void vUtil_TMR0_PrepareForSleep( void ) {
	TMR0_StopTimer();
	PIE0bits.TMR0IE = 0;			// Disabling TMR0 interrupt.
	PMD1bits.TMR0MD = 1;			// Timer TMR0 module disabled
	return;
}

static void vUtil_TMR0_ResumeFromSleep( void ) {
	vInit_TMR0();
	return;
}

Conclusion

The PMD feature provides granular control over power consumption by deactivating only the modules that are not currently needed, this is a significant advantage for applications where minimizing power consumption during idle periods is crucial for extending battery life or reducing overall energy usage. These are two significant advantages:

1. Intelligent power management could be implemented by firmware at driver-level code. For example, if a certain sensor or communication interface is only required on-demand, it can be turned off during idle periods.
2. Standby Mode and Interrupts: In scenarios where the CPU is in standby mode, PMD provides the ability to turn off all the unused peripherals and leave only the essential interrupts enabled.

The challenge: Fast calc on 8-bit CPU

In the realm of low-power microcontrollers, performing complex calculations can become a significant challenge. 8-bit microcontrollers are characterized by limited resources: executing complex mathematical calculations directly on the CPU can be inefficient and slow.

The Solution: Lookup Tables

Instead of dynamically calculating values each time they are needed, results are stored in an array in flash memory. When a value is required, the microcontroller accesses the table directly, eliminating the need for complex calculations on the CPU.

Practical Implementation

Determine the mathematical functions to be addressed and create a mapping table with the corresponding precalculated values (in this example, the logarithm function is utilized).

12 points approximation

uint16_t array [12] = {
1,	2,	4,		7,	12,	23,	43,	81,	152,	285,	534,	1000};

34 points approximation

uint16_t array [32] = {
1,	1,	2,	2,	2,	3,	4,	4,	5,	7,	8,	10,	12,	15,	19,	23,	28,	35,	43,	53,	66,	81,	100,	123,	152,	187,	231,	285,	351,	433,	534,	658,	811,	1000};

100 points approximation

uint16_t array [100] = {
1,	1,	1,	1,	1,	1,	2,	2,	2,	2,	2,	2,	2,	2,	3,	3,	3,	3,	4,	4,	4,	4,	5,	5,	5,	6,	6,	7,	7,	8,	8,	9,	9,	10,	11,	11,	12,	13,	14,	15,	16,	17,	19,	20,	22,	23,	25,	27,	28,	31,	33,	35,	38,	40,	43,	46,	50,	53,	57,	61,	66,	71,	76,	81,	87,	93,	100,	107,	115,	123,	132,	142,	152,	163,	175,	187,	201,	215,	231,	248,	266,	285,	305,	327,	351,	376,	404,	433,	464,	498,	534,	572,	614,	658,	705,	756,	811,	870,	933,	1000};

/* returns value of LOG using lookup table  */
uint16_t calc_log( uint8_t value) {
	if( value >= sizeof( array ) ) {	// sanity check for value out of range
		return array[sizeof( array ) - 1];

	} else { 				// pick value from lookup table
		return array[value];
	}
}

Conclusion

Lookup Tables is a powerful programming trick: this technique not only enhances performance but also allows for more efficient resources management, making embedded systems more responsive and efficient.