Projects in detail

• Transport: MQTT
• Authentication/Authorization: JWT
• USER, THINGS storage: PostgreSQL
• THINGS DATA storage: InfluxDB
• Services intercommunication: gRpc
• Services messaging: Nats

• Transport: OPC-UA
• Data presentation: Grafana
• Reverse proxy: Nginx
• Secret storage/management: Vault
• Caching: Redis
• CI/CD: GitLab

This project page has been separated into to project pages 'LoRaWAN Health V1' and 'LoRaWAN Health V2' as they represents two distinct approach to its backend development.

The previous version used docker with self-managed services with quite a few moving parts and hence higher development complexity (for a team of 1 person).

In this version I moved to a totally different architecture with AWS services which enabled for a much quicker development and much lower operation complexity, at the price of vendor lock-in.

With the use of the LoRaWAN protocol/devices, we can now received data within a kilometer range, still at a low frequency/bandwidth, hence a mandatory processing is made on the wristwatches. The system is now simpler to deploy with only one or few LoRaWAN gateways, rather than tens of mesh relays and gateway.

For the wristwatch and its PCB, we developed a custom system made of several stacked PCBs connected with our own flex connectors. The case/garment that will host this system is developed by a third party company, whom we are in close collaboration.

The Firmware of the STM32 chip within the PCB is written in C and is responsible for controlling the LoRaWAN chip (also from STM) and sampling the sensors. The heart-rate sensor is an entire system by itself with and IC responsible for the data sampling and processing, with extraction of the features. Battery management/protection are also a part that we designed with a lot of care.

The Mobile App has been written with the Flutter SDK. It is used to log the user in, fetch health data online and send/receive notifications.

The LoRaWAN Dockerized Backend is using the ChirpStack project, which allows us to deploy our own LoRaWAN network and application servers. By using our own network server we are able to manage a higher throughput for the system as well as a fine grained control on the application.

Our Dockerized Backend application is there to manage the user, the access to the health data, the notification system, and so one. Its most notable components are Express.js, PostgreSQL, Socket.IO.

A static and well-optimized website, nothing too fancy.

The color selection and UI design are my own.

Wootch's PCB has been made on Altium Designer. it features:

• Battery management, protection and regulators (buck)
• Inertial Measurement Unit (IMU, accelero + gyro)
• FPC connector for 3.5 inches LCD (480*320px) touch capacitive
• Wi-Fi-enabled MCU (esp32)
• Vibration motor and controller IC
• Speaker amplifier
• USB C charging
• Push buttons and RGB LED
• Programmer/debugger

The code is written in C (not C++) along the ESP-IDF SDK . its main component are the following:

• ESP-IDF SDK, peripheral, Wi-Fi, RTOS.
• LvGL graphical library, to easily create responsive UI and provide support for the touch sensitive screen.
• esp_mpu60x0_C, MPU6050 IC from Invensense driver in C.
• ESP-AWS-IOT to interface with the AWS IoT-core service and provide a light-weight, fast and secured with AWS servers. It leverages the MQTT protocol with asymmetric key exchange, symmetric encryption.

The Backend will use the serverless framework:

• Receive MQTT messages,
• Extract data and store them in a dynamoDB Database
• Run analytics on the stored data
• Manage users
• Manage IoT "things" and secure their data link

This project start when our Sensor research team needed a way to test their sensors in real life case scenario and showcase them for the multiple event that HBKU hosted.

One objective was to make this project adaptable for various product situation (smart mask, clothes, appliances, etc...), the printed sensors being the main varying element. We therefore opted for a Bluetooth enabled platform to be connected to a mobile application.

The circuit itself possess a Bluetooth device from Nordic acting as the main computing and communicating component. USB-C, power supplies, battery management/protection, LEDs, RC filters, flat connectors for the printed sensor are all the peripheral we needed to make this system works.

It connects to the mobile app through a bluetooth link which enable us to sample the sensor and control the embedded system (sample rate, gain, etc...). The mobile application manages the Bluetooth connection and the sensor data storage in a local database. Finally, a large part of the application consists on an offline tool for navigating and filtering the data (analytics).

