CRP's Tech Blog
Rust Project: CRP's Budget Book
17.03.2025
In 2024, I set myself the goal of deepening my knowledge of the system programming language Rust. The most effective way for me to learn a new language is by developing a practical project that is both challenging and relevant. I chose a budget book because it covers numerous technical aspects, including UI development, financial data processing and storage, and cross-platform deployment of the application.
In this article, I want to provide a comprehensive insight into the current development status of my project, describe challenges, and present solutions.
Requirements for the Budget Book
The application should offer an intuitive user interface (UI) that allows users to easily manage their income and expenses. My budget book should also be well suited for managing club financial records or similar needs. The data is stored in a database to ensure reliable and structured processing. To reach a broad user base, the budget book is being developed in multiple languages. Currently, support for English, German, and Russian is planned.
Through a settings menu, users can customize parameters such as date and currency format, default currency, and language. Additionally, a comprehensive reporting function will compare income and expenses and calculate the current balance. These reports will not only be viewable within the application but will also be exportable as PDF files.
Another important feature is the ability to import financial data as CSV. Privacy remains a key focus: the application initially operates entirely locally without connecting to a central database server. However, future plans include integrating a synchronization option via WebDAV so that users can sync their data with a private server.
Cross-platform support is also a central goal of the project. Currently, the application is being developed for Linux and Windows, while Android, iOS, and macOS will follow in later phases. The next platform to be supported will be Android, and I plan to release the app on the Play Store.
Technology Stack
For UI development, I use Dioxus, which provides cross-platform support. Data storage and management are handled via rusqlite, a powerful and lightweight SQLite library for Rust.
Build Process
To ensure a clean and reproducible development environment, I use Docker combined with a custom build script. This allows me to efficiently manage builds for different platforms and minimize issues caused by inconsistent development environments.
Windows Build
The Windows version uses the x86_64-pc-windows-gnu platform. Since not all necessary libraries are statically linked, the corresponding DLL files are provided separately alongside the executable file. The program package is then bundled into a ZIP archive.
An installer for Windows is not yet implemented but is planned for future versions.
Linux Build
The Linux version is compiled for the x86_64-unknown-linux-gnu platform and provided as an AppImage. This distribution method ensures that the program can run on various Linux distributions without requiring a complex installation process.
Tests on independent Linux systems have shown that some dependencies were missing in the AppImage. After a thorough analysis, the missing deb packages were identified and included in the build package to ensure seamless usage on other Debian-based systems. Currently, I have not been able to test the AppImage on non-Debian-based systems, so I cannot yet make any statements about its compatibility on those systems.
Build and Tests in CI/CD in GitLab
To further optimize the build process, I have implemented a CI/CD pipeline in GitLab.
This ensures that commits to open merge requests are automatically compiled.
Thanks to Rust's integrated test framework, I was able to add a test stage to the pipeline.
There, all unit tests are executed to ensure that the program still functions as expected.
Additionally, it gives me a sense of security when I create unit tests for individual
software modules and all tests pass successfully.
Impressions of the Current Development Status
Conclusion
Developing my budget book project has already provided me with many valuable insights. I was able to deepen my knowledge of Rust and the Cargo build system and compare Rust's unique features with other programming languages.
I was particularly impressed by Rust’s integrated test framework, which has proven to be extremely valuable for maintaining a stable code base. This highlights how Rust, as a modern system programming language, effectively integrates many proven concepts.
Weather Station on the Balcony – A Bluetooth Learning Project
19.03.2025
Bluetooth Low Energy (BLE) is an efficient solution for wireless sensor networks, especially for energy-optimized IoT applications. In this article, we combine theory and practice by developing a BLE driver for an ESP32-WROOM in a real-world scenario: an environmental sensor on the balcony that measures temperature, humidity, and air pressure and transmits these values via BLE to my home server.
Project Goal: A Weather Station for the Balcony
The goal is to develop a solar-powered weather station that regularly records environmental data and transmits it via BLE to my home server (Raspberry Pi 4). Energy-efficient communication is the key focus to ensure long battery life.
Hardware Components
- ESP32-WROOM-32 module
- BME280 sensor (temperature, humidity, air pressure)
- TP4056 charging controller module
- Solar SP2 panel
- LM3671 3.3V regulator
- LED for status indication
- LiPo battery
BLE Driver Development: Basics and Challenges
A BLE driver acts as an interface between the application software and the ESP32 hardware. It involves several layers:
- Controller Layer: Controls BLE functions at the hardware level
- Host Layer: BLE protocol processing (GATT, GAP)
- Application Layer: Data exchange with the application
Key challenges include:
- Energy-saving mechanisms to maximize sensor uptime
- Reliable data transmission with minimal overhead
Firmware Development: Implementing a BLE Driver
I use VS Code with the ESP-IDF plugin as the development environment, which includes the
necessary compiler for the ESP32. The build system used is CMake.
The ESP32 firmware is written in C++. The following core functions have been implemented:
- Advertising mechanism: The ESP32 periodically sends data packets containing sensor readings. The sensor acts as a broadcaster, eliminating the need for a connection to retrieve data.
- Deep-sleep mode: After each measurement, the ESP32 switches to a low-power state.
- Reconnect handling: Automatic reconnection after a connection loss
Data Transmission to the Home Server
A crucial aspect of this project is the reliable and energy-efficient transmission of sensor data to the home server. Since the ESP32 operates as a BLE broadcaster, it periodically transmits measurement values as BLE advertising packets, without requiring the home server to actively request data. The process works as follows:
- The ESP32 processes environmental data, such as temperature, humidity, and air pressure, and packages it into BLE advertising packets.
- The home server (in my case, a Raspberry Pi 4) continuously listens for BLE advertising data and receives the transmitted values.
- The received sensor data is stored on the server in CSV format and visualized using a Jupyter Notebook.
This method keeps the ESP32 highly energy-efficient, as it does not need to manage complex BLE connections but simply sends advertising packets at regular intervals.
Troubleshooting and Debugging
Various debugging methods were used during development:
- BLE sniffer (Wireshark with nRF Sniffer plugin) for analyzing BLE packets
- Logging BLE events to trace connection issues
- Debugging with Segger J-Link Compact in VS Code
Structure of a Bluetooth Advertising Packet
A Bluetooth advertising frame consists of the following elements:
- Preamble: Synchronization pattern marking the start of a new frame
- Address: Static address of the packet as UInt32
- PDU header: Contains information about packet type, payload length, and control flags
- PDU payload: Consists of a 6-byte MAC address of the broadcaster and the actual payload. In my case, temperature, air pressure, and humidity data.
- CRC to ensure communication reliability and detect transmission errors
Conclusion
Developing a BLE driver for the ESP32 requires a well-thought-out architecture, especially concerning power consumption and memory management. The balcony sensor project demonstrates how BLE can be practically used to collect and transmit sensor data efficiently. With optimized BLE mechanisms and a robust driver architecture, a long-lasting and reliable IoT solution can be achieved. I thoroughly enjoyed this project and learned a lot. Unfortunately, it remained a private study, and I have not yet implemented a permanent installation on my balcony.