Part -A

Flight Control System (FCS), essential for all flight operations, has significantly changed throughout the years. A FCS is
kind of a middleman between the pilot’s flight controls and the flight control surfaces such as the elevator, ailerons and
rudders. The FCS aims to achieve this control via the aircraft's aerodynamic control surfaces and/or the thrust provided
by the engines, which is normally controlled in its magnitude and in its direction. In this context, write an essay on the
topic: “Aircraft Fight Control System”.

The Aircraft Flight Control System (FCS) is the core system responsible for managing the aircraft's flight dynamics and
navigation. It acts as an intermediary between the pilot’s input and the actual control surfaces like the ailerons, rudder,
and elevators, facilitating safe and precise aircraft handling during all phases of flight. The FCS controls the aircraft’s
motion around the three axes — pitch, roll, and yaw — through manipulation of aerodynamic forces or engine thrust,
ensuring the stability and maneuverability of the aircraft.

Modern Flight Control Systems have evolved significantly from their earlier mechanical and rudimentary designs into the
advanced systems in today's commercial and military aircraft, encompassing hydraulic, electrical, and fly-by-wire
technologies. Let's delve deeper into the components and types of equipment involved in flight control systems and why
powered and power-assisted controls are so essential in modern aviation.

A1.1 Mechanical and Electrical Control Equipment in Flight Control System

Initially, flight control systems were purely mechanical, requiring the pilot to physically control the aircraft using
mechanical linkages. Over time, as aircraft grew in size and sophistication, so did the need for more efficient and
powerful systems that could handle greater loads and offer finer precision.

Mechanical Control Systems

 Control Columns, Yokes, and Rudder Pedals: In the early designs, pilots used mechanical control sticks (control
columns) or yokes to steer the aircraft. The ailerons were controlled by the pilot turning the yoke or moving the
control column left or right, rolling the aircraft to the desired angle. Rudder pedals, located on the floor of the
cockpit, were used to control the yaw axis. For larger aircraft, separate pedals controlled the rudder at the tail,
helping to stabilize and steer the plane around its vertical axis.

 Cables, Pulleys, and Pushrods: These devices physically transmitted the pilot’s inputs to the flight control
surfaces via a series of mechanical linkages. Cables connected the control yoke and pedals to the ailerons and
rudder, enabling movement with relatively direct feedback. However, this system is subject to limitations,
especially in larger aircraft where substantial control forces may be needed.

Electrical Control Systems

As aircraft designs evolved and became more complex, mechanical systems gave way to more modern electrical
components, driven by advancements in technology and the need for more precise, flexible, and lightweight systems.
The shift from mechanical to electrical systems provided several benefits such as reduced pilot workload, the ability to
integrate more sophisticated control functions, and system redundancy.

 Servo Motors: A key electrical component that began replacing traditional mechanical actuators was the servo
motor, which acts as an intermediary between pilot inputs and flight control surfaces. These devices receive
electrical commands and convert them into physical movements to adjust control surfaces like ailerons, rudder,
and elevators.

 Fly-By-Wire (FBW): Modern airliners have transitioned to digital or electronic flight control systems that replace
traditional control linkages with wire or fiber optic cables and computers that directly control the actuators,
commonly known as fly-by-wire systems. In a FBW system, the pilot’s input is captured by sensors (usually in the
 form of analog or digital signals), transmitted through wires to flight control computers, and then converted into
corresponding movements of the flight control surfaces through electrical actuators.

 Fly-By-Light: In some advanced systems, Fly-By-Light is used, which involves light signals instead of electrical
currents in the wire systems to provide ultra-fast communication, a concept used in next-generation aircraft
control systems.

 Feedback Sensors and Actuators: In FBW and fly-by-wire systems, sensors monitor the position of both control
surfaces and pilot inputs, allowing the control system to adjust in real time to maintain the desired performance.
This data is continually fed back into the system to ensure precise aircraft control.

 Power Supply: A robust, redundant power supply is crucial to ensure these electronic control systems continue
operating without disruption. Electrical systems are powered by onboard generators, with redundancy built into
power systems to prevent the loss of control in case of malfunction.

A1.2 Need for Powered Control and Power-Assisted Control Systems

Powered Control Systems

Powered control systems address the limitations of manually-operated mechanical linkages and offer substantial
advantages in aircraft handling and operation.

 Larger Control Surfaces in Larger Aircraft: As aircraft began to increase in size, so did the forces required to move
