This is my next generation of bike POV displays based on bkpvdsply. With much extended functionality, a more polished design and an easier user-experience, the goal for it is to extend my capabilities and experiment with building a "real product" that lives up to the expectations one might have. Also take a look at the project website or the launch video:

I generally try to minimize dependencies, but I'm a one man crew and can therefore only support Debian-based Linux distributions as I'm running one myself. Anyway, you need to have the following packages installed for everything to work properly:

• Arduino IDE as a way to compile the Arduino code. Install it with sudo apt install arduino.
• Arduino ESP32 LittleFS uploader for uploading the data. Install it via the installation guide.
• Adafruit NeoPixel library for controlling the LEDs. Install it via the integrated library manager.
• MPU6050_tockn library for communicating with the gyroscope. Install it via the integrated library manager.

• Reduce the overall height to fit slimmer wheels
• Rethink the mounting system to be easier for the user
• FAILED: Switch to a reusable cable tie alternative
• Improve the water resistance (ideally water proof)
• Make everything more balanced (equal weight distribution)
• Add LED strips to both sides

• Improve battery runtime
• ABANDONED VIA SWITCH TO BATTERIES: Make charging easier
• Develop a properly sized power supply unit
• Use custom-made circuit boards
• Switch to all SMT components
• Off-hand to production to a specialized vendor

• Implement customizable LED strip positions (relative to control board)
• Allow the rotation direction to be reversed (when the control board back faces right)
• Use LED trips on both sides to display the image
• Allow the image to be mirrored for the second side (useful for symbols and graphics, but not text)
• Reduce storage size of images (ideally via file compression)
• Add the ability to make animations with more than 2 images
• Improve image stability (more exact rotation and speed change detection, smooth measuremets)
• Implement customizable sampling threshold (allowed variation to trigger rotation detection)
• Rework API with clearer endpoints
• Load existing settings to UI for easier incremental changes
• Store and load associative names of images for easier identification

And more to come...

In order to create a device able to produce such wonderful visuals, you only need rather common components (an ESP32, some LED strips, an IMU and some sort of power supply), but their combination results in this really special outcome. Everything is based on a custom PCB onto which all of the other components are soldered and which is then encased in 3D printed parts. Here's what the finished outcome should look like:

Even though many sequences of assembly will result in functional boards, here's how I assemble them after trying out several approaches with varying success:

1. In case you went for the cheap battery holders from Amazon, cut off the brim on the bottom, sand this side for better adhesive contact, shorten the wires and tin them in advance.
2. As always, parts should be soldered in the order of their height. So start off with cutting the LED strips to their desired length of 32 LEDs and then solder them down with the arrows facing towards the slim end of the boards from each side. It's easiest to solder one side of a strip, apply some instant glue along it's way and then solder the other one mounting it into place.
3. After that's done, continue with the diodes - be careful to install them the right way around (silver ring facing the marked direction) - and On/Off switch.
4. Now it's time install the ESP32 and IMU. Solder male headers facing down to the D1 Mini board in case not already done and then mount their female counterparts to the main PCB. You can also fill the contacts on the other boards, but that's not necessary. Then add the right-angle connector to the MPU-6050 board so that it can be mounted vertically to the PCB with its back facing to the wide end of the board and solder it down.
5. You're getting there, just add the screw terminals and then capacitors with the polarity of the latter being crucial (white component markings should face the filled side on the PCB).
6. If necessary glue down the battery holders and then solder them into place - this can be quite tight, but should be doable.
7. To prevent shorts with the spokes from happing isolate the back side with some duck tape or equivalent material. If you want everything to be more moisture resistant, you can also look into spray rubber products.
8. Finally, install the connection cables in the consistent matter and make sure that there are no shorts or other critical mistakes.
9. Once the electronics are done, cut the Plexiglas sheet into 8 14x222mm big pieces, glue them into the 3D prints (4 bottom 4 top parts) and put them together (bottom part PCB top part, 4 times).

Below is a full bill of materials with German sources for all required non-printable parts:

1. Build the hardware as described above and put the batteries in.

2. Select the "WEMOS D1 MINI ESP32" board in the Arduino IDE.

3. Flash the sketch with the following settings:

   • Upload Speed: 9215600
   • CPU Frequency: 240MHz (WiFi/BT)
   • Flash Frequency: 80MHz
   • Partition Scheme: No OTA (Large APP)
   • Core Debug Level: None
   • Erase All Flash Before Sketch Upload: Disabled

4. Upload the additional files via the Arduino ESP32 LittleFS uploader.

5. After turning on BikeBeamer, give the ESP roughly half a minute to boot up.

6. Connect to the Wi-Fi network BikeBeamer, open any webpage (or 192.168.0.1 if the local DNS server doesn't work) and upload an image (examples are in the images folder).

7. Test the assembled hardware on your workbench and check if everything works as expected. Here is some reference footage:

   Loose boards in action

   loose-in-action.mp4

   

8. Mount it on your bike with some cable ties like this:

   

   

   

   

   

9. Then just hop on your bike and enjoy the glory of this next generation POV display. Here's just some inspiration:

   Mounted boards in action

   mounted-in-action.mp4

   

• All angles used are in counted in degrees clockwise from 12 o'clock looking at the left side of the bike
• All coordinate systems used have their origin at the bottom left
• The PCBs are mounted with the back side visible when looking at the left side of the bike and connected in clockwise direction
• All indexes in the code are zero-based, while all user interfaces and visualisations use regular one-based numbering
• All API communication is done through HTTP headers for the sake of easy parsing in the front- and backend

• User interface: GET /index.html

• Get stored settings: GET /api/settings
• Update settings: PUT /api/settings

• Get image names: GET /api/images
• Update image: PUT /api/images/{slot}

• https://subethasoftware.com/bikelights/
• https://www.kickstarter.com/projects/minimonkey/monkey-light-pro-bicycle-wheel-display-system/description
• https://learn.adafruit.com/spokepov/overview
• https://www.ladyada.net/make/spokepov/
• https://learn.adafruit.com/bike-wheel-pov-display/overview
• https://bicycletouringpro.com/hokey-spokes-bicycle-lights-review/