Vivid Unit + Arduino MKR1010 Flight data logger 

The Vivid Unit is a small computer with an integrated color touch display sitting on my desk for a few weeks. Shawn sent it to me for a review, and to be transparent, I was a bit at a loss about what to do with it. The “problem” is that the Vivid Unit can do a lot. Narrowing into one thing is hard. In addition, this computer has a Raspberry Pi header, so naturally, I was thinking of doing something I already did on a Raspberry Pi and then comparing the two. But doing that would be unjust for Vivid. Vivid Unit is not a Raspberry Pi, but it can do things that the Raspberry Pi can do.

So, I left it on my desk a bit longer while I thought about it in the background and worked on my KiCad Like a Pro eBook update.

Eventually, an idea landed: to use Vivid Unit as part of a flight data logger. In this project, I would build on this computer’s strengths, especially its high-resolution screen, abundant ports, fast processor, and Debian operating system that runs full Python.

Let’s start from… the start. What is the Vivid Unit?

The Vivid Unit is a powerful, versatile technology designed to cater to various computing needs. This device’s heart is the RK3399 processor, which combines a dual-core Cortex-A72 and a quad-core Cortex-A53 configuration. This is complemented by a Mali-T860MP4 GPU and 4GB of LPDDR3 RAM, ensuring smooth performance, whether multitasking or running demanding applications.

The Vivid Unit features a compact 5.5-inch display with a resolution of 1280×720, supporting capacitive multi-touch for an intuitive user interface. It includes Ethernet, Wi-Fi, and Bluetooth 4.1, alongside various USB ports for extensive peripheral compatibility. Additionally, it boasts an array of GPIO pins compatible with Raspberry Pi, which makes it ideal for hobbyists and developers alike who need flexibility in physical computing projects.

The Vivid Unit website provides basic information about what this machine can do. There are drawings, schematics, and operating system images. There’s even a STEP file that you can use with CAD applications. While it was sitting on my desk, I noticed new “How to” and “FAQ” articles appearing. For someone familiar with the Raspberry Pi and Debian, the Vivid Unit was easy to learn and use, and later to develop a simple Python application.

When I first received the unit, I connected it to a screen, mouse, and keyboard and used it as a desktop dual-screen computer. Aside from a noticeable lag when scrolling the menus, I could browse the web, check email, and even play games.

This computer is based on the RK3399 ARM CPU, known for its robust performance and energy efficiency. It features a dual-core Cortex-A72 and quad-core Cortex-A53 configuration, blending high performance with lower power consumption. This processor also supports high-quality 4K video decoding and output, making it ideal for media-rich applications. Additionally, it can handle complex computational tasks while maintaining energy efficiency is appreciated in both industrial applications and consumer electronics.

The Vivid Unit also includes the Mali-T860MP4 GPU, which is well-regarded for its graphics processing capabilities, particularly in devices that balance performance with power efficiency. It supports advanced graphics technologies, including OpenGL ES, OpenCL, and Vulkan, which are essential for modern gaming and graphics-intensive applications. The GPU’s architecture allows for efficient multitasking and enhances the rendering of complex graphical content, making it a solid choice for multimedia applications that require high-definition visuals.

Other important technical specifications include 4 GB of LPDDR3, a 32 GB eMMC, an Ethernet connector, Wifi, Bluetooth (BLE), 2 x USB 3.1 with 5 Gpbs bandwidth (plus 2 x USB 2.0 as pin headers behind the board), and a USB C port for power and flashing the OS.

Of course, the Vivid Unit has a touch-capable display, contributing to its uniqueness. This display, plus the USB ports, inspired me to use it as the “head” component of my Flight Datalogger project.

Lastly, the Vivid Unit has a 40-pin Raspberry Pi-compatible header.

At €99, roughly around US$105, the Vivid Unit is priced about the same as a Raspberry Pi 5 with 8 GB RAM. While the Raspberry Pi has more RAM and a faster processor, it’s not a computer you can plug and play. You still need a display, case, and keyboard + mouse.