the large control surfaces (like ailerons and elevators). These surfaces generate enormous aerodynamic loads,
and manually controlling them became practically impossible in large aircraft. Powered control systems, typically
using hydraulic power, provide the necessary force to move the control surfaces easily and precisely, while
reducing pilot fatigue.

 Hydraulic Actuators: Hydraulic-powered actuators became the standard in powered control systems. Hydraulic
power is generated by fluid pumps, and high-pressure hydraulic fluid is used to actuate the flight control
surfaces. This allows for lightweight control systems that offer high force for large control surfaces without the
need for additional mechanical systems.

 Electric Actuators and Redundancy: Electrical actuators are used to move flight surfaces, offering a quieter and
more efficient method compared to hydraulics. Many modern aircraft combine both electrical and hydraulic
systems to offer flexibility and fail-safe measures. Electric actuators also allow for more precise adjustments to
flight surfaces as they respond more quickly to commands.

 Increased Precision and Safety: Powered control systems enable the aircraft to operate with greater precision,
especially when combined with computerized systems. They ensure optimal aerodynamic performance across
various conditions (speed, altitude, weight) and minimize mechanical fatigue, which improves the overall safety
of the aircraft.

Power-Assisted Control Systems

Power-assisted systems make use of actuator technology to reduce the pilot’s workload and provide more comfortable
and manageable control.

 Lightweight and Responsive Controls: These systems use mechanical input mechanisms such as yokes and
pedals, but they have electrical actuators that assist in the movement of control surfaces. The actuators respond
to small inputs from the pilot, effectively enhancing responsiveness and reducing the forces required from the
pilot to achieve precise maneuvers.

 Benefits in Large Aircraft and Modern Jets: Power-assisted systems are particularly beneficial in large
commercial jets or military aircraft where the forces on the control surfaces may exceed what a human pilot can
 handle. The power assist can respond with the necessary adjustments quickly, allowing for quicker responses
and adjustments in flight, especially during critical phases like takeoff, landing, or turbulent weather.

 Enabling Fine Control at Low Speeds: For modern aircraft, power-assisted controls ensure that pilots can make
smooth, finely-tuned adjustments. These systems assist in maintaining precision during manual flight and
improve comfort during extended operations, including autopilot functions.

 Use in Fly-By-Wire and Autopilot: Modern Fly-By-Wire systems often integrate power-assisted controls, allowing
computers to assist pilots, maintaining the aircraft’s stability and flight envelope, or fully controlling the aircraft
in some cases. Power assistance allows for efficient control even in conditions of reduced pilot capacity or longer
flight times.

Conclusion

The development of the Aircraft Flight Control System (FCS) has significantly transformed the aviation landscape,
evolving from direct mechanical systems to highly advanced electrical and digital control systems. From mechanical
linkages to Fly-By-Wire (FBW) and hybrid electrical-hydraulic actuators, the evolution of FCS has played a central role in
enhancing flight safety, efficiency, and the comfort of pilots.

Powered control systems have proven indispensable, as they alleviate the enormous physical demands placed on pilots,
especially with the larger and more complex aircraft in service today. Moreover, power-assisted systems not only reduce
manual labor but also allow for finer control over the flight surfaces, improving both maneuverability and safety. The
future of aircraft flight control promises further integration of artificial intelligence and machine learning, along with
enhanced automated flight control systems, which will redefine the capabilities of modern aircraft.

These advancements, alongside the development of self-correcting and adaptive flight control mechanisms, ensure that
the FCS will continue to evolve and adapt, providing increasingly safer and more efficient systems in the years ahead.
With the crucial role of powered and power-assisted systems, the complexity of flight control will always find ways to
meet the growing needs of the aviation industry.
 PART B

B.1

A 7-segment display is commonly used in electronic display devices for decimal numbers from 0 to 9 and in some cases,
basic characters. The use of light-emitting diodes (LEDs) in seven-segment displays made it more popular, whereas of late
liquid crystal displays (LCD) have also come into use. In this section all tests should be carried out using Proteus Software
Design an Automatic 7-segment display control using switch in Proteus software

B1.1

Review and analyze the various components and sub-systems involved in developing automated 7-segment control
system and arrive at the functional block diagram

COMPONENTS USED:
 Arduino Uno
 7 Segment Display
 CD4511 IC
 IR Remote & Receiver
 LED’s
 Resistors
 Jumper Wires
 Bread Board

Arduino Uno:

The Arduino Uno serves as the central controller, processing signals from the IR receiver
and controlling the display through the CD4511 IC. It is easy to program and integrates well
with components like IR receivers using libraries like IRremote.h. Its role is critical for
translating user inputs from the IR remote into binary values to control the display.

However, the Uno's limited number of pins can be a challenge if the system needs
expansion, such as adding multiple displays or sensors. While sufficient for this project,
handling complex functionality may require additional hardware like multiplexers or shift
registers.

