How Evolutek Used Ada to Build Their CanSat

AdaCore supports practical engineering projects that help students apply technical concepts to real-world problems. As part of this effort, AdaCore sponsored Evolutek, a student-run robotics club founded in 1997 and backed by the IONIS Group. Evolutek brings together students from three French engineering schools, EPITA, EPITECH, and IPSA, and has consistently achieved strong results in the French and Belgian Robotics Cups.

Last year, the Evolutek team entered the field of aerospace engineering by building its first compact satellite (CanSat), Evolusat MK1. The team developed the flight software, sensor drivers, telemetry, and mission-control software entirely from scratch, using Ada throughout and managing the project with Alire. This year marked the next step in that journey with Evolusat MK2.

Evolutek has just returned from this year’s CanSat competition, in which they participated with their MK2 design with excellent results. Read on to learn more about the team’s work, technical choices, and lessons learned.

The CanSat Challenge

The task is to build and operate a compact satellite, hence the name CanSat, that fits within a maximum one-liter cylindrical envelope. The satellite is then dropped from approximately 120 meters and must complete several precise technical missions during its descent and after landing. These missions are divided into mandatory and optional categories.

Mandatory Missions

This year, the team was required to complete the following mandatory missions:

Separation

The CanSat had to separate cleanly into two modules between 40 and 60 meters of altitude. The separation mechanism was required to withstand a force of at least 30 N.

Telemetry

The CanSat had to transmit real-time altitude measurements and at least one atmospheric parameter, such as temperature, pressure, or humidity, to a ground station.

Optional Technical Missions

Teams could also select several optional technical challenges to earn additional points:

Miniaturization

Build the CanSat within the volume of a 33 cl soda can, rather than the standard one-liter cylinder, effectively doubling the scoring potential.

Alternative Altitude Measurement

Measure altitude accurately without relying on GPS or barometric sensors. Alternative methods included techniques such as laser ranging or ultrasonic sensing.

Distance Measurement

Precisely measure and transmit the distance between the two separated modules.

Custom Mission

Design and execute an original mission evaluated on creativity, technical relevance, and successful implementation.

The team built the entire system from scratch, including sensor drivers, telemetry infrastructure, and mission-control software.

Why Ada and AdaCore?

Choosing Ada for the CanSat project was a practical decision. As a low-level programming language that supports the development of high-level abstractions, it gave the team both direct hardware control and the flexibility to write structured, modular, memory-safe, and type-safe code.

Designed for reliability and maintainability, Ada proved well-suited for software that had to work on the first try, in flight, with no second chances.

Its strong typing, runtime checks, and well-defined semantics made it easier for the team to implement sensor drivers from scratch. The debugging process was smoother than expected, as many ambiguous edge cases were detected early, during compilation.

The team relied on Alire, Ada’s package manager, to manage dependencies and structure the codebase. It simplified library integration, kept builds reproducible, and helped onboard new contributors without destabilizing the project. Paired with the GPR build system, it provided a consistent workflow that scaled from early experimentation to full system integration.

AdaCore supported the project through funding and technical mentorship. Since AdaCore already maintains toolchains for STM32-based platforms, the same family of microcontrollers used on the CanSat board, the collaboration was a natural fit. This allowed the students to focus on applying industrial-grade tools to a concrete, real-world engineering challenge.

EvoluSat Mk2

Evolution is part of Evolutek’s DNA, and the MK2 version of the CanSat is a natural progression from MK1. For this reason, this section will occasionally refer back to MK1, as well as to the overall design philosophy that drives Evolutek’s projects.

Mechanical Design

For EvoluSat, Evolutek focused on simplicity and maintainability. The core idea was to build the satellite around a central structural plate. Last year, the structure consisted of four 3D-printed PLA modules mounted around a central PLA frame. This year, that number increased to five due to additional mission constraints, as the CanSat was required to deploy a secondary module.

