He estado desarrollando un software integrado basado en RTOS en C y he encontrado un problema con respecto al acceso a recursos compartidos desde varios subprocesos. Tengo dos problemas El primero es establecer y obtener un valor de variable de estado en la máquina de estados. A continuación se muestra el archivo de encabezado para el "objeto" de StateMachine:

typedef enum{
  STATE_01,
  STATE_02,
  STATE_03,
  STATE_04
}state_e;

// state machine instance
typedef struct{
  state_e currState;
}StateMachine;

extern state_e GetState(StateMachine*);
extern void SetState(StateMachine*, state_e);

a implementación de los métodos de acceso es la siguiente:

state_e GetState(StateMachine *sm){
  return sm->currState;
}

void SetState(StateMachine *sm, state_e state){
  sm->currState = state;
}

Mi problema es que no estoy seguro de si debo usar un mutex para controlar el acceso a la variable de estado. Quise decir que leer y escribir variables de 32 bits en MCU de 32 bits es una operación atómica.

El segundo problema se refiere a la lectura del valor de un elemento de una matriz que contiene los enteros de 32 bits sin signo donde cada bit almacena un valor de una variable de un bit. De nuevo, no estoy seguro de si es necesario usar un mutex. Por el mismo motivo que el anterior, creo que no, pero me gustaría escuchar la opinión de algún programador más experimentado. El archivo de encabezado asociado para el "objeto" de la matriz de bits:

typedef struct{
  uint32_t BitsArray[NO_WORDS];
}BitsArray;

extern uint32_t GetWordValue(BitsArray*, uint8_t);

La implementación del método de acceso:

uint32_t GetWordValue(BitsArray *ba, uint8_t word){
 return *(ba->BitsArray + word);
}

Gracias por cualquier idea