7 Segment Display:

The 7-segment display provides a simple and clear way to visually output numbers (0-9). Its
operation is made efficient by using the CD4511 IC, which reduces the Arduino's pin usage to
just four for binary input.

Its main limitation is in displaying only single digits. Expanding to multiple digits or
alphanumeric characters would increase wiring complexity and may require additional
circuitry, but for straightforward numeric output, it is an ideal solution.

CD4511 IC:

The CD4511 IC functions as a BCD-to-7-segment decoder, enabling the Arduino to efficiently

control a 7-segment display using just four binary input pins. This simplifies the design by handling the
translation of binary inputs to the corresponding 7-segment output, reducing the need for manual pin-
level control of individual segments.
Its dependency on precise binary input from the Arduino is a potential limitation. Errors in the input logic would directly
affect the display output. Nonetheless, its role in simplifying the system and saving microcontroller pins makes it an
essential component for this project.

IR Remote & Reciever:

The IR remote and receiver pair allows for wireless control of the display, providing a user-
friendly interface. The IR receiver decodes signals from the remote, and the Arduino processes
these codes to determine the corresponding numeric input. This setup minimizes physical
interaction, making it versatile and convenient for users.

However, IR communication is line-of-sight dependent, so the remote must be aimed correctly

at the receiver. Despite this minor limitation, its ease of integration and reliable functionality make it a suitable choice for
the project.

LED’s:

The LED serves as an indicator to show that the system is ready to receive input from the IR remote. Its blinking
state reassures users that the system is operational, enhancing the interface's usability. Also, the set of 4 LED’s indicate
the binary input the IC.

While simple, the LED's role is limited to visual feedback. In future iterations,
more advanced indicators, like LCD messages, could replace it for detailed
information. For now, it fulfills its purpose effectively within this basic system.

Bread Board, Resistors and Jumper Wires:

Resistors ensure proper current control across the circuits, preventing

damage to LEDs and the IC. They are crucial for the stability and longevity of the
components. Proper resistor values must be chosen for each element to ensure consistent performance.

Jumper wires are the backbone of connectivity in the breadboard setup, establishing electrical connections between
components. While convenient, they can lead to a cluttered design and are prone to disconnections if not handled
carefully. Using a custom PCB would be a more robust solution for larger or long-term applications. All these placed on
the breadboard to have a proper connection of the circuit.

BLOCK DIAGRAM:

IR REMOTE IR RECIEVER ARDUINO UNO LED’s

CD4511 IC 7 SEG DISPLAY

B1.2
Develop appropriate simulation algorithm with microcontroller to display chosen number (0-9) when particular Switch is
ON state.

CODE:
#include <IRremote.h>

// Define pin connections

#define RECV_PIN 11
#define PIN_0 2
#define PIN_1 3
#define PIN_2 4
#define PIN_3 5
#define WAIT_LED_PIN 6

int button = -1;

// Map the IR code to the corresponding remote button using a simple switch-
case
int mapCodeToButton(unsigned long code) {
switch (code) {
case 0xF30CBF00: return 0; // F30CBF00 for 0
case 0xEF10BF00: return 1; // EF10BF00 for 1
case 0xEE11BF00: return 2; // EE11BF00 for 2
case 0xED12BF00: return 3; // ED12BF00 for 3
case 0xEB14BF00: return 4; // EB14BF00 for 4
case 0xEA15BF00: return 5; // EA15BF00 for 5
case 0xE916BF00: return 6; // E916BF00 for 6
case 0xE718BF00: return 7; // E718BF00 for 7
case 0xE619BF00: return 8; // E619BF00 for 8
case 0xE51ABF00: return 9; // E51ABF00 for 9
default: return -1; // Unknown code
}
}

