Build Your Own Annunciator Panel

When I built my airplane, I installed switches to monitor the critical items like gear position, canopy, and landing brake. I always intended to build an annunciator panel, but was unhappy with the design shown in the Cozy plans.

Building a flexible annunciator panel can be very complex. If the panel is to handle various inputs for multiple displays (i.e., throttle position, spoilers, and gear warning) sometimes the wiring will require diodes and other schemes to keep the warning coherent.

Adding a basic processor in the middle can make many complex systems simpler. While in the past microprocessors were quite difficult to program and install, things are less complicated now. For hobbyists there are many choices that make adding a processor to any system easier.

One of the most basic processor boards available is the Arduino. I have used the Arduino for many projects and find it simple to build with and very reliable. I used an Arduino Uno to control an annunciator panel in my Cozy.

In the Cozy, as in most aircraft, there are certain situations the pilot must try to avoid to get the best performance out of the aircraft. The nosegear should be extended before landing, the canopy should be latched before taking off, and the landing brake (spoiler) should be retracted before adding power to the engine. There are four sensors that are used in this panel: throttle position, gear up, landing brake up, and canopy latched.

Microswitch vs. Microprocessor

The Cozy plans suggested putting in a microswitch for throttle position. The microswitch is one way to do it, but by using the Arduino, a variable resistor can be used to get both throttle open and throttle closed indications, along with anything in between. The plans made no provision for a landing brake sensor because the plans have a manual landing brake, and the actuator handle is an obvious indicator.

When my Cozy was built, I installed all the switches. Then I ran all the sensor wiring to a barrier strip near the panel. The barrier strip allows changing what is on either side without drastically affecting the opposite side. Replacing the plans circuit with a microprocessor-based system was easily done.

Human factors research has shown a dark cockpit will allow the most use out of an annunciator panel. The panel will be dark and quiet until the pilot needs to handle something. There are two main alarms, both a bright LED and an audio alarm that will alert me when something is not in the expected configuration. There are individual indicators of what system is not normal, besides the master alarm.
A pushbutton is added to the annunciator panel to quiet the alarm for five seconds. Sometimes during testing and maneuvering, the aircraft will be in a configuration where an alarm may display, but I am OK with the situation. I won’t need an alarm to remind me that I need to do something. The alarm is quiet, but the red master alarm LED stays lit.

Wiring

When wiring sensors, sometimes it seems like a good idea to run power to the switches, causing them to switch 12 or 24V on to the panel, but this adds complexity. Any power run through the aircraft should be fused. When wiring switches to a microprocessor, it is best to have the switches control a ground signal. The processor can have a local voltage on board that will be switched off when the switch closes to ground. In a metal aircraft where the fuselage is ground, switching grounds can simplify the wiring since the ground wires will not have to be run to the switch.

I found software to light indicators will allow the greatest flexibility. The software can monitor individual pins of input and react by changing the state on other pins. The inputs can be combined to provide the most accurate output.

The Arduino has many inputs. The schematic shows all the switches are connected to digital inputs, and the variable resistor is connected to an analog input. The variable resistor is like a volume control, not set to any particular voltage, so it will measure the voltage at the time it is read (many times a second).

The Arduino board needs 12V power supplied to the processor from the aircraft. I added a dedicated 1-amp fused circuit to protect the wires leading to the Arduino board. Nothing on the board will require more than 1 amp of power.

Throttle position sensor.

The wires to the switches are very light. Simple 22-30 gauge wire worked fine. Lighter wire keeps the weight down and is easier to work with. In case the switches come loose, I left some slack near the switches to minimize wire breakage.

The throttle position indicator could be either near the carburetor or near the throttle knob. I mounted the variable resistor in such a way as to not interfere with the throttle setting, in case something comes loose. For my aircraft, I mounted it near the instrument panel, connected to the throttle knob using a small piece of music wire from the hobby store.