Topic Studied and Resources

• Many programming challenges/problems solved on Codewars
• Python design patterns
• Full stack applications design
• Algorithms design and usage
• SQL and NoSQL databases
• Cloud computing with AWS

We have developed a custom wrist-mounted device, RF enabled, that integrates into a low-power Mesh network ( OpenThread ). All Bio data are sent to our server hosting a full stack application (backend/database and front end). This system is easily scalable so hundreds of companies can monitor the health status of hundreds of their employees. 

Each person is wearing a custom smart wristwatch that contains essentially two temperature sensors (on for the skin and one for the ambient temperature, one heart rate / oximetry sensor (oxygen level), and one dehydration sensor (that is still under development with our research team). Each of these devices is transmitting and listening data from the RF low-power network they are authenticated to, at regular intervals. The network is created by a set of routers that relay the sensor data to a gateway, which is a router connected to a board computer with an internet access. This RF mesh network protocol is the OpenThread implementation, for low-power, (relatively) high bandwidth and latency, and robustness. This Gateway, send data to our backend application, hosted online , with a by directional communication . That way, our server online can received and send data to each node. Finally we designed a frontend application (website) that can display all of these data and control the overall behavior of the system. Moreover, this system integrate user authentication, meaning that we can easily scale this system up, so that many different company can have their own sets of wristwatch/routers/gateway and access their data online, securely, as we are using the latest security technologies, both for the online server, the mesh network and the hardware. 

• Wrist-mounted device (wristwatch), containing sensors and wireless chip for the mesh network communication, battery powered, with a firmware written in C. This system is custom made by our team, which concerns both the Printed Circuit Board (PCB) and the wristwatch bracelet (3D printed with hard and soft materials). 
• Mesh Router device (plugged to a wall socket) containing a wireless chip with a power amplifier (firmware written in C as well). This system is also custom made (PCB, and 3D printed case). 
• Mesh Gateway device with the same component as the Router above; it role is entirely different as It is the interface between our mesh network and the single board computer, with which they communicate via a serial connection (C programming). 
• Gateway device , which is a single board computer running a Node.js daemon program, which make the link between our full-stack application and the Mesh network (JavaScript). 
• Backend server application , Which consists into a REST API coupled with a Database. We used Node.js with Express and MongoDB. This application was written in JavaScript. 
• Frontend Application (hosted by the backend server) that uses the Angular framework (Typescript/ JavaScript). 
  The 6 above parts are 6 independent programs and physical devices (except for the frontend application and backend server that are run on online servers). 

We therefore used the Bluetooth 4.2 (BLE) protocol in a star topology with a base station being a computer for display and storage.

The embedded system consisted into a Nordic Semiconductor wireless MCU along power supply/management, vibration motor, LED and a FFC connector to connect multiple sensors. The base station connected to the PC was containing the same Nordic Semi chip along with a UART/USB interfacing chip. The data were then displayed on the PC. By the architecture of our system, we could connect as many node to the base station as the Bluetooth bandwidth would allow, which represents hundreds of nodes, as each node only transmit few times per minutes (which is selectable). The system is bidirectional, meaning that the Base station could send notifications/warning to the embedded system and vice versa. We designed the PCB with Eagle (Cadsoft) and had it manufactured in China, soldered in Qatar by ourselves. The code was made in C with Segger Embedded Studio. The Graphical application was written in Python with PyQt for a quick prototyping .

Regarding most of these workstations, manipulations and consumables we designed all the technical specifications in term of our projects needs but also in terms of safety , storage and maintenance . This helped me significantly to develop my organization skills, my human contact with the different actor involved in laboratory management and my knowledge about the state of the market for the electronic machinery and consumables. In term of my work schedule and achievement, The set-up of the lab was time consuming only for 6 months during the design and set-up of the lab in collaboration with our Facility management team, the safety team and our procurement team that leveraged the administrative work, leaving us only the essential technical work to do . For the two and half following years, I only assisted on critical issues and seldom set-up of new machinery.

For this project, I designed a web crawler used to collect the data of our ERP system, sort them and gather them into a spreadsheet. This program was mainly using Selenium, a browser controller library used to automate test but not only. The goal was to automate a repetitive task that slowed down our division work in term of material resources management. 

In the context of sustainable energy development. A Research set up a protocol to analyze the different reaction of bacterial solution exposed to light with multiple wavelength. For this reason, we designed a rectangular panel including LEDs, controller, and microcontroller and power supply

One of our college experimentation implied that solution rich in nitrate was injected at regular intervals into a larger bacterial solution. To do so, we (rapidly) developed a system controlling our pump and displaying the necessary information on a screen.

In order to introduce our undergrads students to Digital Systems and Electronic, we build a set  of lab around a line following robot. In my particular case, I designed the robot out of TTL logic components and light emitter/receiver sensor (Led and photodiode).

Although this project looks like the one above, I set up a race competition for high school student during our University holiday to introduce them happily to Computer Sciences. Thus I built with them around 15 line following robot, this time controlled by a Microcontroller (MCU) in order to simplify the implementation (and keep them interested). For this we used 3 different MCU technologies: STM32, and Arduino.

For this project a student wanted help on how to link sensors to a computer wirelessly and without much complexity. Therefore we headed to an Arduino + serial Bluetooth connection with a simple python script to log data on a computer.

The goal of this project was to design a “smart composter” that would be used to monitor the degradation of alimentary product. It consisted mainly into linking sensor to a data logger, and to control the composter in term of temperature, humidity (by injecting water) and rotating a helix to move the processed food inside the composter, the student is currently implementing our solution.

Here is the truth: the first year was not a success with this class . Even though I was perfectly skilled on the technical plan , my teaching method was to be revised. So for the coming year I spent countless of hours training my communication and teaching skills, how to approach people and motivate them to learn; with books, online classes and lots of practice . The results for the next class, were above my expectations . Students were extremely motivated and stayed late after to continue learning. Overall, this teaching experience was a success and taught me much more than technical skills.

This application allows for transmitting data from a FPGA to a PC or any TCP/IP capable device through WiFi via a wireless enabled MCU (CC3200 from TI), at a rate up to 8 Mbits/sec .

A FPGA receive data from several sensors, store them in memory and transmit them to a Microcontroller (MCU) through a SPI connection custom (written in verilog) .

The MCU first connect itself to an access point (WiFi) and then to a receiving server (in our case a python program we wrote ).

Afterward, the MCU starts accepting the SPI data sent from the FPGA and store them in a Buffer. Once the buffer is full enough, the MCU send data to a computer through the TCP/IP protocol.

Meanwhile, it still receives data from the SPI.

These parallel processes (SPI reception, TCP transmission) repeat endlessly as long as the (socket) connection between the MCU and the PC stays alive.

The key point of this project was to create a reliable connection between the FPGA and the MCU as the MCU often drop the connection with the remote server . Therefore the FPGA needed to wait the connection to recover and store the data into a SRAM chip placed on its board.

Once the project finalized, sources along with a comprehensive user manual were sent to the research team in need for this particular use case.

• Study of the mathematical and physical problem on which they were based. For instance with the Sound Generator, we needed to understand how to create a mesh of hardware nodes (Finite Element Computation) communicating together and implement the PDE solver
• Making a higher level architecture, involving Multiple Architecture Diagrams
• Making a first implementation with Verilog
• Simulating this implementation on a RTL Simulator, in our case ModelSim
• Optimize the hardware in term of speed and Size
• Implement and test it on the DE2-115 FPGA board

Code available on:  GitHub  

Overall these classes, brought me so much knowledge of Computer Architecture, Digital Design and Hardware acceleration, I cannot say thank you enough to Bruce Land, Senior Lecturer in Cornell University to make these resources available online.

• Design of a wireless system for recording the neural activity of a freely moving rat
• Design and implementation of compression algorithm, ADCPM, for the optimization of the bandwidth usage among the wireless neural signal acquisition systems

• Design and management of a workspace for the development of microelectronics systems
• Selection of the tools and components for the development of based-microcontroller systems
• Evaluation of the project costs, within the context of open source development, fast reproducible systems
• The purpose is to offer a non-expensive replacement of industrial existing systems

The initial part of the project was to select the appropriate Microcontroller and wireless transceiver that would reach our specifications. Thus we tests multiple wireless systems: Bluetooth, WIFI, ZigBee, analog RF, Nordic Custom; and microcontroller: Arduino, Mbed, STMicroelectronics, TI. We select the Nordic nrf24L01+ for the wireless part and a STM32F0 for the computing/peripheral unit. We then created our first proto-board, then the PCB. The following was to debug both the hardware of our 3 stages board and its firmware. After a long series of test regarding the bandwidth, transmission loss and battery life, we were ready to test it on living rodents. Once the real data were acquired, we worked on the journal article writing to finally end the project.

Design of an autonomous embedded system destined to be placed on a moving robot

• The system was to be light enough to be transported by a cable robot and resist high acceleration. Therefore we reduced the mass of the Printed Circuit Board and used ultra-thin silver wires to connect the system to the animal (moth)

Acquisition of moth neuromuscular signals to be sent to a computer via Bluetooth

• The system needed to send the electrophysiological data to a distant computer . Within our configuration, the use of cable was impossible due to the high speed of the cable robot for which the system was meant to be placed on. We selected Bluetooth technology for it reliability, speed matching our requirement, and ease of use. The microcontroller used were from STmicroelectronic and its firmware was written in C .

Design of a graphical application

• Finally we needed to acquire and display the said data on a computer placed across the room as well as sending it data. Thus, we designed a Qt based graphical application in C++ for this purpose .

The first challenge was to setup the goals upon what the system would do. Being used to the simplicity of Arduino, we sometimes set unattainable goals regarding embedded system, especially when looking outside of the arduino realm. In here, by the nature of our this project development tools (set by the professor), we were forced to make a comprehensive analysis of what can be done within a certain time period . Therefore the idea of heartbeat data logger came into our mind.

We firstly created a prototype thanks to several development boards. Then we wrote the firmware . After this, we designed our custom PCB and adapted the firmware. We then made the board manufactured and attempted a first soldering. After quite some hardware and software debugging, the system came to life and with it the end of this project. The satisfaction to create a system from scratch was almost overwhelming. This is at this moment that I knew I had found my path.

The purpose of this project was to design a bench test for the Varistart system.

These strange gearing shapes may strike a question: How do they even rotate without breaking and what do we do with them ?

Without going too far in mechanical analytic, we can say that when the system start , the overall torque in enormous with a small speed (hence easy to rotate) and at the end of the revolution of the blue gearing (above), the torque reduces dramatically and provides a large speed (hence fast after the start). This ingeniously named system “ Varistart ” indicate that the torque vary at the start of the system.

We divided this project in 3 parts:

CAD design of the gears and the bench in which these sat

• We proceeded to design these gearing on Catia CAD and run mechanical simulation and mechanical resistance study in order to obtain a product able to pass our specifications. 

Design of the electronic system used for data acquisition

• We designed a Electronic system needed to acquire the position/speed/acceleration and torque of the system in order to classify its performances. For this design we used Arduino, which was my introduction to embedded systems

 Implementation/manufacture of the whole system

• We used the heavy duty manufacturing machines available in our school to implement the system and test it

Results : We did a complete mechanical study of the performance of Varistart which were later used to design several prototypes by the IP owner of this system.

We divided this project into 3 parts:

Preliminary study and data acquisition

• We first became familiar with the company, its employees and the equipment before proceeding to the data acquisition. Secondly we proceed to take physical measurement of the production chains and reported digital with AutoCAD. Then we took time measurement of the various production steps and dead times.

Data Analysis and refactoring proposal

• The second step was to analyze the data we acquired and proceed to plan different modifications of the workspace. This involved product Flow analysis, financial analysis on the cost of the modification and its benefices. We then proposed our solution to Les Zelles.

Implementation

• Finally we proceed to the implementation of our accepted solution with the company and reported our work to both Les Zelles and our School.

Result:  We improved the production rate by 31% (averaging the different productions with small and large series)  by refactoring the workstation, involving a gain ~2000 euros per month for the company.