Project 2 - Implement the Code for controlling the retraction and extension of Airplane’s landing gear

Overview - 

To implement the controlling retraction and extension of Airplane's Landing Gear using Finite State Machine.

Goals - 

• To control the direction of valve
• To control the retraction and extension of Airplane's Landing Gear
• To check the transition is possible or not before gear transition

Key Highlights - 

• Controlling the direction valve
• Check the state of Hydraulics Mechanism for Gear Transition
• Transitioning of Gear 

Deliverables - 

• Implementing retraction control of Landing Gear
• Implementing extension control of Landing Gear
• Implementing different states of switches and gear

Expected Outcome -

• To control the Airplane Landing Gear mechanism using Finite State Machine.

Code - 

/*
 * Landing_Gear.c
 *
 *  Created on: 22-Jan-2023
 *      Author: Vishal Goyal
 */

// For including standard I/O Functions
#include

// Declaring Functions
void Init_State_Machine();
void GearUp();
void GearDown();
void GearRise();
void GearFall();
void TakeoffCheck();
void LandingCheck();

// State Table
static void(*StateTable[])(void) =
		{GearDown,TakeoffCheck,GearRise,GearUp,LandingCheck,GearFall};

// Different States
typedef enum States
{
	Gear_Down,
	Takeoff_Check,
	Gear_Rise,
	Gear_Up,
	Landing_Check,
	Gear_Fall
}State_Types;

// For Switches State
typedef enum Switch
{
	Closed,
	Open
}Switch_Status;

// For Pilot Lever State
typedef enum Gear_Lever
{
	Rising,
	Falling
}Pilot_Lever;

// Hydraulic Mechanism Control
typedef enum Hydraulic_Mechanism
{
	Working,
	Not_Working
}Hydraulic_Mech;

// Variables to be used throughout the file
static volatile Switch_Status Squat_Switch;
static volatile Switch_Status Limit_Switch;
static volatile Pilot_Lever Lever;
static volatile Hydraulic_Mech Hydraulics;

// Variable defined for current state
State_Types current_state;

// Structure for State Table
typedef struct
{
	char* state;
	char* light;
	char* direction;
	char* landing_gear_control;
	char* Spring_System[2];
}State_Table;

// State Machine definition
static State_Table State_Machine[6] = {
		{"GearDown","Green","Down","Enabled",{NULL,NULL}},
		{"TakeoffCheck","Green","Down","Enabled",{NULL,NULL}},
		{"GearRising","Red","Up","Enabled",{NULL,NULL}},
		{"GearUP","Open","NULL","Disabled",{NULL,NULL}},
		{"LandingCheck","Red","Down","Enabled",{NULL,NULL}},
		{"GearFall","Green","Down","Enabled",{"Disabled","Enabled"}}
		};

// Starting of Main Function
// Logic is written inside the main function
int main()
{
	// Initializing the state mechanism
	Init_State_Machine();

	// Infinite Time Loop
	while(1)
	{
		StateTable[current_state]();
	}

	// After executing this main function, this function will return value 0
	return 0;
}

// Initializing State Machine
void Init_State_Machine()
{
	current_state = Gear_Down;
	printf("Initializing....\n");
	printf("Current State is Gear_Down\n");
	printf("Signal Light is %s\n",State_Machine[current_state].light);
}

// Function for Gear Down
void GearDown()
{
	// Current state
	current_state = Gear_Down;

	// Taking the Pilot Lever State from user
	printf("Enter the state of Pilot's Lever: ");
	fflush(stdout);
	scanf("%d",&Lever);

	// Taking the Squat Switch condition from user
	printf("Enter the state of Squat Switch: ");
	fflush(stdout);
	scanf("%d",&Squat_Switch);

	// Condition for Successful Gear Down Condition
	// Rising Lever and Open Squat Switch
	if((Lever == Rising) && (Squat_Switch == Open))
	{
		current_state = Takeoff_Check;
		printf("Current State: %s\n",State_Machine[current_state].state);
		printf("Signal Light: %s\n",State_Machine[current_state].light);
	}
	else
	{
		GearDown();
	}
}

// Checking before Takeoff
void TakeoffCheck()
{
	// Current state is TakeoffCheck
	current_state = Takeoff_Check;

	// Taking user input for Pilot's Lever
	printf("Enter the state of Pilot's Lever: ");
	fflush(stdout);
	scanf("%d",&Lever);

	// Taking user input for Squat Switch
	printf("Enter the state of Squat Switch: ");
	fflush(stdout);
	scanf("%d",&Squat_Switch);

	// Taking user input for Hydraulics Mechanism
	printf("Enter the state of Hydraulics Mechanism: ");
	fflush(stdout);
	scanf("%d",&Hydraulics);

	// Conditions Check before Takeoff
	if((Lever == Falling) && (Squat_Switch == Open))
	{
		GearDown();
	}
	else if((Lever == Rising) && (Squat_Switch == Closed) && (Hydraulics == Working))
	{
		current_state = Gear_Rise;
		printf("Current State: %s\n",State_Machine[current_state].state);
		printf("Signal Light: %s\n",State_Machine[current_state].light);
		printf("Direction State: %s\n",State_Machine[current_state].direction);
	}
	else if((Lever == Rising) && (Squat_Switch == Closed) && (Hydraulics == Not_Working))
	{
		current_state = Gear_Rise;
		printf("Current State: %s\n",State_Machine[current_state].state);
		printf("Signal Light: %s\n",State_Machine[current_state].light);
		printf("Direction State: %s\n",State_Machine[current_state].direction);
		printf("Gas Pressurized Spring System State: %s\n",State_Machine[current_state].Spring_System);
	}
}

