Our projects
Graduation Project – Sensor Expansion at Urban Reef
For my graduation project at Urban Reef, I expanded the company’s existing LoRaWAN-based sensor system. Urban Reef develops 3D-printed reef structures designed to create and support microclimates and ecosystems in urban environments. The goal of my assignment was to expand the system within three months with at least three additional microclimate sensors, meeting strict requirements for compact size, low power consumption, cost efficiency, and full compatibility with the existing hub and data processing structure.
Project activities included:
Stakeholder analysis (internal team, clients, investors) to determine which environmental data is most valuable.
Selection of measurement parameters based on scientific standards (ISO, WHO, ASHRAE) and microclimate relevance: temperature, humidity, CO₂, eCO₂, O₂, TVOC, UV light, and particulate matter.
Multi-Criteria Decision Analysis (MCDA) to compare sensors on size, energy usage, cost, measurement range, accuracy, and communication interface (I²C).
Prototype development: integration of selected sensors into the existing Wio E5 LoRa hub with I²C multiplexer.
Firmware adjustments: extending the C++ codebase to handle sensor initialization, data processing, encoding, and LoRaWAN transmission to The Things Network.
Data handling & visualization: implementing custom payload formatters, HTTP POST webhooks, and Apps Script for automatic data storage and visualization in Sheets.
Validation: performing hardware and software testing, analyzing results, and comparing new sensors against existing ones.
Result: A working prototype that extends Urban Reef’s sensor system with two new environmental measurements (TVOC and eCO₂), along with recommendations for the next iteration (Urban Reef V3) to support multiple communication protocols (I²C, UART, analog) and improved power management.
Networking Project: Arduino, Raspberry Pi, Flask & MariaDB
In this project I built a small IoT system where sensor data from an Arduino (GY-521 accelerometer/gyroscope module) was transmitted via a TCP/IP connection to a Raspberry Pi. The Pi acted as a TCP client, web server, and database host, using Flask for the web interface and MariaDB for storage.
Problem: The main challenge was creating seamless communication between different platforms (Arduino C code, Python/Flask web interface, and a MariaDB database). Using Django turned out to be too complex, so a lighter solution (Flask) was implemented. Additional issues included data formatting, database NULL values, and limitations in linking C and Python scripts.
Solution & Result:
Implemented a TCP server on Arduino to read and send sensor data. Developed a TCP client in C on Raspberry Pi to receive and push values into a MariaDB database. Created a Flask-based web interface with AJAX/jQuery for live sensor data visualization. Debugged and refined the database logic to correctly store sensor readings.
The result was a working IoT prototype where sensor data could be streamed, displayed on a webpage, and stored in a database, demonstrating the integration of embedded systems, networking, and web development.
With daily congestion at the elevators during peak hours, students faced delays and often avoided lifts altogether. To solve this, we explored IoT-based methods to monitor elevator occupancy.
Problem: Identify which sensing method could accurately and reliably detect how many people are in a lift, while remaining safe, cost-effective, and privacy-friendly.
Solution: Built a prototype with a pressure sensor (load cell) to estimate passenger count from total weight.Added a Bluetooth/WiFi beacon to detect nearby devices as an indicator of presence.
Programmed and calibrated both systems using Arduino IDE, with real-world testing in campus elevators.
Result: The pressure sensor proved reliable for weight-based detection, while the beacon method offered flexibility but less accuracy due to device variability. A combined approach was recommended for the most effective monitoring, improving elevator efficiency and passenger flow.
Smart Lift Monitoring Project
Robotica Project – Lego Mindstorm EV3
The project was part of the First Lego League (FLL) City Shaper challenge. The main goal was to design, build, and program a Lego EV3 robot capable of performing multiple missions within 2.5 minutes. Beyond building the robot, the challenge required programming in C (via Eclipse with the ARM GCC toolchain) and working with structured design methods (PSD diagrams). The project also included mentoring a group of primary school students, guiding them in programming and mission execution.
Problem & Research Question
The central problem was: How can an EV3 robot be effectively controlled using C-code to execute missions reliably?
Sub-questions included how to design the robot for precision, how to structure the C-code with PSD diagrams, and how to solve technical problems that arose during programming and testing.
Approach & Methods
Hardware Design: The robot went through several iterations. Initial designs with tracks proved inaccurate due to slippage, so the team switched to a two-wheel drive with a support wheel. This made the robot faster, more precise, and better at turning.
Programming: Each mission was broken into subroutines (move forward, rotate, lift, push). These were structured with PSD diagrams and then coded in C. Uploading and testing was done via USB, with repeated calibration for accuracy.
Missions:
Mission 7 – Swing: The robot measured distances (155 cm) and executed precise turns to push the swing. After completing the action, it repositioned for the next mission.
Mission 8 – Lift: Distances were measured (87 cm and 80 cm) and programmed into subroutines for movement and turning, enabling the robot to reach and activate the lift.
Other missions were assigned to the second team member, with similar approaches.
Testing: Distances were refined step by step (large → small adjustments) until the robot executed tasks reliably. Multiple failures occurred due to misalignments, SD card software conflicts, and hardware stability, but these were resolved through redesigns and code calibration.
Challenges
Inconsistent robot movement (did not always drive straight).
Lack of online C-language documentation for EV3 programming.
Hardware design flaws (unstable tracks, unreliable sensors like the gyroscope).
SD card issue that initially limited the robot to Python compatibility.
Results
The robot successfully completed the chosen missions within the given time limit.
The final design (two wheels + one caster wheel) provided consistent performance.
The programming structure with PSD diagrams made the C-code more modular and reusable.
The team gained hands-on experience with embedded programming, problem-solving, and hardware–software integration.
Camping Wi-Fi Antenna & Access Point Project
The goal of this project was to design a low-cost antenna and access point system to improve Wi-Fi connectivity on campsites, where poor signal coverage often prevents visitors from accessing the internet. The solution had to capture weak campground Wi-Fi signals, amplify them, and redistribute them locally through a secure access point.
Problem
Campsites typically lack sufficient access points, resulting in weak or inconsistent signals. Campers at the edge of the coverage area cannot reliably browse, stream, or work online. The challenge was: How can a Raspberry Pi, combined with a suitable antenna, be configured into an access point that strengthens Wi-Fi signals for campers?
Approach & Methods
Research: Conducted desk and field research on antenna types (omni-directional vs. directional) and their suitability for outdoor environments. Studied interference factors such as trees, water, and nearby devices.
Antenna Design: Directional antennas were identified as the best choice, focusing the signal in one direction for long-distance coverage. Copper was selected as the material due to its strong conductivity and affordability. Calculations were made for antenna length based on the 2.4 GHz Wi-Fi frequency (approx. 6.15 cm per half wavelength).
Raspberry Pi Setup: A Raspberry Pi was configured as an access point. The setup included:
Installing Raspbian OS.
Configuring Hostapd to act as a hotspot.
Using Dnsmasq for DHCP and DNS management.
Setting firewall rules with iptables for network routing.
Assigning static IP addresses and enabling IP forwarding.
Security: Implemented a MAC whitelist to restrict access only to approved devices, ensuring security for campers.
Integration: Connected the custom antenna to a Wi-Fi dongle on the Raspberry Pi to redirect the amplified campground signal into a localized hotspot for campers.
Results
Successfully demonstrated that a Raspberry Pi and external antenna could be combined into a working access point.
Directional antennas provided stronger, more stable connections over longer distances compared to omni-directional types.
The MAC whitelist added a layer of access control, preventing unauthorized use.
The solution allowed campers in weak-signal zones to connect reliably through the Raspberry Pi hotspot.
Experimental Research: C Programming on ARM Platform
The goal of this project was to investigate how C source code can be compiled and executed on an ARM-based platform, specifically the Lego Mindstorms EV3 brick. The study aimed to understand the steps required to transform high-level C code into machine code that runs on a processor with a different architecture than the development environment.
Problem
The EV3 brick uses an ARM processor, which cannot directly execute C code written on a Windows or Linux machine. The challenge was to determine which libraries, compilers, and methods are required to cross-compile code so that it can run effectively on the EV3 device.
Approach & Methods
Theoretical Framework: Reviewed how compilers, assemblers, linkers, and loaders work together to transform C code into machine code. Researched machine code concepts such as opcodes, operands, and the binary execution cycle.
Libraries: Identified key libraries for EV3 programming, such as:
ev3.h for sensor input and base functions.
ev3_output.h for controlling EV3 motors and outputs.
Programming Syntax: Investigated the use of C syntax in combination with EV3-specific function calls (e.g., readSensor(), OnFwdSync(), RotateMotor()).
Compiling Methods:
Native compiling – compiling directly on the platform where the code is executed.
Cross-compiling – compiling on one platform (Windows/Linux) and generating executable code for another (ARM/EV3).
Implementation: Developed small test programs in C, including motor control routines and sensor input processing. These were compiled using a cross-compiler configured for the ARM architecture and deployed to the EV3 brick.
Results
Successfully compiled and executed C programs on the EV3 brick.
Demonstrated that cross-compiling is the most effective method for developing EV3 applications, as it allows code to be written on a standard PC and executed on ARM hardware.
Confirmed that the use of EV3-specific libraries is essential for accessing sensors and motors.
Learned the importance of debugging and error handling during compilation, as differences between platforms can introduce unexpected issues.
Engineering Article: Learning to Write a Technical Report
The purpose of this project was not only to investigate the process of compiling C code for the Lego EV3 (ARM platform), but also to learn how to structure and write an engineering article. The assignment emphasized developing a professional writing style: clear problem definition, theoretical background, methodology, results, conclusion, and recommendations.
Problem
The technical subject of the article was: How can C source code be compiled into an executable binary for an ARM platform such as the EV3 brick? While the technical problem was central, the challenge for the student was to communicate this process in the formal structure of an engineering article, ensuring clarity, objectivity, and correct terminology.
Approach & Methods
Theoretical Framework: Researched machine code, compilers, assemblers, linkers, loaders, and cross-compilation. Studied how libraries (ev3.h, ev3_output.h) and syntax are applied in C programming for ARM devices.
Methodology: Followed the structure of an engineering paper: defining research questions, gathering theory, describing experimental steps, presenting results, and drawing conclusions.
Writing Process: Practiced using technical terminology, referencing sources, and formatting the article in a professional way. Paid attention to logical flow between sections, and to distinguishing between theory, results, and personal reflection.
Results
Gained technical insights into cross-compiling for ARM platforms and the importance of libraries and syntax for embedded systems programming.
Produced a full engineering-style article, applying academic writing conventions such as structured sections, formal tone, and references.
Learned the value of precise language and clear structure for communicating complex technical processes.
Case Studies
Artechno Track & Trace
The research project was carried out for Artechno, a company active in automated plant production. The objective was to design and test a more effective track & trace system that could register individual trays of plants, instead of only tracking entire containers. This would allow Artechno to trace production conditions more precisely, improve logistics, and reduce errors.
The main problem with the current HF RFID solution was its limited range and difficulty in detecting trays placed inside larger containers. Trays were frequently moved between containers, making it impossible to know exactly which tray was located where. Additional challenges included the wet greenhouse environment, the risk of signal interference when multiple trays were stacked close together, and the need for tags that were durable, reliable, and cost-effective.
To address these challenges, the project followed the Design Thinking methodology:
Empathize & Define: Company visits, stakeholder interviews, and analysis of the current process to understand the problem.
Ideate: Exploration of hardware options, including different types of UHF RFID tags, readers, and antennas, as well as placement strategies to ensure readability.
Prototype: Building a small-scale system with trays and UHF RFID components. A backend database was implemented to store tag IDs and link them to trays and containers.
Test: Tags were tested for range, water resistance, durability, and interference handling. Multiple positions on the trays were evaluated to determine optimal placement. The system was also tested with an ESP32 microcontroller for integration and database connectivity.
The results showed that UHF RFID provides a clear improvement over HF for tray-level monitoring. The tags could be read reliably when placed in protected but visible positions, and the ESP32 successfully communicated with the backend system to log tray IDs. However, challenges remained in filtering duplicate reads, avoiding interference between nearby containers, and ensuring consistent performance in humid conditions.
In conclusion, the project demonstrated that UHF RFID is a viable solution for Artechno’s needs, provided that careful attention is given to tag type, placement, and reader configuration. A combined approach of hardware testing, software filtering, and robust installation guidelines was recommended to achieve accurate, scalable, and user-friendly tray tracking within vertical farming operations.
Aquabots:
Reliable Data Connection Between Shore and Ship
The project focused on creating a reliable wireless communication system between an autonomous boat (Aquabot) and the control center onshore. The objective was to replace the existing wired setup with a secure, stable, and long-range network connection, enabling real-time instructions, monitoring, and data collection during missions.
Problem
The previous system required operators to stay close to the boat and manually update its memory for new tasks. This was inefficient, limited the operational range, and prevented continuous monitoring. The challenge was to design a solution that could:
Maintain a fast and stable connection (latency within milliseconds).
Handle multiple simultaneous connections.
Ensure data security and prevent unauthorized access.
Remain cost-effective and compatible with ongoing boat subsystems.
Approach & Methods
The project followed a multi-step approach:
Literature Research – explored existing methods for wireless communication (Wi-Fi, LTE/4G, satellite, VHF) and reviewed documentation from earlier student groups.
Prototype Development – implemented using the Khadas Vim3, a powerful single-board computer (similar to Raspberry Pi) integrated with sensors and modules. An M2X extension board was added for LTE 4G connectivity, SIM support, and expanded storage.
Antenna Selection – evaluated three antenna types:
VHF (Very High Frequency) for radio and short-distance communication.
Wi-Fi/Cell antennas for flexible wireless and mobile data connections.
GPS antenna for global satellite communication (effective but not budget-friendly).
Ultimately, a Wi-Fi/Cell antenna was chosen for reliability and cost balance.
Server & Networking Setup – a virtual server was provided by the client to manage connections. Communication was structured via IP addresses, enabling a defined start and endpoint between boat and shore.
Security – implemented with firewalls, encryption, and authentication through the MQTT broker (Aquastorm software). Login credentials and certificates ensured data integrity and access control.
Testing – experimental trials included data transfer and video streaming over the network. Latency tests using “ping” showed consistent results of around 50 ± 10 ms, confirming stability under light traffic.
Results
The wireless connection worked reliably via the internet, fulfilling the requirements for real-time control and monitoring.
Data was successfully transmitted and secured using MQTT with login protection and encryption certificates.
The system provided flexibility for use within the harbor and the potential for expansion to larger ranges.
The final prototype allowed the Aquabot to operate without constant human presence nearby and enabled central data collection at the control center.