The Vivid Unit is an all-inclusive computer ready to use out of the box, which I did.

The Flight Datalogger project

In one of my recent flights, I experimented with adding an overlay of flight parameters, such as speed, attitude/pitch, heading, and altitude, to my log videos. You can see an example below and the full video here.

Some of the data for the overlay widgets came from my phone, and some more came from the GoPro Hero 12 I used on that flight. Unfortunately, unlike previous models, the GoPro Hero 12 has no GPS capability. Therefore, I had to blend accelerometer data from the GoPro with GPS data from my phone. Even worse, some other data I’d like to include, such as barometric pressure and acceleration, were unavailable in this equipment.

So, as a Maker, I decided to build a custom Flight Datalogger. After some research and deliberation, I came up with these basic requirements for my datalogger:

1. It must have a simple user interface with only an ON/OFF switch and minimal status indicators.
2. Once turned on, it should operate automatically. No alerts should be emitted to ensure the pilot (I!) is not distracted during flight.
3. Logging should be recorded in a CSV file written on an SD card.
4. The log CSV file should be easy to process and use to produce the telemetry overlay in the videos.
5. The log CSV file should contain data from the GPS receiver and other on-board sensors.
6. The GPS receiver must support an external antenna.
7. The GPS receiver must be capable of 1-second updates (1 Hz update rate).
8. The logger must be battery-powered.
9. The logger must be robust and survive sitting in my flight bag.
10. Bonus: The ability to connect to a computer via USB and automatically provide sensor data to the external device. This can be done anytime; the external device can be disconnected and reconnected without additional actions.

I used an Arduino MKR1010 for requirements 1 to 9 and the Vivid Unit for requirement 10.

Components

Let’s look at the components I use in this project, aside from the Vivid Unit.

Arduino MKR1010

For the logger, I opted to use an Arduino MKR1010. The Arduino MKR1010 is a compact microcontroller board designed to offer connectivity and performance in IoT projects. It integrates Wi-Fi connectivity through the U-BLOX NINA-W10 series module, which supports a range of secure communication protocols. The board is also compatible with various Arduino shields and sensors, enabling extensive customization for various applications. The MKR1010 is particularly user-friendly for developers aiming to deploy IoT solutions efficiently.

I’m already familiar with the Arduino boards and with the MKR1010 in particular. For my specific application, the “killer” features of the board include:

• The USB port for power and communications. I use this port to connect the MCU to the Vivid.
• Support for a Lipo battery. The Arduino MKR1010 has a built-in charging circuit for a Li-Po battery, enabling the board to be easily powered via its USB connection while simultaneously charging the battery. Additionally, the board can be powered directly from the battery without USB power, making it highly suitable for mobile or remote IoT applications.
• The UART interface. The Arduino MKR 1010 features a UART (Universal Asynchronous Receiver-Transmitter) interface, allowing serial communication. I use this to receive data from the GPS module.
• The MKR ENV shield enhances Arduino MKR boards by adding environmental sensing capabilities. But just as important, it has an SD Card module. My prototype uses the SD Card module to record data, and I plan to tap into the sensors in a later iteration. All this, with no wiring or soldering needed—and I already have one!
• A lot of RAM, storage, and processing capacity is needed to grow this project.
• I already have one!

Vivid Unit

In this prototype, the Vivid Unit is the “head” of the Flight Logger. I have written a Python program that uses Tkinter to create a full-frame GUI application. When I connect the Vivid Unit to the Arduino via USB, the application shows the incoming values in real time on the screen.

I’ve written this script with some basic robustness. I can start the program on the Vivid anytime; it will wait for the connection to the Arduino. When I make the connection, the program will start reading the GPS data (sent as comma-delimited text) and show the values on the screen. The only interactivity feature is the close button. I plan to add other features later, such as recording a separate log on the Vivid when certain conditions are true. For example, recording can happen when an on-screen button is pressed, speed reaches a threshold, or the airplane engine starts (the Vivid has a microphone).

