Devlog #5 - Settings & Profile Storage

## Unknown - 5th September 2026

### Version: v0.4.0-settinger

Hello again!

Yeah… I kinda forgot the journal existed again XD

A LOT has changed since the last devlog, especially internally. The project is starting to feel less like a giant prototype held together by hopes and prayers and more like an actual tool.

### Main events

- Finally started working properly on the Settings menu!

- Added persistent settings using the ESP32’s Preferences storage

- Basically all the important environment variables are now stored, including:

- - Servo / joystick pins

- - Axis inversion and swapping

- - Speed settings and multipliers

- - Calibration parameters

- - Joystick deadzones and offsets

- - Debug mode

- - Display and scrolling settings

- - Calibration list information

- - Various delays and timing values

- Added saveSettings() and loadSettings() functions so I don’t have to hardcode everything every single time the board boots

- Settings also have default values, so if there is no saved value yet, the program still has a working configuration

- Started separating the stored data into different Preferences namespaces, so Settings and Servo Profiles don’t all get thrown into one giant storage section

- Calibration Lists got actual persistent storage, meaning the calibration data doesn’t disappear every time the ESP32 restarts

- Added more profile-related error handling

- Continued expanding the 3-digit error code system, which is starting to look suspiciously like I accidentally created my own mini error protocol XD

- Did a LOT more bug hunting and general code cleanup

- Also spent way too much time making tiny UI things work properly because apparently I have decided that a 128x64 OLED deserves the same amount of attention as a full desktop application :I

### Some of the more important stuff

The biggest thing here is probably the storage system.

Before, most of the variables were basically just sitting in the code waiting for me to change them manually.

Now I can save them to the ESP32 and load them again later.

For example:

settings.putDouble("speedMultiplier", speedMultiplier);

and later:

speedMultiplier = settings.getDouble("speedMultiplier", 1);

So if I change a setting, restart the board, and come back later, it stays changed.

This also means I finally don’t have to keep scrolling to the top of a 1500+ line sketch every time I want to change something XD

### What’s next?

- [ ] Actually TEST the full calibration workflow with a real servo

- [ ] Add an X-axis animation to the Settings menu when changing variables

- [ ] Add a way to name calibration list slots

- [ ] Make the amount of list slots dynamically generated instead of hardcoded

- - [ ] Add an “Add New Slot” option

- [ ] Add an on-screen keyboard or find a decent library for one

- [ ] Add a way to connect to the ESP32-S3’s second USB port and extract saved servo profiles as files

- [ ] Keep murdering bugs until the project stops finding new ones

### Notes

I’m starting to realize that the actual servo movement part was probably the easy bit.

The annoying part is everything around it.

Menus, storage, scrolling, profile management, error handling, input validation…

At least it makes the project way more interesting :D

Devlog #4 - UI Polish

Hello!

Probably not one of the most impressive things, but a good UI is something people always respect (just subcounciously… ).

• Added prettyPrint() funtion, which essentially gives me the ability to parse any long message into separate pages with skippable delays. All you need to do is just click once you finished reading the page. For now I’m experimenting with the delay but 7.5 seconds feels natural for 64x128 display (probably around ~40 words).

• Sadly, I need to rework some of the functions for the calibration picker because there is just no way to go back to the main menu at this point..

• Added some Display Error Function, which pretty much relies on prettyPrint().

• Added some helper functions for things i consistently call to lower the ammount of same-purpose code and managed to bring the sketch down to ~1500 lines!

The attached image is the skippable delay I kinda invented because I didn’t want to use milis() XD.

Devlog #3 - Servo Profiles

Hello everyone,

We just hit a new milestone in the development of this project: Laser Calibration Profiles

How do They Work?

Right now we have a menu where you can choose between 3 calibration profiles each having a different ammount of samples (the more, the better, but slower due to the higher ammount of measurements)

• Basic (5 samples)
  [0, 45, 90, 135, 180]

• Accurate (9 samples)
  [0, 22.5, 45, 67.5, 90,
  112.5, 135, 157.5, 180]

• Servophile (17 samples)
  [0, 11.25, 22.5, 33.75, 45,
  56.25, 67.5, 78.75, 90,
  101.25, 112.5, 123.75, 135,
  146.25, 157.5, 168.75, 180]

• (I plan on adding a Super Servophile profile with 33 samples soon!)

After choosing the profile (and - in the future - one of the 3 slots each list has), the user will go through with recording distances for each angle using a marking on the wall (use a pencil or just tape a paper and draw on it)

That’s it! (At least for the manual input XD)

Then the list with colleced measurements gets put in a script and thrown out as a list of angles.

Now that’s it!

Next Features

• I plan on adding an expected measurement section in the UI so the user has a better idea what the expected output should be during calibration (also helps with debugging ;))

• Turning the List of angles into a complex map that can directly transform digital angles to calibrated ones

• Actually using the calilbration profiles when moving servos

• Adding all environment variables to settings so you can change them during runtime!

Devlog #2 - The OLED Age

SUP!

It has been like a week since the last devlog… and a lot happened to be honest.
(If you don’t wanna read, just go down to see the SUPER cinematic demo I made for you <3 )

If you read the first devlog, you might remember that the plan was basically:

“Make the Servo move”
“Then add a Joystick”

and then:

“Make an OLED Menu”

Well, I just finished the OLED Menu!

THE CODE

This time I spent a LOT more time on the actual code structure (+4 hours wondering why jumper wires (the bare ones with no heads) drop so much voltage, but we don’t talk about that).