// Gear Up
void GearRise()
{
	// Current State is Gear Rise
	current_state = Gear_Rise;

	// Taking user input of Pilot's Lever
	printf("Enter the state of Pilot's Lever: ");
	fflush(stdout);
	scanf("%d",&Lever);

	// Taking user input of Limit Switch
	printf("Enter the state of Limit Switch: ");
	fflush(stdout);
	scanf("%d",&Limit_Switch);

	// Conditions
	if((Lever == Falling) && (Limit_Switch == Closed))
	{
		current_state = Landing_Check;
		printf("Current State: %s\n",State_Machine[current_state].state);
		printf("Signal Light: %s\n",State_Machine[current_state].light);
		printf("Landing Gear Hydraulic Control State: %s\n",State_Machine[current_state].landing_gear_control);
	}
	else if((Lever == Rising) && (Limit_Switch == Open))
	{
		current_state = Gear_Up;
		printf("Current State: %s\n",State_Machine[current_state].state);
		printf("Signal Light: %s\n",State_Machine[current_state].light);
		printf("Landing Gear Hydraulic Control: %s\n",State_Machine[current_state].landing_gear_control);
	}
	else
	{
		GearRise();
	}
}

// Gear Transition from Down to Up
void GearUp()
{
	// Current State is Gear Up
	current_state = Gear_Up;

	// Taking user input of Pilot's Lever
	printf("Enter the state of Pilot's Lever: ");
	fflush(stdout);
	scanf("%d",&Lever);

	// Conditions
	if(Lever == Falling)
	{
		current_state = Landing_Check;
		printf("Current State: %s\n",State_Machine[current_state].state);
		printf("Signal Light: %s\n",State_Machine[current_state].light);
		printf("Landing Gear Hydraulic Control: %s\n",State_Machine[current_state].landing_gear_control);
	}
	else
	{
		GearUp();
	}
}

// Check before Landing
void LandingCheck()
{
	// Current state is Landing Check
	current_state = Landing_Check;

	// Taking user input of Pilot's Lever
	printf("Enter the status of Pilot's Lever: ");
	fflush(stdout);
	scanf("%d",&Lever);

	// Taking user input of Hydraulics Mechanism
	printf("Enter the status of Hydraulics Mechanism: ");
	fflush(stdout);
	scanf("%d",&Hydraulics);

	// Conditions
	if((Lever == Falling) && (Hydraulics == Working))
	{
		current_state = Gear_Fall;
		printf("Current State: %s\n",State_Machine[current_state].state);
		printf("Signal Light: %s\n",State_Machine[current_state].light);
		printf("Direction State: %s\n",State_Machine[current_state].direction);
	}
	else if((Lever == Falling) && (Hydraulics == Not_Working))
	{
		current_state = Gear_Fall;
		printf("Current State: %s\n",State_Machine[current_state].state);
		printf("Signal Light: %s\n",State_Machine[current_state].light);
		printf("Direction State: %s\n",State_Machine[current_state].direction);
		printf("Gas Pressurized Spring System State: %s\n",State_Machine[current_state].Spring_System);
	}
	else if(Lever == Rising)
	{
		LandingCheck();
	}
}

// Gear Transition from Up to Downl
void GearFall()
{
	// Current state is Gear Fall
	current_state = Gear_Fall;

	// Taking user input of Pilot's lever
	printf("Enter the status of Pilot's Lever: ");
	fflush(stdout);
	scanf("%d",&Lever);

	// Taking user input of Limit Switch
	printf("Enter the status of Limit Switch: ");
	fflush(stdout);
	scanf("%d",&Limit_Switch);

	// Conditions
	if((Lever == Rising) && (Limit_Switch == Closed))
	{
		current_state = Takeoff_Check;
		printf("Current State: %s\n",State_Machine[current_state].state);
		printf("Signal Light: %s\n",State_Machine[current_state].light);
		printf("Landing Gear Hydraulic Control: %s\n",State_Machine[current_state].landing_gear_control);
	}
	else if((Lever == Rising) && (Limit_Switch == Open))
	{
		current_state = Gear_Down;
		printf("Current State: %s\n",State_Machine[current_state].state);
		printf("Signal Light: %s\n",State_Machine[current_state].light);
		printf("Landing Gear Hydraulic Control: %s\n",State_Machine[current_state].landing_gear_control);
	}
	else if(Limit_Switch == Open)
	{
		GearFall();
	}
}

Output -