Devlog #8 - Actually Finished

S.U.P. - v1.0

Okay, NOW it’s finished.

(GO HERE TO SEE VIDEO: https://www.youtube.com/watch?v=IzWqsmjGq4U)

Last time I said we were getting close. Now I can finally confirm it!

S.U.P. is finished.

There was still a surprising amount of work left after v0.9.1, especially around handling different servo types. I ended up reworking a lot of the servo logic to make everything work together properly.

Important Features Added

• Full support for different servo types, including 90°, 180° positional, and 360° continuous-rotation servos
• Added working pulse-width calibration for servo control
• Added working servo sweeps for testing positional servos
• Finished the servo type handling system
• Improved calibration logic so it works correctly with the selected servo type
• Finished saved profile handling, including persistent storage across resets
• Finished the joystick calibration system
• Completed the C.E.A. Laser Calibration system
• Finished the Settings, Debug, Calibration, Manual Control, and other menu systems
• Added and tested the final error handling and debugging tools

Final Testing

I tested the main workflows with real hardware instead of relying on a simulation (as I always have).

The Demo Video

The final demo video is finished and uploaded here:
https://www.youtube.com/watch?v=IzWqsmjGq4U

I tried to show the project itself rather than only talking about the code and development process.

One thing I did not manage to include properly was footage of the full physical servo calibration process. The only calibration footage I kept was the joystick calibration.
Everything works though :D.
Sorry about that.

The actual calibration system and everything else was still tested and works. I explain the missing footage in the video.

Final Result

S.U.P. started as a small ESP32 servo tester and grew into a much larger system than I originally expected.

TODO

There are still ideas I might work on in the future, but they are no longer required for the first release:

• Custom PCB
• Custom 3D Case
• Advanced diagnostics (I’ll have to open up the servo)
• General code cleanup and optimization

For now, though: S.U.P. v1.0 is done.

Devlog #7 - Getting Closer

S.U.P. - v0.9.1

To be honest, i kinda lied last time…

There is still a lot of work to do, espesially about the servoType handling

Important Features Added

• Added WORKING Joystick Calibration + integrated additional calibration logic directly in joystick movement (toggable, of course)
• You can finally use the manualControl() with a fully calibrated custom profile. Changing the selected profile now updates automatically.
• Huge improvements to Selecting Servo Type. Now calibration works for both 90° and 180° servos.
• Added Servo Test Sweep!
• Added a custom option in the main menu to change profiles
• Wrote the About me Section (Finally)

Less Important Features Added

• Isolated updateSelectedProfile() in its own function so i can reuse it (like 100+ lines of code saved there…)
• Added debugger function (in “Debug” menu) for testing the joystick calibration
• Added a global int - actionDelay = 300ms. I have always added a delay(300) before changing display screens, starting/ending actions, ect.. to keep the app posished and remove the irritation of “fake”/“accidental” double, triple and spam clicks
• Fixed a bug in the normal joystick debugger function

TODO

• [ ] Add support for 360 deg servos
• basically writing a custom new version of each function but for rotating servos because they are fundamentally different then positional servos (such as 90° and 180°) and don’t integrate well into the current ecosystem.
• [ ] Show which saved profile is for which servo type
• [ ] Film the video for the v1.0 release (we are really getting closer :D).

Devlog #6 - THE “ALMOST FINISHED”

[Some original greeting here]!

Time goes by, so does progress on this calibrator tool. I really started to like it to be honest. It has been really fun making all the additional systems around the calibration, such as the “Debug”, “Settings”, (soon “About” too), all the UI polish and case handling. Even the NVS storage setup (basically the real ESP32 storage instead of the RAM-like one it usually uses) teached me a lot and I’m proud of how far this project has come.

But enough yapping.  

I FINALLY Taped the Laser module to the servo bracket! Also, I put it in a box of TicTac (image below XD) so it doesnt fall and give wrong reading. Then I filled the box with COINS so it doesn’t wiggle during servo movement.
Just WILD XD

So, what did i update in this 1 week?

- Well… A LOT.

If i had to list it:

• Made the settings finally work!
• Fixed a bug where option scroll started when there was no need at all
• Saved all settings, preferences and user profiles to permament NVS storage
• Changed ALL delay() instances with millis() (Where possible/wanted). Just this took like 4 hours :I
• (Like I said before) - FINALLY Taped the Laser module to the servo bracket! Also, I put it in a box of TicTac (image below XD) so it doesnt fall and give wrong reading. Then I filled the box with coins so it gets heavy enough to not wiggle during joystick movement :D
• Changed a breadboard because for some reason my jumper wires started losing lots of voltage and the connectors were really loose for some reason
• Polished the UI, A LOT. I probably plan to change from normal lists to Flipper Zero-style menu soon.
• Added a “Simulate Errors” feature in the “Debug” menu to test if my error and case handling works well
• Fixed multiple smaller bugs…

I think that’s pretty much it, there could be more smaller things I don’t remember rn (sorry about that).

Notes

• Sadly went a little above 10 hours this time D; - I sill have lots of things to do - mainly polish messages, small inconsistensies, ect.
• I kinda gave up on adding a keyboard - it is pretty unnecessary and will add a lot more cases to handle for almost no benefit.
• These days I will be filming the final video for the v1.0 release!
• I accept any ideas from you for future features and filming advice.

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 🙏)