Electronic – Use of global variables in Embedded Systems

cembeddedfirmware

I started writing firmware for my product and I'm a rookie here. I went through many articles about not using global variables or functions. Is there any limit for using global variables in an 8 bit system or is it a complete 'No-No'. How should I use global variables in my system or should I completely avoid them?

I would like to take valuable advice from you guys on this topic to make my firmware more compact.

Best Answer

You can use global variables successfully, as long as you keep in mind @Phil's guidelines. However, here are some nice ways to avoid their issues without making the compiled code less compact.

Use local static variables for persistent state that you only want to access inside one function.

#include <stdint.h>
void skipper()
{
    static uint8_t skip_initial_cycles = 5;
    if (skip_initial_cycles > 0) {
        skip_initial_cycles -= 1;
        return;
    }
    /* ... */
}

Use a struct to keep related variables together, to make it clearer where they should be used and where not.

struct machine_state {
     uint8_t level;
     uint8_t error_code;
} machine_state;

struct led_state {
    uint8_t red;
    uint8_t green;
    uint8_t blue;
} led_state;

void machine_change_state()
{
    machine_state.level += 1;
    /* ... */
    /* We can easily remember not to use led_state in this function. */
}

void machine_set_io()
{
    switch (machine_state.level) {
    case 1:
        PIN_MACHINE_IO_A = 1;
        /* ... */
    }
}

Use global static variables to make the variables visible only within the current C file. This prevents accidental access by code in other files due to naming conflicts.

/* time_machine.c */
static uint8_t current_time;
/* ... */

/* delay.c */
static uint8_t current_time; /* A completely separate variable for this C file only. */
/* ... */

As a final note, if you are modifying a global variable within an interrupt routine and reading it elsewhere:

Mark the variable volatile.
Make sure it is atomic for the CPU (i.e. 8-bit for an 8-bit CPU).

Use a locking mechanism to protect access to the variable.

Related Solutions

Electronic – USART transmit problems on a PIC

It's a little confusing that the code in the question differs to the code in pastebin - but assuming that the pastebin code is correct, I'd say that the problem is that you're sending uninitialised data from the array instead of the characters that you put in it.

TXREG = TXBuffer[TXEndPos];           // send next byte

should be

TXREG = TXBuffer[TXCurrentPos];           // send next byte

It's important to copy/paste the code directly (using pastebin is great!) because you've actually corrected this yourself in the question - making it hard for people to spot the problem :)

This may have been easier to spot yourself if you initialised the buffer to a known value on startup (eg 0x5A).

You also mention that you reset the TxCurrentPos & TxEndPos variables to zero at some point, but I can't see that in your code. It's best to do this whenever you increment those values. Eg

TxCurrentPos++;
TxCurrentPos %= TX_BUFFER_SIZE;

Aside: I like that you've removed the redundant TxBufferSize variable in the question - this follows the DRY Principle and eliminates the source for an error. Having data duplicated in two spots is asking for trouble.

Electronic – Best practice to keep main() in embedded systems

If you're concerned that code for a simple switch() based state machine (SM) will become untidy, you can split it into smaller subroutines.

void do_state_s1() {
    // stuff
    if ( /* certain  contidition */ ) {
        g_iState = STATE_S2;  // transition to another state
    }
}

void do_state_s2()  {
    // other stuff
    if ( /* some other condition */ ) {
        g_iState = STATE_S1;
    }
}

void do_state_machine() {
    switch (g_iState) {
    case STATE_S1:
        do_state_s1();
        break;

    case STATE_S2:
        do_state_s2();
        break;
    };
}

void main() {
    g_iState = STATE_S1;        // initialize the SM

    while (1) {
        do_state_machine();
    }
}

Best Answer

Related Solutions

Electronic – USART transmit problems on a PIC

Electronic – Best practice to keep main() in embedded systems

Related Topic