The indicators are simple light emitting diodes (LEDs). LEDs in many ways act like light bulbs, but have a couple critical differences. Light bulbs can be connected to the power source either way, and they will light. LEDs have to be connected such that the power will flow the proper direction. Connecting them backwards won’t damage them, but they won’t light up. The other difference is that LEDs must be current limited. Without that, the LEDs will send too much current through and be very bright for a brief period of time, and then never light again. The current limiter is a simple resistor, and for this project I used a 1000-ohm (brown-black-red) resistor.

I chose a Soberton Inc. WST-1205S buzzer available from Digi-Key as the audio alert. These buzzers are small, but are very loud. I mounted the buzzer on the back of the panel. The panel vibrates, making the sound louder.

I built a fixture to do the development of this system. The airplane is a short drive away, but it is cold working in the hangar, so I have a fixture with all the switches, knobs, audio alert, and LEDs. The orientation is similar to the aircraft, and I have the switches and LEDs labeled.

Canopy microswitch wiring.

Programming

Programming an Arduino is done on a laptop or desktop computer. The integrated development environment (IDE) allows the programs to be entered in a C or Java-like language and saved on the disk. The programs are loaded on the processor using a USB jack. Once loaded on the Arduino, the program will run every time power is added to the processor. Removing the power will not erase the processor’s memory.

/*
Annunciator Panel Sketch
This program will light up the Annunciator Panel based on current status of the Aircraft. The circuit:

*Momentary switch attached from pin 4 to ground (Nose Gear)
*Momentary switch attached from pin 6 to ground (Canopy)
*Momentary switch attached from pin 7 to ground (Landing Brake)
*Momentary switch attached from pin 5 to ground (alarm silence)
*sounder attached from pin 3 to ground
*Potentiometer connected to A0 (Throttle position)
*Built-in/External LED on pin 13 (green Gear Up)
*External LED on pin 12 (green Canopy open)
*External LED on pin 11 (green landing brake deployed)
*External LED on pin10(RED Master Caution)Unlike in Mode(INPUT),there is no pull-down resistor necessary. An internal 20K-ohm resistor is pulled to 5V. This configuration causes the input to read HIGH when the switch is open, and LOW when it is closed.

*/#include //Give all the pins a name. Change the pin numbers here and the logic won't have to change.
int GEAR_SW =4;
int CANOPY_SW=6;
int LB_SW =7;//Silence pushbutton. Once button released, alarm is silenced for 5 seconds.
int SILENCE_SW=5;//Alarm sounder is on pin 3
int ALARM_OUT = 3;//Green LEDs on pins 10, 12 and 13.
int GEAR_IND =13;
int CANOPY_IND =12;
int LB_IND =10;//red master alarm is on pin 9
int MASTER_IND =9;//Throttle position is analog
int THROTTLE_IN = 0; // analog pin 0
int THROTTLE_CLOSED=100; // fast idle
int THROTTLE_MAX=900; // takeoff power

The program for this annunciator panel is mostly linear. The setup function sets all the input and output pins as they need to be. The digital input is the pins where the switches are connected, and the digital output is the pins where the LEDs are connected. The names assigned to the pins are convenient for people reading the program; the computer really doesn’t care what names are assigned.

void setup(){   //configure input pins as an input and enable the internal pull-up resistor
  pinMode(GEAR_SW, INPUT_PULLUP);
  pinMode(CANOPY_SW, INPUT_PULLUP);
  pinMode(LB_SW, INPUT_PULLUP);

  pinMode(SILENCE_SW, INPUT_PULLUP);

  // configure output pins for output.
  pinMode(ALARM_OUT, OUTPUT);

  pinMode(GEAR_IND, OUTPUT);
  pinMode(CANOPY_IND, OUTPUT);
  pinMode(LB_IND, OUTPUT);
  pinMode(MASTER_IND, OUTPUT);
}

The loop part of the sketch will read the switches and throttle position sensor. The loop function will call the display() function created in this program to compare the settings and try to set the lights to the appropriate values. The green lights will indicate the “out of normal” system. Gear down, landing brake, and canopy open are out of normal for cruise flight.