This modular layout offers several advantages. First, it provides direct access to all internal components, making assembly, testing, and repairs straightforward. Second, a reinforced central body maintains overall structural rigidity without overcomplicating the design. The separation mechanism relies on a rotating ring located at the interface between the main body and the secondary module, while the parachute is attached directly to the top fairing using minimal hardware. Finally, PLA was chosen for its low cost, ease of printing, and sufficient mechanical strength for the application. More importantly, it allowed the team to print replacement parts on-site. This is an important advantage when components break or require adjustment between test runs.

Overall, the result is a clean and functional design that strikes a careful balance between weight, durability, and ease of iteration.

Hardware Development

Development process

For the first generation of the CanSat, the team focused on building a reliable system using off-the-shelf components in order to keep the integration cycle as short as possible.

Relying on prebuilt modules simplified early development but increased the bill of materials and limited flexibility during final integration. The development board’s large footprint complicated the mechanical layout, and the power supply system was over-dimensioned, consuming space that could have been used more efficiently.

Such practical trade-offs are common and acceptable during early development phases and were sufficient for the first-generation CanSat. This year, however, the challenge was to fit all electronics within a 33 cl volume, which required significant refinement of both the mechanical and electronic designs. While the overall mechanical concept was retained, scaled down, and adapted to meet the new constraints, the electronics were completely redesigned around custom circuit boards, as off-the-shelf development boards were simply too large to fit.

AFS and ESP

The main flight controller, referred to as AFS (Advanced Flight System), is a custom PCB based on the STM32F407 microcontroller. It interfaces with the following subsystems:

• GPS module (PA1616D) via UART
• LoRa module (Wio-E5 Mini) using AT commands over UART
• IMU (BNO085) via I²C
• Barometer (BMP390) via SPI
• Magnetic sensor (AS5600) via SPI
• Servo motor (DS041MG) controlled via PWM

The ground station is built around two Wio-E5 Mini LoRa modules connected to a Linux-based PC.

The system workflow is as follows: the AFS collects data from the IMU, barometer, GPS, and magnetic sensor; stores the data locally on an SD card; and simultaneously transmits it to the ground station using the LoRa protocol. The entire system is powered by a 9 V LiPo battery.

The secondary module, referred to as ESP (Electronic Separation Payload), is a stripped-down counterpart of the AFS. It omits extension interfaces and includes only the essential components: a barometer, a magnetic sensor, an IMU, and a LoRa transmitter.

Software Development

Development Process

While developing EvoluSat MK1, the team began by exploring Ada on the STM32F429DISCOVERY development board, using the stm32_blinky_demo from the GNAT Academic Program. These early experiments helped the students become familiar with the language’s syntax, semantics, and development environment before moving on to the actual hardware target. The choice was to run Ada baremetal, that is, directly on the hardware without the addition of an OS, this provides the capabilities that the team needed, without adding additional overhead and complexity.

After receiving training from AdaCore and selecting the Nucleo-G431KB development board, the team transitioned to full-scale development. To streamline the workflow, they relied on Alire, Ada’s package manager. This setup provided access to up-to-date board support packages and allowed dependencies and builds to be managed in a reproducible and structured way.

Each hardware component was paired with a dedicated driver built around a consistent structure: a configuration record and an Init procedure. This standardization improved readability and reduced the learning curve associated with using a new language on bare-metal targets. To keep development simple for the initial version, the team used polling for all driver communication, deliberately avoiding interrupts and their associated complexity. While this approach limited efficiency, it enabled rapid development of a working and testable system.

The second iteration retained the same microcontroller, which meant the effort was primarily focused on reorganizing the software. The team created its own Alire index to better structure the project and maximize modularity. Each driver was turned into an Alire dependency, making it easy to reuse the same code across future projects.

Because MK2 was designed to include a secondary, deployable module, also powered by a microcontroller, Evolutek chose to further challenge itself by attempting to port the SDK to another microcontroller family. Although this work was not completed in time for the competition, the team plans to finish it next year.