Adafruit GPS module V3

This is another component I already had in my drawers from a relevant lecture for Arduino Step By Step. It was time to put it to work.

The Adafruit GPS Module V3, known as the Ultimate GPS Breakout, stands out for its high-performance MTK3339 chipset. This chipset can track up to 22 satellites on 66 channels, providing high sensitivity reception (-165 dBm tracking) and fast position updates up to 10 Hz. This module is particularly user-friendly due to its built-in data logging capability and support for external antennas via a uFL connector. This enables larger, more powerful antennas if greater range and precision are needed.

I like its simple UART interface, which worked great with the Arduino MKR1010.

I initially hoped the integrated antenna would be sufficient, but the module could not get a consistent fix during my first test flight. So, I purchased an external GPS antenna with a 2-meter lead that works great. The antenna uses a magnet to attach to a vehicle’s exterior, but I’ll have to find an alternative way to attach it internally to a rear window on the plane.

Box

I always wanted to learn the basics of FreeCAD but didn’t have a project, and without a project I didn’t have sufficient motivation. But now, I do. So, I spent a bit of time with FreeCAD 0.21 and designed a simple box for the flight recorder. You can see it below, sitting on my PrusaSlicer workbench, ready to print.

This box has the following features:

1. SD card access slot.
2. Arduino MKR1010 USB port.
3. Attachment points for devices. The Arduino and the GPS module are placed on the left side, and other sensors on the right.
4. On/Off switch.
5. Antenna socket.
6. Openings for cable ties or other attachments.
7. Openings for cable ties or other attachments.

The box has the exact width required to accommodate a 4000 mAh battery on its bottom. You can see the prototype in its current form below.

Future plans

I’m planning to test the Flight Logger in my upcoming flights. So far, I have conducted one flight test and one car test. The objectives of these tests are:

• Check that I am getting reliable GPS data in the CSV files and can use the data with my video telemetry overlays.
• Add barometer, temperature, acceleration, and gyro readings to the log.
• Design an enclosure for the Vivid Unit. The ideal enclosure would lock with the Arduino enclosure so that the two components become a single unit when I want to use the screen. The enclosure will protect the Vivid Unit, provide space for a battery, and allow access to the USB ports and On/Off buttons.
• Make gradual improvements to the Arduino enclosure, including a hinged lid, and improve internal spacing and mounting points. I will need to improve my FreeCAD skills for this.
• Once I’m content with the hardware selections, design a PCB in KiCad.
• Improve the software on the Arduino and Vivid.
  • Arduino improvements: Add more sensors, intelligent filename and file management, ability to detect when Vivid is connected.
  • Vivid / Python improvements: Improve reliability and ergonomics, including the ability to create and maintain a log. Use the internal microphone to know when the airplane engine has started and automatically start logging. The ability to detect when the airplane is airborne and when it has landed. Support a moving map. One day, replace text with graphics for nice widgets.

How many of those objectives I will be able to implement will depend largely on how much time I can give to this project.

What makes this project “blue sky” is the Vivid Unit. While the Arduino MKR1010 is an excellent data logger in stand-alone mode, adding a small computer with a touch screen makes the playing (and imagining) field much larger. For example, with GPS data and cellular communications, the Vivid should be able to make possible the addition of flight planning capabilities that consider live weather, airplane performance, weight, and balance. While it won’t be Garmin-tier equipment, it can be good enough for amateur and experimental use. The reality that the Vivid Unit is a fully functioning computer out of the box that can play well and easily with other devices is truly remarkable.

As always, I am very interested in hearing your opinions and ideas. What do you think of the Vivid Unit? What would you use one for? And what about my Flight Logger? How can I make it better? Let me know in the comments below!