/** 
 * Read all the switches and call the display function
 */
void loop(){
  //read the switch value into a variable
  int gearVal = digitalRead(GEAR_SW);
  int canopyVal = digitalRead(CANOPY_SW);
  int landBrakeVal = digitalRead(LB_SW);
  int silenceVal = digitalRead(SILENCE_SW);
  int throttleVal = analogRead(THROTTLE_IN);

  display(gearVal, canopyVal, landBrakeVal,
  throttleVal, silenceVal);
}

The logic for the master warning is in its own functions. The logic can be minimized to make debugging easier. The state setting is separate from the alert indications. The master warning will happen using some more involved logic. When the gear switch indicates the gear is up, and the throttle position is closed (landing configuration), the alarm state is set. When the throttle position is set to takeoff power, and the landing brake is down or the canopy is open, the alarm state is set.

**   
 * check the logic to see if there is a master warning to display
 * returns 1 if the master warning should be set.
 */
int isAlertState(int gearVal, int canopyVal, int lbVal, int throttleVal)
{
  int alert = 0;
  // throttle closed, and landing gear up
  if ((throttleVal <= THROTTLE_CLOSED) && (!gearVal)) {
  alert = 1;
}

// throttle max and canopy not closed, and landing brake not up
if ((throttleVal >= THROTTLE_MAX) && (canopyVal) && (lbVal)) {
  alert = 1;
}
return alert;
}

The display() function will set the green LEDs, indicating the current “out of normal” system setting. The isAlertState is called to see if the master warning should be turned on. Some logic is called to cause the buzzer to sound. The buzzer is modulated to make a more obnoxious sound. The logic for silence uses the time library. The code will check what time the buzzer will stop sounding. When the silence button is released the silencedAt value will be set. When five seconds have elapsed beyond the silencedAt time, the buzzer will continue.

/**   
 * Process all the logic, to allow displaying LEDs in
 * proper state, and handle master alarm state,
 * including sound.
 */
void display(int gearVal, int canopyVal, int lbVal, int throttleVal, int silenceVal)
{
  int alert = 0;

  // gap is the cycle time for the tone. state is the tone state.
  static int gap=0;
  static int state=LOW;

  // silenced at is the time the alarm was silenced at.
  static time_t silencedAt=0;
  // Keep in mind the pullup means the pushbutton's
  // logic is inverted. It goes HIGH when it's open,
  // and LOW when it's pressed.:
  digitalWrite(GEAR_IND, gearVal);
  digitalWrite(CANOPY_IND, canopyVal);
  digitalWrite(LB_IND, lbVal);
  // The silence button is open normally. Logic is reversed. if (!silenceVal) {
  silencedAt = now();
}

alert = isAlertState(gearVal, canopyVal, lbVal, hrottleVal);

// output the master alarm status
if (alert) {
digitalWrite(MASTER_IND, HIGH);

// generate a tone
if (gap++ == 4) {
state = !state;
gap = 0;
}
if (now() > silencedAt + 5) {
digitalWrite(ALARM_OUT, state);
}
} else {
digitalWrite(MASTER_IND, LOW);
digitalWrite(ALARM_OUT, LOW);
}
}

I feel with the system installed, the aircraft is much safer. Using the Arduino allows a system I can change easily. There is plenty of expansion in the software and plenty of pins available to make a system that will allow me to monitor more of the aircraft. I could add various temperature sensors (i.e., brake, carb, etc.) or access door position sensors that would alert me when those items are out of normal.

Don’t feel like typing? The code from this article, ready for loading into the Arduino IDE, is available here.

/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.

Modified 8 May 2014
by Scott Fitzgerald
*///the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin 13 as an output.
pinMode(13, OUTPUT);
}//the loop function runs over and over again forever
void loop() {
digitalWrite(13, HIGH);// turn the LED on (HIGH is the voltage level)
delay(1000);// wait for a second
digitalWrite(13, LOW);// turn the LED off by making the voltage LOW
delay(1000);// wait for a second
}

int led = 13;

void setup()
void loop()