The sketch has grown up to like ~700 lines, but more importantly, I started optimising it and making the code reusable instead of just putting everything into loop().

I have broken the code down into independent functions like:

calculateOffCenter()
offCenterToDirection()
buildMenu()
callMenuOption()
drawScrollbar()
...

So now everything is more optimised and easier to expand and debug!

THE MENU

Our menu now consists of:

- "Manual Control"
- "Calibration"
- "Debug"
- "Settings"

I made buildMenu() take an array of options and their length, so I can reuse the same function for all menus.

I also added a scrollbar (cause apparently four lines of text just wasn’t enough).

Calibration Time

This is where things got interesting.

I started working on the Calibration menu.

Right now it has:

- Simple Calibr.
- Pulse Width Calibr.
- C.E.A. LASER Calibr.
- 360deg Servo
- 180deg Servo
- Go Back

Some of these are still placeholders, but LASER Calibration is halfway done.

C.E.A. LASER CALIBRATION

Yes.

I finally found a purpose to my year old laser module :D

The idea is pretty simple.

Tape a laser to the servo head.

Put a piece of paper on a wall.

Point the laser at it.

Move it a certain ammount of degrees (e.g. 5deg)

Then use the distance between the 2 points to figure out how much degrees the servo ACTUALLY moved.

And this is where the math comes in.

If the servo is L centimeters away from the wall, and the laser spot moves X centimeters, we can calculate the angle with:

θ = arctan(X / L)

So instead of trusting the servo when sayin’:

“Yeah, that’s 90° bro”

S.U.P. is able to measure where the servo is actually located.

And the best part is that the user doesn’t need to buy some expensive angle sensor (which is the whole idea of the project btw).

You need:

• A laser
• A ruler
• A piece of paper
• A pencil
• A wall (I hope you have one C: )

That’s it.

And I think that’s pretty damn cool.

The current prototype goes through:

0°
45°
90°
135°
180°

and lets me enter the measured distance (in cm ofc, no freedom units… ) with the joystick.

It isn’t finished yet, but the basic system is working.

What’s Next?

• Finish C.E.A. Laser Calibration
• Make the angle calculation automatic
• Add proper servo calibration profiles
• Work on Pulse Width Calibration
• Figure out 180° vs 360° servos
• Add joystick calibration
• Keep improving the OLED interface

And hopefully make S.U.P. look less like a breadboard project and more like an actual tool.

Devlog #1 - The Rise of S.U.P.

Hello everyone,

Welcome to the first ever Devlog of the Servo Utility Platform (aka. S.U.P.)

This is the project I decided to make for Stardance, and the first ever solely non-AI-dependent one :D

Overview

So what even is S.U.P.?

[Demo can be found at the Bottom if you don’t like reading explanations :D]

The Servo Utility Platform is, I won’t lie, nothing super wow.

The idea is that instead of making a random test circuit every time I wanna test a new servo, I can use S.U.P. to quickly test it, calibrate it, and see if something is wrong with it.

At least that’s the plan cuz right now it’s still a bunch of wires on a breadboard :D

Hardware Used

Currently, S.U.P. uses:

• ESP-WROOM-32 x1
• Small I2C OLED 128x64 Display x1
• Joystick Module x1
• MG90S Servo Module x1
• 830-point Breadboard x1
• A suspicious amount of jumper wires…

The Beginning

The first version was… really simple XD.

It was literally an ESP32 shooting electricity through a wire and nothing more.

[Check out the “Fancy This” picture at the bottom]

The goal wasn’t to make something impressive. It was just to make sure I can do the simplest thing imaginable:

“Can I make the servo move?”

The answer was yes (thankfully XD).

After that I added a Volume Knob (potentiometer).

[Check the Picture that features it (it’s really sad that I can’t put the pictures in-between text)]

This helped me control the servo angle, which made it more satisfying to play around with, but felt too weird.

It felt like giving a static position to the servo, not making it move.

The knob might work for a real 10$ servo tester but it’s just not my style.

MEET: The Joystick

So I replaced the potentiometer with his cooler Oklahoma bro: The Joystick.

[A video of me “casually” testing the hardware can be found down below]

And this is where it started feeling like the gadget of my dreams.

Instead of:

Pot position → Static Servo angle

I first changed it to:

Joystick Pot position → Static Servo angle

wow! amazing!

So I had to do a lil more work than changing one wire…

The redesigned system was way better:

Joystick x-axis position (still a pot just a fancy one) → offCenter from 0 (we actaully use the middle of the pot as 0 and the ends as -1 and 1) → Velocity → Servo Speed

Now moving the joystick slightly makes super small adjustments, while pushing it further makes the servo go wayy faster.

To make this feel better, I made my own acceleration function instead of just using a simple linear movement. The final result feels surprisingly nice.

Current Prototype

Right now S.U.P. has:

• A working joystick-controlled servo system
• Acceleration-based movement
• Speed settings
• Adjustable servo limits
• Joystick deadzones
• A debugging system because manually adding and removing Serial.println() gets old really quickly :I

[Now look at the Super Cinematic picture of that MG90S Servo]

Things I Learned

A few things I learned while making this:

• Joysticks are basically just two pots and a button
• The ESP32 ADC reads voltage, not “positions”
• Tuning acceleration functions is really worth it for making the movement feel good

What’s Next?

The next steps are:

• Add joystick calibration
• Find servo minimum and maximum angles (if even possible idk)
• Figure out how to detect 180° vs 360° servos
• Start building the OLED menu system (tbh sounds like the most interesting and hard part at the same time 🙏)