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

Project2:

Implementation of the code for controlling the retraction and extension of airplane’s landing gear

Aim:

• To implement the code for control retraction and extension of airplanes landing gear implementation using Finite State Machine (FSM).

Objective:

• Controlling the direction of valve.
• Controlling the retraction and extension of airplane’s landing gear.

Principle:

• The airplane has three gears for landing such as nose gear, left gear and right gear.
• There is a hydraulic pump which is exerting pressure tothe gears to bring it down or pull it up using electrical driven pump.
• When the direction of the valve is down then it is landed or gear down position.
• Similarly when the direction of valve is up then it is in rising gear or taking off.
• When gear is up then light status is off.
• Gear is down then the light status is green.
• Gear is raising or lowering then the colour of light is red.

Process:

• Gear down
• Checking before take off
• Raising gear
• Gear up
• Checking before landing
• Lowering gear

State Type	Switch Status	Pilot Lever Status	Hydraulic Mechanics Status
GR_DWN	Open	Rising	Working
CHK_BFR_TKFF	Close	Falling	Malfunctioning
RSING_GR		Up
GR_UP		Down
CHK_BFR_LND
LWRNG_GR

Code:

Main1.c:

#include
#include "States.h"

static void(*state_table[])(void) = {Gear_Down, Checking_Before_Takeoff,Raising_Gear,
		                            Gear_Up, Checking_Before_Landing, Lowering_Gear};

int main()
{
	Init_State_Machine();
	while(1)
	{
		state_table[current_state]();
	}
}



States.h:

#ifndef STATES_H_
#define STATES_H_

void Init_State_Machine();
void Gear_Down();
void Checking_Before_Takeoff();
void Raising_Gear();
void Gear_Up();
void Checking_Before_Landing();
void Lowering_Gear();

typedef enum State
{
	GR_DWN,
	CHK_BFR_TKFF,
	RSING_GR,
	GR_UP,
	CHK_BFR_LND,
	LWRNG_GR

}State_Type;

typedef enum Switch
{
	Open,
	Close

}Switch_Status;

typedef enum Pilot_Lever
{

	Rising,
	Falling,
	UP,
	DOWN

}Pilot_Lever_Status;

typedef enum Hydraulic_Mechanism
{
	Working,
	Malfunctioning

}Hydraulic_Mechanism_Status;

static volatile Switch_Status squat_switch;
static volatile Switch_Status limit_switch;
static volatile Pilot_Lever_Status pilot_lever;
static volatile Hydraulic_Mechanism_Status hydraulic_mechanism;

State_Type current_state;

typedef struct
{
	char* current_state_indication;
	char* light_status;
	char* direction_valve_status;
	char* hydraulic_pump_control_status;
	char* gas_pressurized_spring_status[2];
}State_Table;

static State_Table State_Machine[6] = {
		{"GearDown","Green","Down","Enabled",0,0},
		{"Checking Before Take Off","Green","Down","Enabled",0,0},
		{"Raising Gear","Red","Up","Enabled",{"Disabled","Enabled"}},
		{"Gear Up","Off","Null","Disabled",0,0},
		{"Checking Before Landing","Red","Down","Enabled",0,0},
		{"Lowering Gear","Green","Down","Enabled",{"Disabled","Enabled"}}

};

#endif




Init_State_Machine.c:

#include"States.h"

void Init_State_Machine()
{
	current_state = GR_DWN;
	printf("\nState Machine is initialized & Program is in Gear_Down State & Light Status: %s\n"
			,State_Machine[current_state].light_status);
}




Gear _Down.c:

#include"States.h"
#include

void Gear_Down(void)
{
	current_state = GR_DWN;
	printf("\n Enter the Pilot's Lever Position and Squat Switch  Status:");
	fflush(stdout);
	scanf("%d %d",&pilot_lever,&squat_switch);
	if(pilot_lever == Rising && squat_switch == Open)
	{
		current_state = CHK_BFR_TKFF;
		printf("\nCurrent State: %s\n",State_Machine[current_state].current_state_indication);
		printf("Light Status:%s\n", State_Machine[current_state].light_status);

	}
	else
	{
		Gear_Down();
	}
}




