SJ FlightSense

Flight Sense - Realtime Avionic Telemetry and Intelligent Fault Detection

Comment

Inspiration

Since we were young, we had a strong interest in aviation and how plane avionics telemetry function. We have played real-time simulations, including XPlane, Microsoft Simulator Flight, and real-time simulation equipment in airports across America. We have been further inspired to discover and apply these principles as a foundational means to our EE careers to expand our knowledge and advance as engineers.

What it does

SJ FlightSense is an avionics-inspired prototype that meshes environmental telemetry data acquisition with an interactive, manual fault detector and actuator-control demonstration. This design is powered by two embedded subsystems that complement one another. The first subsystem is an Environmental Telemetry System that utilizes a STM32 NUCLEO-F446RE microcontroller that is connected to multiple environmental sensors, measuring temperature (in Celsius), humidity (in %), atmospheric pressure (in hPa), and an estimated relative altitude (in meters). The second subsystem is a physical fault-response indicator that is powered using an Arduino Uno, a push button, a red warning LED light, and a TowerPro SG-5010 servo motor. When the servo operates normally detecting no fault, the motor alternates between the two programmed angular positions of 60 degrees and 120 degrees. When the operator pushes down the manual fault-trigger button, the Arduino detects this (simulated) fault through digital inputs, illuminates the red LED, and instructs the servo to return to and hold its initial position of 90 degrees. Once the button is released, the servo continues standard operation. Together, these 2 subsystems establish a solid foundation for a broader FlightSense platform that will eventually measure and connect live sensor measurements to physical control, digital visualization, and automated monitoring.

How we built it

Our 2 subsystems called for two parallel workstreams on STM32 IDE and Arduino IDE to complete the foundation of the overarching project. Our team's Hardware and Control Systems Lead Jadyn Hardy pursued the objective of establishing a functional hardware control system using an Arduino Uno, 2 TowerPro SG-5010 servo motors, and Arduino firmware to represent independent pitch and roll control surfaces for our simulated project. These crucial Arduino steps allowed us to develop our dual-axis demonstration with coordinated manual or automated fault response and consistent power distribution. The hackathon time constraint provided some creative introspection regarding our mechanical design and physical demo representation, though functionality and software integration took slight priority over a idealized rocket gimbal build. To establish stable communication between our Arduino Uno and a computer, we utilized PySerial to implement a serial-command interface that can instruct both the Pitch and Roll Servos, activate and disengage software fault mode, and confirm communication every step of the way. To expand on the informativeness of our physical subsystem, we integrated a Seeed Studio Grove RGB LCD V4 using the Arduino's I²C interface. This configured display notes normal system operation, pitch and roll commanded angular positions, active fault conditions, and visual indicators for fault occurrences. Finally, we prepared the Arduino to be integrated with the Python-programmed real-time dashboard. Using PySerial, the Python backend we constructed can request the aforementioned display messages and detect the manual (human-made) and software-generated (artificial) faults. This preparation was key for integrating the STM32 microntroller with the Arduino Uno to align with the FlightSense monitoring application. Our Sensors and Embedded Systems Lead Sherlon Junor focused on preparing, soldering, and implementing sensors to gather live environmental data, configuring the STM32 microcontroller as the brain of our system, and developing the Python monitoring dashboard. Firstly, the sensor subsystem was developed around a STM32 NUCLEO-F446RE development board for data acquisiton and accurate communication. Then, an AHT20 temperature and humidity sensor and a BMP280 pressure sensor were integrated into this subsystem to measure ambient temperature, atmospheric pressure, and estimates relative atmosphere through barometic pressure measurements. Once we obtained data, we converted the embedded sensor measurements flowing into the Python datastream into readable enviromental telemetry. Utilizing a USB virtual COM ort, the STM32 subsystem was configured to receive and transport measurements indirectly. This separation aided in both easier debugging processes and a convenient communication pathway between the sensing hardware and our dashboard application. With Python, he programmed a dashboard that serves as a central interface for the system's key sensor measurements, including estimated altitude and angular velocity. To merge our sensor and control subsystems, we implemented a two-USB architecture. The STM32 communicates to Python through one USB connection, while Arduino communicates utilizing another. Furthermore, we implemented a Grove RGB LCD to add a local tangible display without compromising our STM32 sensor circuitry. At our conclusion, Python application served as the great midpoint, receiving sensor measurements and monitoring the Arduino's fault state through PySerial. We utilized the Version Control tool on Github to update progress to our repository every (significant) step of the way.

Challenges we ran into

We ran into a few challenges. For example, in the Arduino workstream we encountered improper grounding in our circuit, inaccurate polarity wiring, and (for STM32) we encountered incorrect pin assignments and syntax errors. This was fixed after rigorous inspection. Additionally, inconsistent circuitry exposed our Servo motors to instability and jitters that interrupted their normal operations and influenced the physicality of their respective fault states. We solved this by ensuring the external 5V power supply was grounded in our Arduino.

Accomplishments that we're proud of

We were proud to navigate through the challenges that this project had thrown in our path. Our teamwork and collaboration was evident and carried us over these obstacles. Within one prototype, we encountered environmental monitoring utilizing real sensors, manual and software-controlled fault responses, dual-axis actuator control using Arduinos and servo motors, and Python-based telemetry visualization coding and discovered a pathway forward for integrated fault monitoring.

What we learned

We learned new concepts, such as debugging, programming techniques like C and Python, and how to power through consistent programming and circuitry obstacles. Furthermore, there was a clear intersection of power distribution, input prioritization, common grounding, serial communication, web design and coding, and data processing that is usually introduced over the course of multiple Electrical Engineering courses over multiple semesters. We grappled with and developed understanding of these concepts in less than 24 hours.

What's next for SJ FlightSense

We will further continue to improve our model, as this prototype serves as a foundation for our programming and embedded systems journey as EE Sophomores at UB. We plan on building a physical two-axis demonstration mount to better visualize the servo motors' impact on movement and orientation. As we navigate through the foreseen weekends beyond the Hackathon, we will consistently improve this project and implement additional features for local visualization and clearer indication capabilities.

Built With

Share this project:

Updates

Submission history