Array in Case Statement - c++

Question

I am having trouble using an array for case statement for my state machine. Most sites mention that an array cannot be used for case statements so i have been trying a work around for it but so far it has been unsuccessful. I would really appreciate any help or suggestions for this. For Clarification: I do not want to hard code the states, i am trying to make the program in such a way that if the user only changes the order in the fsm_state_array[] the program would execute in that order only without changing anything else in the void loop().
Here is what i have tried so far, i have used functions to hard code to check previous state, current state and next state when the user enters their sequence of states in an array , so in my code below the states should go from 0 --> 2 --> 3--> 1 , however , i get 0 --> 2 --> 1 --> 3. I know this problem can be easily solved if i just use the array in the case statement but the compiler gives me an error. I would really appreciate any help or suggestions for this.
My code is shown below :
//Objectives: Use input from laser to control pre-amp on adc. Multiplex the inputs on Pre-Amp
//Type: Pulse, Freq:20Hz (50ms), Amp:5.0 Vpp, Offset:500mV, Width = 100ns
//-----------------------PROJECT LIBRARIES----------------------------------
#include <Bounce2.h>
#include <Arduino.h>
#include <avr/io.h>
#include <avr/wdt.h>
#include <avr/interrupt.h>
//-----------------------DEFINES------------------------------------------
//Declare Laser Input Pin
#define LASER_PIN 2
//Declare Reset Pin
#define RESET_PIN 3
typedef enum {
STATE_0,
STATE_1,
STATE_2,
STATE_3
} fsm_state;
//User can change or remove states here
fsm_state fsm_state_Array[] = {STATE_0, STATE_2, STATE_3, STATE_1};
//*eNextstate controls on which state the program starts the state machine, default is STATE_00, Must be same value as Transition_State[0]
fsm_state eNextState = fsm_state_Array[0];
int Current_State = 0;
int Next_State = 0;
int Previous_State = 0;
// -------------------------CONSTANTS (won't change)-------------------------------------
const unsigned long period = 1000; //the value is a number of milliseconds
//-------------------------VARIABLES (will change)-------------------------------------
bool only_for_print = false;//used only for print state ments
int reset_switch = 1;//Start HIGH to avoid reset
int PulseCount = 0; //Pulse count from X-RAY
int Output = 0;//Switch state on the Pre-Amp
int wait = 0;//wait for pulses count
int N = 20;//no. of pulses to count before switching states
volatile int IRQcount = 0;
volatile boolean reset_flag = false;
unsigned long start_time = 0;
unsigned long current_time = 0;
//----------------------------USER DEFINED FUNCTIONS---------------------------------
void fsm();
void loop();
void setup();
void WDT_RESET();
void IRQcounter();
void CountPulses();
//-----------------------------DEBOUNCE FUNCTIONS---------------------------------------
//--------------------------------MAIN SETUP--------------------------------------
void setup()
{
Serial.begin(115200);
//Pin Setup
pinMode(LASER_PIN, INPUT_PULLUP);
pinMode(RESET_PIN, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(LASER_PIN), IRQcounter, RISING);//attach interrupt handler to laser input
attachInterrupt (digitalPinToInterrupt (RESET_PIN), RESET_ISR, FALLING); // attach interrupt handler to reset, wait for user press button or switch
start_time = millis(); //initial start time
sei();//Turn on Interrupts
WaitForPulses();//Waits to detect 20 pulses
}
//--------------------------------MAIN LOOP----------------------------------
void loop()
{
current_time = millis();
fsm();//State machine
}
//--------------------------------PULSE COUNT FUNCTION--------------------------------------------
void CountPulses()
{
// current_time = millis();
if ((current_time - start_time) >= period)
{
start_time = current_time;
cli();//disable interrupts
PulseCount = IRQcount;
IRQcount = 0;
Serial.print(F("Pulse Count is = "));
Serial.println(PulseCount);
sei();//enable interrupts
}
}
//--------------------------------STATE MACHINE FUNCTION--------------------------------------------
void fsm()
{
switch (eNextState)
{
case STATE_0:
/////////Print Statement only for debugging//////////
while (only_for_print == false)
{
Serial.println("The state is 0");
only_for_print = true;
}
///////// Count Pulses Setup /////////////////
Previous_State = fsm_state_Array[3];
Current_State= 0;
Next_State = fsm_state_Array[1];
current_time = millis();
CountPulses();
Output = 0;
if (PulseCount == N)
{
PulseCount = 0;//Reset Pulse Count
only_for_print = false; //used only for print statments
State_Check_0_to_1();//Move to next state
}
break;
case STATE_1:
/////////Print Statement only for debugging//////////
while (only_for_print == false)
{
Serial.println("The state is 1");
only_for_print = true;
}
///////// Count Pulses Setup /////////////////
Previous_State = fsm_state_Array[0];
Current_State= 1;
Next_State = fsm_state_Array[2];
current_time = millis();
CountPulses();
Output = 1;
if (PulseCount == N)
{
PulseCount = 0;//Reset Pulse Count
only_for_print = false; //used only for print statments
State_Check_1_to_2();//Move to next state
}
break;
case STATE_2:
/////////Print Statement only for debugging//////////
while (only_for_print == false)
{
Serial.println("The state is 2");
only_for_print = true;
}
///////// Count Pulses Setup /////////////////
Previous_State = fsm_state_Array[1];
Current_State= 2;
Next_State = fsm_state_Array[3];
current_time = millis();
CountPulses();
Output = 2;
if (PulseCount == N)
{
PulseCount = 0;//Reset Pulse Count
only_for_print = false; //used only for print statments
State_Check_2_to_3();//Move to next state
}
break;
case STATE_3:
/////////Print Statement only for debugging//////////
while (only_for_print == false)
{
Serial.println("The state is 3");
only_for_print = true;
}
///////// Count Pulses Setup /////////////////
Previous_State = fsm_state_Array[2];
Current_State= 3;
Next_State = fsm_state_Array[0];
current_time = millis();
CountPulses();
Output = 3;
if (PulseCount == N)
{
PulseCount = 0;//Reset Pulse Count
only_for_print = false; //used only for print statments
State_Check_3_to_0();//Move to next state
}
break;
}
}
//----------------------------------RESET SWITCH ISR-------------------------------------
void RESET_ISR()
{
reset_flag = true;
if (reset_flag == true)
{
// Serial.println("System will now Reset");// Only for debugging
reset_flag = false;//Reset reset switch flag
wdt_enable(WDTO_500MS);//Reset after 0.5 seconds
while (1)
{
// wdt_reset(); // uncomment to avoid reboot
}
}
}
//-----------------------PULSE COUNT ISR---------------------------------------
void IRQcounter()
{
IRQcount++;
}
//-----------------------WAIT FOR PULSES---------------------------------------
void WaitForPulses()
{
while (wait < 20)
{
if (bit_is_set(EIFR, INTF0))
{
Serial.println("Pulse is detected ");
wait++;
}
}
wait = 0;//reset
}
void State_Check_0_to_1()//Check values of state 0 before going to state 1
{
if(Previous_State == fsm_state_Array[3] && Current_State == 0 && Next_State == fsm_state_Array[1])
{
eNextState = Next_State;
}
}
void State_Check_1_to_2()//Check values of state 1 before going to state 2
{
if((Previous_State == fsm_state_Array[0]) && (Current_State == 1) && (Next_State == fsm_state_Array[2]))
{
eNextState = Next_State;
}
}
void State_Check_2_to_3()//Check values of state 2 before going to state 3
{
if((Previous_State == fsm_state_Array[1]) && (Current_State == 2) && (Next_State == fsm_state_Array[3]))
{
eNextState = Next_State;
}
}
void State_Check_3_to_0()//Check values of state 3 before going to state 0
{
if((Previous_State == fsm_state_Array[2]) && (Current_State == 3) && (Next_State == fsm_state_Array[0]))
{
eNextState = Next_State;
}
}
Here is what my serial monitor shows:
Pulse is detected
Pulse is detected
Pulse is detected
Pulse is detected
Pulse is detected
Pulse is detected
Pulse is detected
Pulse is detected
Pulse is detected
Pulse is detected
Pulse is detected
Pulse is detected
Pulse is detected
Pulse is detected
Pulse is detected
Pulse is detected
Pulse is detected
Pulse is detected
Pulse is detected
Pulse is detected
The state is 0 -----> State 0
Pulse Count is = 72
Pulse Count is = 19
Pulse Count is = 20
The state is 2 -----> State 2
Pulse Count is = 20
The state is 1 -----> State 1
Pulse Count is = 21
Pulse Count is = 19
Pulse Count is = 21
Pulse Count is = 19
Pulse Count is = 21
Pulse Count is = 19
Pulse Count is = 21
Pulse Count is = 19
Pulse Count is = 21
Pulse Count is = 20
The state is 3 -----> State 3
Pulse Count is = 20
The state is 0
Pulse Count is = 20
The state is 2
Pulse Count is = 20
The state is 1
Pulse Count is = 20
The state is 3
Seperate code to test out FSM with pointers as suggested in the comments:
typedef void (*current_state)();
void state0();
void state1();
void state2();
void state3();
current_state states[4]={&state0,&state2,&state3,&state1};
current_state next_state;
void setup()
{
Serial.begin(115200);
}
void loop()
{
current_state();
}
void state0()
{
next_state = states[1]; // No parenthesis!
Serial.println("I am in STATE 0");
}
void state1()
{
next_state = states[2]; // No parenthesis!
Serial.println("I am in STATE 1");
}
void state2()
{
next_state = states[3]; // No parenthesis!
Serial.println("I am in STATE 2");
}
void state3()
{
next_state = states[0]; // No parenthesis!
Serial.println("I am in STATE 3");
}

Answer 1

This code from handling of STATE_2
Next_State = fsm_state_Array[3];
sets Next_State to STATE_1 because the array is initalized as
fsm_state fsm_state_Array[] = {STATE_0, STATE_2, STATE_3, STATE_1};
That means...
fsm_state_Array[0] = STATE_0;
fsm_state_Array[1] = STATE_2;
fsm_state_Array[2] = STATE_3;
fsm_state_Array[3] = STATE_1; // This is the element used
To provide a more "dynamic" solution probably using function pointer for states works better that using a switch:
// Current state is just a apointer to a void function
// accepting no parameters
void (*current_state)();
// All states are just void functions accepting no parameters
void state1();
void state2();
...
// To set what is the next state you update current_state
void state1() {
...
current_state = state2; // No parenthesis!
}
// In the main handler you just call current_state
...
current_state(); // Do the state processing
If you want to perform a sequence of operations then using function pointers you can just keep an array of them and iterate over it:
void (*states[])() = {
state1,
state2,
state3,
...
NULL /// To mark the end of the sequence
};
then you can execute the steps in sequence with
void main() {
for(int i=0; states[i]; i++) {
states[i](); // Execute the step
}
}