Recent years have been marked by the rapid development of unmanned aerial vehicles, which is of interest not only to ordinary citizens but also to military, industrial and civilian spheres of activity. Designing and developing software to control the orientation and movement of an unmanned aerial vehicle in space takes a long time, including time for debugging, testing, and conducting flight tests. Errors made in the development of the software can lead to emergencies or other unforeseen failures during operation, which can lead to the destruction of the vehicle or cause harm to people and the environment. In the course of analyzing recent studies of software testing methods for embedded systems, their advantages and disadvantages were identified. It was found that both mechanical test benches and simulation modeling in a 3D environment are used: SIL, HIL and SIH simulation. Mechanical test benches allow testing and calibration of the parameters of real models of unmanned aerial vehicles, but have some limitations. Simulation modeling does not require additional equipment due to the use of virtual models of unmanned aircraft and does not have the limitations inherent in mechanical test benches. The most successful implementation of the test platform is the implementation using SIH simulation. The proposed method is an improved version of SIH simulation. The basis of this variant is a sensor and actuator simulator that ensures the operation of the original firmware of an unmanned aerial vehicle and allows you to organize the interconnection of on-board and personal computers. To test the idea, the test platform was implemented in practice. A configuration utility for the simulator of sensors and actuators has also been developed. The results obtained in the work will allow to organize software testing of the on-board computer of an unmanned aerial vehicle even without having the source code.
Unmanned aerial vehicles (UAV), which are flying robots, are an important part of scientific research in military, industrial and civilian areas of activity: aerial photography and mapping, promptly obtaining information about the consequences of emergencies, monitoring industrial and natural complexes, delivering goods, entertainment purposes, etc. Designing and developing software for controlling UAV orientation in space takes a long time, including time for debugging, testing, and flight tests.
Using classical methods of debugging and testing flight controller firmware is problematic. One way to test controller firmware is to use an oscilloscope and logic analyzer to obtain timing diagrams. This approach is efective, but it is not always possible. In our case it is not possible to use these tools, because the UAV must move in space. When the controller is operating power equipment, it must not be stopped. Stopping the controller during operation at the breakpoint will, at best, cause the equipment to stop, and at worst it may lead to equipment failure. Also further step-by-step debugging becomes impossible because the system state will change (closed-loop control system). However, many debugging tools, such as J-Link, display the change of variables in real time. As in the first case, it is impossible to connect directly, so it is necessary to use remote data transfer. this possibility is theoretically possible (figure 1), but this option is not provided.
Each of the considered options can be used to solve narrowly focused problems, but all the considered approaches do not guarantee the work of the whole system. Mistakes made in the development of UAV software can lead to emergencies or other unforeseen failures during operation. In this regard, the task of checking the reliability of the UAV’s on-board computer software arises, which will simplify the maintenance, modernization and optimization of the software.
Debugging and testing UAV software is a challenging task. The problem lies in the dificulty of generating a complete set of sensor signals and the impossibility of creating emergency situations on a real UAV, so special software and hardware are used to develop, test and debug UAV software.
Let us consider modern approaches used to verify the reliability of software during development,
namely testing. According to the degree of code isolation, there are 4 levels of testing [
Unit testing is a level in which individual modules or components of a program (functions, methods, or classes) are tested independently of the rest of the program. This level of testing is intended to verify that each component works correctly. An important aspect of unit testing is the isolation of the component under test from other components of the application to ensure that bugs are detected and corrected locally within the component.
Integration testing is a level that is aimed at checking the interaction between diferent modules or components of the application. Integration testing checks how components interact with each other and how they interact with external systems, if any.
System testing – a level that is carried out at the final stage of development, when all components of the application are already integrated together and ready for testing in real conditions before the application is released into operation
Acceptance testing is a level aimed at verifying that the application meets the requirements of the customer or end user. It is usually performed by the customer or their representatives.
Testing ensures that: • code quality; • compliance with the stated requirements; • optimization of computing resources; • data security and integrity; • time saving (searching for errors can take a lot of time);
In many cases, the use of testing during the development of, for example, computer application software is suficient to ensure the required level of reliability of the software, but not for firmware.
For efective and eficient testing of embedded software, a large number of testing methods,
approaches, and tools are used, so in [
Embedded systems often need to work in interaction with the environment, using sensors to obtain
input data (temperature, pressure, etc.) [
One of the efective methods of testing embedded systems is simulation modeling. Simulation modeling is a research method that uses models that describe real-world processes. Using such models, it is possible to test the real system without exposing it to danger. Simulation modeling is most often used when it is impossible to conduct an experiment on a real object or it is necessary to simulate the behavior of a real system in time.
The firmware test in UAV simulation can be performed in three places: on a host computer, using
code compilation for the source platform; in an emulator on a host computer, such as QEMU; on a real
lfight controller, using cross-compilation of code for the target hardware. The first two options are used
when performing SIL (Software in the Loop) simulation [
As mentioned above, various testing methods and tools are used to ensure the reliability of embedded
system software. The main dificulty is testing the hardware components of the embedded system, so
additional hardware and/or software tools are being developed. Figure 2 shows a test stand that provides
verification of the functioning of algorithms in the on-board computer, the operation of sensors, motors,
etc. However, it is obvious that this stand limits the UAV’s movement in space. Another approach that
allows you to test a full-fledged UAV flight is to use HIL simulation. The flight is performed in a 3D
environment on a computer (e.g., Gazebo, jMavSim, or another). Figure 3 shows a diagram of such a
HIL simulation system of the PX4 autopilot software [
Obviously, this approach allows testing only the operation of the on-board computer, while other
hardware nodes are virtual. These virtual nodes interact with the on-board computer using the MAVLink
protocol [
To ensure firmware testing in the on-board computer, you need to use mock objects. The purpose of
mock objects is to replace the objects that are tested in the program code with equivalent debugging
objects. Creating mock objects can be associated with some dificulties, for example, using interrupts
from a specific communication interface that a real sensor uses. The disadvantage of this approach
is that the firmware during testing will not correspond to its final implementation. The use of SIH
simulation (figure 5) improves the situation when testing UAVs [
To address these shortcomings, it is proposed to implement a test platform that uses the original ifrmware of the on-board computer. How to implement it? Consider a simplified diagram of any sensor (figure 6).
The sensor consists of: • a sensing element that is directly related to the measured value; • transducer, which serves to convert the measured value into another value convenient for transmission, processing and storage.
When using any simulation option (HIL, SIH), the virtual sensor is fully implemented in a 3D
environment [
The on-board computer already uses communication interfaces with sensors (mainly I2C, SPI), so it is logical to use them to solve the problem. In this case, the on-board computer will access real hardware nodes, but this is problematic because these interfaces are not available in a personal computer. On the other hand, it is necessary to use a 3D environment to organise safe flights when testing UAV algorithms.
Obviously, a node is needed to connect the on-board computer with the 3D environment on a PC to transmit navigation and control information to the UAV. From the above, it follows that a sensor and actuator simulator (SAS) is needed, where the software model will correspond to the hardware nodes. The architecture of the proposed test platform is shown in figure 7.
When using this approach, in fact, the SAS will perform the functions of a sensor converter (figure 6),
and only the sensing element will be used in the 3D environment. The information transmitted from
the 3D environment will be wrapped in a software model of the sensor (in our case, MPU-6050 [
A debugging board is required for UAV simulation. The most popular microcontrollers for the on-board computer are STM32F405RGT6 and STM32F722RET6. Unfortunately, STMicroelectronics does not produce a debugging board based on the STM32F405RGT6 microcontroller, so you need to use a third-party debugging board, such as the Core405R from Waveshare or the STM32F405 Core Board from WeAct. The NUCLEO-F722ZE debug board can be used to simulate an on-board computer based on the STM32F722RET6 microcontroller. The SAS can be performed on any debugging board that has three I2C and SPI interfaces each (the number of interfaces is determined by the number of interfaces in the above-mentioned microcontrollers). In our case, we used the STM32G431 Core Board from WeAct. The configuration of the SAS for each sensor is performed similarly to its prototype, and the data registers are filled with information coming from a personal computer with a 3D environment.
The software of the SAS is implemented in the C++ programming language. For sensors with an I2C interface, the basis is an abstract class shown in the screen (figure 9).
To configure the SAS, we developed a simple utility in the C++ programming language using the QT
framework (figure 10). For each channel, the sensor model, interface, and variable part of the address,
as well as noise parameters are configured in accordance with expression (1) [
= + + , (1) where is the original value, is the current ofset, and is a white Gaussian noise with zero mean.
The article considers a test platform for hardware modelling of an unmanned aircraft’s onboard computer. Various testing methods and tools are used to ensure the reliability of embedded system software. The main dificulty is testing the hardware components of the embedded system, so additional hardware and software tools are being developed.
To accomplish this task, a comparative analysis of existing testing approaches was carried out to identify advantages and disadvantages. It was found that both mechanical test stand and simulation modelling in a 3D environment are used: SIL and HIL. A mechanical test rig is heavy and restricts the UAV’s movement in space. Existing SIL and HIL simulators do not require additional equipment, but they do not take into account the actual operation of hardware components.
An improved version of SIH simulation is proposed. The proposed variant is based on a sensor and actuator simulator that ensures the operation of the original UAV firmware and allows for the interconnection of the onboard and personal computer. The sensor and actuator simulator was built on the basis of the Core Board STM32G431 debugging board from WeAct. To configure the sensor and actuator simulator, a small utility was developed in C++ using the QT framework.
Conceptualization, Arsen Petrosian and Ruslan Petrosian; software, Arsen Petrosian; hardware, Ruslan Petrosian; investigation, Arsen Petrosian; resources, Oleksandra Svintsytska; data curation, Oleksandra Svintsytska; writing-review and editing, Arsen Petrosian.
We would like to express our gratitude to our relatives who supported and helped us. We would also like to express our gratitude to all the organizers of the conference “doors-2024: 4rd Edge Computing Workshop” conference, especially Tetiana Vakaliuk.