Software Design Decisions

Two dedicated UART buses were used for the GPS and LoRa modules, with a shared abstraction layer handling GPIO configuration and peripheral initialization. The I²C bus was initialized once and shared by the remaining sensors. The servo driver supported precise angle control and incorporated safety limits to prevent unexpected movements.

The main control logic for MK1 was implemented as a simple three-stage state machine. State transitions triggered mechanical actions, including the deployment of landing legs during descent and the raising of a flag after landing, both driven by servo actuation.

In the second iteration, the control logic evolved into a five-stage system for the AFS:

1. STARTUP
1. WAITING_JACK
1. READY
1. DROPPED
1. PAYLOAD_RELEASED

Implementation and Testing

Ada’s runtime checks and exception handling proved valuable in improving overall system robustness. To catch faults at runtime, the program’s entry point was enclosed in a top-level exception block that logged errors over the UART.

This approach ensured that most issues could be detected and debugged during development. While exceptions occurring within the UART module itself could interfere with error reporting, this risk was considered minimal, as UART-related errors were typically ignored by design.

For flashing and debugging, the team relied on the open-source OpenOCD toolchain alongside an STLINK-V3 probe, which also served as the UART bridge.

Achievements

The project delivered several concrete results. The team completed a second iteration of an embedded system developed entirely in Ada, including custom drivers and a state-machine-based control loop. They designed, assembled, and integrated the complete CanSat hardware and software stack.

Both iterations of EvoluSat were flight-tested at altitudes of 30 m, 50 m, and 150 m, achieving nominal behavior in all cases. The second model demonstrated a clean and reliable separation at 50 m. Sensor data was successfully collected and processed, validating both the hardware integration and the reliability of the software under real flight conditions.

Looking Ahead

With a complete flight cycle behind them and successful deployment and testing completed, the team is now preparing for the third edition of the CanSat competition. Their focus is shifting toward refining the hardware architecture, optimizing software performance, and simplifying system integration, building directly on the lessons learned during development and field testing.

Key areas targeted for improvement include:

• Addressing hardware issues identified in the custom PCBs
• Replacing polling-based drivers with interrupt-driven implementations
• Streamlining power management

As part of this effort, the team plans to release their drivers, flight logic, and build setup publicly through Alire. These components will be cleaned up, documented, and packaged to allow other teams to benefit from their work.

The project was made possible with the support of AdaCore, both through direct sponsorship and the GNAT Academic Program, which provided access to the tools and training required to effectively adopt Ada.

Although Ada is part of EPITA’s academic curriculum, this project marked the team’s first opportunity to apply it in a real-world embedded system. It allowed Evolutek to gain hands-on experience with Ada’s strengths, particularly its safety features, strong type system, and structured approach to low-level programming. Looking ahead, the team is eager to build on this foundation for the next EvoluSat iteration and to contribute back to the Ada community.

Conclusion

EvoluSat is a good example of what can be achieved when students take full ownership of a technical challenge and see it through with the right tools. From the outset, Evolutek members chose to build everything themselves, from mechanical design to flight software, and to do so using Ada. That decision gave them a structured and reliable foundation, enabling the application of real-world engineering practices within an academic setting.

AdaCore side supported the project through tooling, guidance, and funding where appropriate. The goal was not to steer design decisions, but to facilitate the team’s adoption and effective use of Ada in an aerospace and embedded context. The team has already built something real; the next step is iteration, refinement, and continued learning. The next steps will be equally interesting!

Call to Action

To learn more about the tools and resources used in this project, visit AdaCore’s educational portal and explore the GNAT Academic Program (GAP), which supports student-led initiatives around the world:

https://www.adacore.com/academia

You can follow Evolutek’s progress and upcoming CanSat participation through their official channels and social media. Their work is a strong example of what becomes possible when education, industry, and open source come together, and we are proud to be part of that journey.

You can also try Ada yourself through Alire by visiting https://alire.ada.dev/.