Checking_Before_Takeoff:

#include "States.h"
#include

void Checking_Before_Takeoff()
{
	current_state = CHK_BFR_TKFF;
	printf("\nEnter the Pilot's Lever Position,Squat Switch Status and Hydraulic Mechanism Status:");
	fflush(stdout);
	scanf("%d %d %d",&pilot_lever,&squat_switch,&hydraulic_mechanism);
	printf("\nWait for 2 secs\n");
	if(pilot_lever == Falling || squat_switch == Close)
	{
		Gear_Down();
	}
	else if(pilot_lever == UP && squat_switch == Open && hydraulic_mechanism == Working)
	{
		current_state = RSING_GR;
		printf("\nCurrent State :%s\n",State_Machine[current_state].current_state_indication);
		printf("Light Status: %s\n", State_Machine[current_state].light_status);
		printf("Direction Valve Status:%s\n\n", State_Machine[current_state].direction_valve_status);
	}
	else if(pilot_lever == UP && squat_switch == Open && hydraulic_mechanism == Malfunctioning)
	{
		current_state = RSING_GR;
		printf("\nCurrent State :%s\n",State_Machine[current_state].current_state_indication);
		printf("Light Status: %s\n", State_Machine[current_state].light_status);
		printf("Direction Valve Status:%s\n", State_Machine[current_state].direction_valve_status);
		printf("Gas Pressurized Spring System Status:%s\n",State_Machine[current_state].gas_pressurized_spring_status[hydraulic_mechanism]);
	}
}




Rising_Gear.c:


#include"States.h"
#include

void Raising_Gear()
{
	current_state = RSING_GR;
	printf("\nEnter the Limit Switch Status,Pilots Leaver Status:");
	fflush(stdout);
	scanf("%d %d",&limit_switch,&pilot_lever);
	printf("\nWait for 1 sec\n");
	if(pilot_lever == Falling && limit_switch == Open)
	{
		current_state = CHK_BFR_LND;
		printf("\nCurrent State: %s\n",State_Machine[current_state].current_state_indication);
		printf("Light Status:%s\n",State_Machine[current_state].light_status);
		printf("Hydraulic Control for Landing Gear Status:%s\n",State_Machine[current_state].hydraulic_pump_control_status);

	}
	else if(limit_switch == Close && pilot_lever == UP)
	{
		current_state = GR_UP;
		printf("\nCurrent State: %s\n",State_Machine[current_state].current_state_indication);
		printf("Light Status: %s\n", State_Machine[current_state].light_status);
		printf("Hydraulic Control for Landing Gear Status:%s\n", State_Machine[current_state].hydraulic_pump_control_status);

	}
	else
	{
		Raising_Gear();

	}

}



Gear_Up.c:

#include"States.h"
#include

void Gear_Up()
{
	current_state = GR_UP;
	printf("\nEnter the Pilot's Lever Position:");
	fflush(stdout);
	scanf("%d",&pilot_lever);
	if(pilot_lever == Falling)
	{
		current_state = CHK_BFR_LND;
		printf("\nCurrent State: %s\n",State_Machine[current_state].current_state_indication);
		printf("Light Status:%s\n", State_Machine[current_state].light_status);
		printf("Hydraulic Control for Landing Gear Status:%s\n",State_Machine[current_state].hydraulic_pump_control_status);
	}
	else
	{Gear_Up();

	}
}


Check_Before_Landing:

#include "States.h"
#include
void Checking_Before_Landing()
{
	current_state = CHK_BFR_LND;
	printf("\nEnter the Pilot's Lever Position and Status of Hydraulic Mechanism:");
	fflush(stdout);
	scanf("%d %d",&pilot_lever,&hydraulic_mechanism);
	if(pilot_lever == DOWN && hydraulic_mechanism == Working)
	{
		current_state = LWRNG_GR;
		printf("\nCurrent State:%s\n", State_Machine[current_state].current_state_indication);
		printf("Light Status:%s\n", State_Machine[current_state].light_status);
		printf("Direction Valve Status:%s\n", State_Machine[current_state].direction_valve_status);
	}
	else if(pilot_lever == DOWN && hydraulic_mechanism == Malfunctioning)
	{
		current_state = LWRNG_GR;
		printf("\nCurrent State:%s\n",State_Machine[current_state].current_state_indication);
		printf("Light Status:%s\n", State_Machine[current_state].light_status);
		printf("Direction Valve Status:%s\n", State_Machine[current_state].direction_valve_status);
		printf("Gas Pressurized Spring System Status:%s\n",State_Machine[current_state].gas_pressurized_spring_status[hydraulic_mechanism]);

	}
	else if(pilot_lever == (UP || Rising || Falling))

		{
		Checking_Before_Landing();
		}
}



Lowering_Gear.c:

#include "States.h"
#include
void Lowering_Gear()
{
	current_state = LWRNG_GR;
	printf("\nEnter the Limit Switch Status,Pilots Leaver Status:");
	fflush(stdout);
	scanf("%d %d",&limit_switch,&pilot_lever);
	if(limit_switch == Close && pilot_lever == Rising )
	{
		current_state = CHK_BFR_TKFF;
		printf("\nCurrent State:%s\n",State_Machine[current_state].current_state_indication);
		printf("Light Status:%s\n",State_Machine[current_state].light_status);

	}
	if(limit_switch == Open && pilot_lever == DOWN)
	{
		current_state = GR_DWN;
		printf("\nCurrent State:%s\n",State_Machine[current_state].current_state_indication);
		printf("Light Status:%s\n",State_Machine[current_state].light_status);
		printf("Hydraulic Controlfor Landing Gear Status:%s\n",State_Machine[current_state].hydraulic_pump_control_status);

	}
	else
	{
		Lowering_Gear();
	}

}

Program:

Main1.c:

States.h:

Initial State Machine.c:

Gear Down.c:

Checking Before Taking Off:

Rising Gear:

Gear Up:

Checking Before Landing:

Lowering Gear:

Output:

Main1.c:

• State table conditions are declared in main1.c.

States.h:

• Static table functions are defined in this header file of states.
• It consists of the various states of retraction and extension of airplanes landing gear modes.

States:

GR_DWN
CHK_BFR_TKFF
RSING_GR
GR_UP
CHK_BFR_LND
LWRNG_GR

Switch state:

Open
Close

Pilot lever state:

Rising
Falling
UP
DOWN

Hydraulic mechanism:

Working
Malfunctioning

Initial_State Machine.c:

• After inititializing the code ,current state is in Gear Down with green light.

Gear Down.c:

• Pilots lever position :Rising /Squat Switch: Open leads to Checking Before Takeoff Mode
• Else it returns back to Gear Down mode.
• 0 and 0 values are given as input:

Checking Before Takeoff.c:

Pilot lever:Up /Switch:Open / Hydraulic Mechanics:Working leads to Raising Gear Mode

Pilot lever:Up /Switch:Open/ Hydraulic Mechanics:Malfunctioning leads to Raising Gear Mode

Rising Gear.c:

Pilot lever: Falling/ Switch:Open leads to Check Before Landing Mode

Pilot lever:Up/Switch:Close leads to Gear Up Mode

Gear Up.c

Pilot lever: Falling leads to Check Before Landing Mode

Check Before Landing.c

Pilot lever:Down/Hydradulic Mechanism:Working leads to Lowering Gear Mode

Pilot lever:Down/Hydradulic Mechanism:Malfunctioning leads to Lowering Gear Mode

Lowering Gear.c:

Pilots lever:Rising/Switch:Close leads to Check Before Takeoff Mode

Pilots lever:Down/Switch:Open leads to Gear Down Mode

Result:

Thus a program code is created to control retraction and extension of airplanes landing gear implementation using Finite State Machine (FSM).