void setup() {
// Initialize serial communication for debugging
[Link](9600);

// Initialize IR receiver
[Link](RECV_PIN);

// Set output pins as OUTPUT

pinMode(PIN_0, OUTPUT);
pinMode(PIN_1, OUTPUT);
pinMode(PIN_2, OUTPUT);
pinMode(PIN_3, OUTPUT);
pinMode(WAIT_LED_PIN, OUTPUT);

// Turn all output pins HIGH by default

digitalWrite(PIN_0, HIGH);
Simulation Algorithm
Initialization Phase
 1. Configure Microcontroller Pins
o Set up IR receiver pin as INPUT (e.g., RECV_PIN).
o Set binary data pins (PIN_0 to PIN_3) as OUTPUT to interface with the
CD4511 IC.
o Optionally configure a status LED pin to indicate readiness.
2. Setup IR Receiver:
o Initialize the IR receiver library (e.g., IRremote.h) on the specified pin.
o Ensure the receiver is ready to detect signals by using the [Link]()
function.
3. Define Button Mappings:
o Assign unique raw data codes from the IR remote to numbers (0–9) using a
mapping table or switch-case function (e.g., mapCodeToButton()).
4. Prepare 7-Segment Display:
o Initialize all binary output pins to HIGH to reset or disable the 7-segment
display.
Main Loop
1. Listen for IR Signal:
o Continuously poll the IR receiver for incoming signals using the
[Link]() function.
2. Decode the Signal:
o Extract the raw data (decodedRawData) from the IR receiver to identify
which button was pressed.
o Use a function to map the received code to the corresponding button number
(e.g., mapCodeToButton()).
3. Verify Button Input:
o Check if the mapped number is valid (i.e., between 0 and 9). If invalid, ignore
the input or display an error state.
4. Output the Number:
o Convert the chosen number (0–9) into its 4-bit binary equivalent.
o Set the binary data pins (PIN_0 to PIN_3) to match the binary representation
of the number.
5. Display the Number:
o The CD4511 IC decodes the binary data and lights up the segments of the 7-
segment display to show the corresponding number.
 6. Handle Idle State:
o If no valid button is pressed, ensure the 7-segment display remains cleared
or displays the last valid number.
7. Repeat:
o Resume IR signal processing and continue polling for new inputs.
Example Simulation Steps (Pressing the "2" button on the IR remote)
1. Initialization:
o IR receiver, data pins, and CD4511 are set up.
o The display is initially cleared.
2. Receive IR Signal:
o Button "2" on the remote is pressed, sending code 0xEE11BF00 to the IR
receiver.
3. Decode and Map Code:
o The microcontroller maps the received code to the number 2 using
mapCodeToButton().
4. Generate Binary Output:
o The number 2 is converted to binary (0010), and the corresponding output
pins are set:
 PIN_0 = 0, PIN_1 = 1, PIN_2 = 0, PIN_3 = 0.
5. Display Number:
o The CD4511 IC decodes 0010 and displays the number "2" on the 7-segment
display.
6. Idle State:
o The system waits for the next button press or IR signal.
B1.3
Develop and Demonstrate the simulation model in PROTEUS SOFTWARE and display the results
B2
A robotic hand is a type of mechanical arm, usually programmable, with similar functions to a
human arm; the arm may be the sum total of the mechanism or may be part of a more complex
robot. The actuators then move the joints, causing the robotic arm to perform the desired
motion. In this section all tests should be carried out using Proteus Software Design an
Automatic 5 Fingers robotic hand with controlled scheme using variable resistor
(POT)/Flux Sensor in Proteus software.

B2.1
Review and analyze the various components and sub-systems involved in developing automated
5 Fingers robotic hand and arrive at the functional block diagram.

COMPONENTS USED:
 ARDUINO UNO
 FLEX SESNORS
 POT 10K
 SERVO MOTORS
 POWER SUPPLY
 BREADBOARD
 JUMPER WIRES

Arduino Uno
The Arduino Uno acts as the central control unit, responsible for
processing sensor inputs (flex sensors and potentiometers) and driving
the servo motors. Its analog pins read the resistance changes from the
sensors, map them to angles, and send corresponding PWM signals to
the servo motors for movement. The Uno's compatibility with libraries like
Servo.h makes it ideal for such precise servo control.
Flex Sensors
Flex sensors detect finger bending. When bent, their resistance changes in proportion to
the degree of bending, which is read as an analog voltage by the Arduino. This voltage is
mapped to a servo angle (0–180°), enabling the robot's fingers to replicate human finger
movements.
Potentiometers (POT 10k)
Potentiometers serve as a simple and user-friendly method to directly
control servo motors. By turning the knob, the resistance varies, altering the
voltage output read by the Arduino. This enables manual testing and control of
each servo motor independently.
Servo Motors
Each of the 5 servo motors corresponds to a robotic finger. They receive PWM
signals from the Arduino to rotate at angles matching the mapped sensor
input. The smooth and precise movement of the servos is crucial for
mimicking human hand gestures.

Power Supply
The power supply provides the necessary energy for the Arduino and
servos. Servos, especially when driving multiple motors, require a
steady and adequate current to function without jittering or losing
precision. A separate power supply for servos (e.g., 5V–6V) is often
used to avoid overloading the Arduino.
Breadboard and Jumper Wires
The breadboard and jumper wires facilitate easy prototyping and
connection between components. They help create a non-permanent
but reliable circuit, allowing adjustments during development.
Subsystems and Functionality
1. Sensor Subsystem
 Inputs: Flex sensors or potentiometers.
 Function: Capture analog signals indicating bending angles or manual knob
adjustments.
 Output: Sends analog values to the Arduino for processing.
2. Microcontroller Subsystem
 Inputs: Analog sensor readings.
 Processing:
o Reads the resistance or voltage data from the sensors.
o Maps the values to servo motor angles (e.g., 0–180°).
 Output: Sends PWM signals to the servo motors to control the robotic fingers.
3. Actuator Subsystem
 Input: PWM signals from the Arduino.
 Function: Servo motors rotate to the desired angle based on the signals.
 Output: Physical movement of robotic fingers to match human gestures or manual
input.
4. Power Management Subsystem
 Input: External power source (5V–6V DC).
 Function: Supplies power to the Arduino and servo motors.
 Output: Ensures consistent operation without voltage drops.

BLOCK DIAGRAM:

FLEX / POT ARDUINO UNO SERVO MOTORS POWER SUPPLY

B2.2
Develop appropriate simulation algorithm with microcontroller to display individual finger
position (motor) using variable resistor (POT)/ Flux Sensor.
CODE:
USING FLEX
#include <stdint.h>
#include <Servo.h>
#define FLEX_MIN 384
#define FLEX_MAX 783
#define SERVO_MAX 180
#define SERVO_MIN 0
#define LENGTH(arr) sizeof(arr)/sizeof(arr[0])

uint8_t glove[5] = {A0, A1, A2, A3, A4};

uint8_t robot[5] = {11, 10, 9, 6, 5};
Servo finger[5];
uint8_t pin;
int16_t pos;

void setup() {
[Link](9600);

for (pin = 0; pin < LENGTH(glove); pin++) {

pinMode(glove[pin], INPUT_PULLUP);
}
USING POT #include <Servo.h>

int x1 = 0; //Declare several needed variables

int x2 = 0;
int x3 = 0;
int x4 = 0;
int x5 = 0;

Servo motor1; //Declare servo motor and name it motor1

Servo motor2;
Servo motor3;
Servo motor4;
Servo motor5;

void setup(){
[Link](5); //set each motor to its portpin (from7 to 12)
[Link](6);
[Link](9);
[Link](10);
[Link](11);
}

void loop(){
x1 = analogRead(A4); //x1 is taking its value through port A0
x1 = map(x1,0,1023,0,179); //mapping potentiometer as analog read from (0 to
1023) to understand it as angle from (0 to 179)
[Link](x1); // move motor1 to value of x1
delay(10); // wait a little

x2 = analogRead(A3);
x2 = map(x2,0,1023,0,179);
[Link](x2);
delay(10);

x3 = analogRead(A2);
x3 = map(x3,0,1023,0,179);
Simulation Algorithm
Step 1: Initialize the System
1. Define and declare all required variables for storing sensor values (e.g., x1, x2, x3,
etc., for each finger).
2. Import the necessary library (Servo.h) to control servo motors.
3. Create servo motor objects, one for each robotic finger (e.g., motor1 to motor5 or
finger[5] using an array).
4. Identify the connections:
o Assign analog pins for reading POTs or flex sensors (e.g., A0–A4).
o Assign digital pins for driving servo motors (e.g., 5, 6, 9, 10, 11).
Step 2: System Setup
1. Use the setup() function to:
o Attach servo motors to their respective digital pins.
o Configure analog pins for sensor inputs.
o Initialize serial communication (if needed) for debugging or displaying sensor
values.
Step 3: Sensor Input Mapping
1. Read sensor values:
o Use analogRead() to capture the analog values from POTs or flex sensors for
each finger (e.g., A0 for the thumb).
o The range of values typically varies between 0–1023.
2. Map input values to servo angles:
 o Use the map() function to convert the analog readings into a range suitable
for servo movement (e.g., 0–180°).
Step 4: Control Servo Motors
1. Write the mapped values to the servo motors: Use the [Link]() function to
adjust the servo position according to the sensor values.
2. Implement a small delay (e.g., 10ms) between consecutive servo adjustments for
smooth motion.
Step 5: Monitor Sensor Inputs and Adjust in Real-Time
1. Continuously poll the sensor values within the loop() function.
2. For flex sensors:
o Normalize the input values to match their range (e.g., using a flexible range
like FLEX_MIN to FLEX_MAX).
3. Output each servo's position to the serial monitor for debugging or display
purposes.
B2.3
Develop and Demonstrate the simulation model in PROTEUS SOFTWARE and display the
results