Printer upgrade - Bambu P2S AMS2

It's hard to believe it's been over 10 years since owning my first 3D printer.

It all started with a Vertex K8400. Like most printers at the time, it wasn't exactly plug and play, but it hooked me immediately. Before long I was building RepRap machines with welded steel frames that I fabricated myself, experimenting with Anet A8s, moving through CR-10s, spending years with the Artillery Sidewinder X1, and eventually adding SLA printing to the workshop.

If you've been in the hobby for a while, you'll know every printer had its own temperament.

Some fighting you every step of the way, others needing another upgrade before you even really get it out of the box.

Those machines taught me far more than how to print plastic. They pushed me into CAD and design, electronics, mechanics, firmware, and manufacturing. Before I knew it, what started as a hobby had become another tool that helped shape my career.

The Artillery X1 deserves a lot of credit. It has been an incredibly reliable machine for me and has produced a lot of great parts over the years, but after spending so much time in a continual tinker stage - I was wanting something more.

That's what brought me to the Bambu P2S with the AMS 2.

I'm still getting to know it, but so far it has felt less like setting up another machine and more like adding another tool to the workshop. The printer, AMS, Bambu Studio and MakerLab all fit together in a way that lets you spend less time figuring things out and more time making something. It basically configured itself.

MakerLab has also been useful tool I've overlooked. AI-assisted tools that can turn an image into a relief, generate printable models, or help someone bring an idea to life don't replace learning CAD—they simply make creating more accessible. This is something I am looking forward in seeing my family gain further involvement.

So far, pretty impressive machine!

Lowrider CNC Jackpot Controller

LowRider CNC - Finally Installing the Jackpot Controller

The Jackpot controller has been sitting on my bench for quite a while. My LowRider was already running reliably with an SKR board, so there wasn't much incentive to change it. With some free time, I finally decided it was time to make the move to FluidNC.

The first step was removing the existing SKR controller and documenting the wiring before disconnecting anything. Fortunately, the migration was straightforward. The only hardware changes required were replacing two connectors to match the Jackpot board. Once those were changed, the remaining wiring transferred over without much trouble.

With the controller installed, I powered everything up and connected to the Jackpot over Wi-Fi. After confirming communication, I reloaded my "config.yaml" configuration and started verifying each axis, endstop, and probe input. It's always worth taking the time to test each function individually before assuming everything is correct.

On the CAM side, I created a basic FluidNC post processor in Alphacam to get the machine moving. The initial version was intentionally simple—just enough to output clean G-code while I verified motion, probing, and general machine operation. As testing progresses, I'll continue adding the features I rely on in my normal workflow.

With the controller configured and the post processor producing usable code, it was time for the first test cuts. A few simple toolpaths confirmed that the machine was responding correctly, the coordinate system was behaving as expected, and the overall migration had been successful.

There is still work to do before I consider the conversion complete. I want to refine the Alphacam post, verify tool changes and probing routines, and spend some time cutting real projects before drawing any conclusions.

So far, though, the transition from the SKR board to the Jackpot controller has been much smoother than I expected. Hopefully these notes will help anyone else considering making the same upgrade.

Getting Started with the NanoVNA H - What I Learned

After spending a few hours with the NanoVNA H, I figured I'd write down what actually stuck. This isn't intended to be a tutorial. My goal was simply to understand enough to begin tuning the telescoping dipole I've been using for weather satellite reception. As I dug into the NanoVNA and worked through the setup, these are the things I came away with.

The reason I bought the NanoVNA wasn't just to own another gadget. I wanted to stop guessing.

My immediate goal is tuning the telescoping dipole I've been using with the 3D printed 120° clip I made for weather satellite reception. Ultimately I'd like to use it to receive Meteor-M No. 2-4 LRPT images with my HackRF and SatDump, but before worrying about satellites I needed to understand the instrument sitting on my bench.

Out of the box the NanoVNA displays several traces at once. There is S11, S21, a Smith Chart and phase information. Rather than trying to understand all of them at once, I disabled everything except S11 LogMag.

From what I understand so far, S11 LogMag is showing how much of the transmitted signal is reflected back from whatever is connected to Port 1. Since tuning an antenna is really about minimizing those reflections at the frequency you're interested in, that became the graph I wanted to focus on.

The other displays are simply different ways of representing RF measurements. The Smith Chart, for example, is displaying impedance graphically. I'll get there eventually, but for now one graph is enough.

Before calibrating anything, I learned that you should first decide what frequencies you're interested in.

For my antenna I set:

• Centre Frequency: 137.5 MHz
• Span: 10 MHz

That gives me a measurement window from approximately 132.5 MHz to 142.5 MHz, which comfortably covers the weather satellite frequencies I'm interested in.

One thing that briefly confused me was entering frequencies. After typing a value the NanoVNA asks whether it's H, k, M or G. It eventually clicked that it was simply asking if I meant Hz, kHz, MHz or GHz.

Calibration

This was probably the biggest takeaway.

Calibration isn't just about the NanoVNA itself. It's about the entire measurement path.

Rather than calibrating directly on the front of the NanoVNA, I left my SMA test cable and coupler attached, then performed the calibration at the end of that assembly.

The supplied standards are easy to identify once you know what they are.

• Open – the connector with the empty centre.
• Short – the all-metal connector.
• Load – the connector with the white insulator containing a precision 50 Ω load.

Work through Open, Short and Load, press Done, then save the calibration.

One thing that still makes me laugh...

It's called SOL calibration, yet you perform Open, Short, Load. Maybe there's a historical reason, but my brain still wants to call it OSL.

The first surprise

Once everything was calibrated I connected my dipole expecting to start tuning.

Instead I discovered something I'd completely forgotten.

The antenna still had its original 75 ohm to 300 ohm television balun attached.

So instead of measuring the antenna itself, I was actually measuring:

NanoVNA - Test Cable - TV Balun - Dipole

That explained why the results weren't quite what I expected.

Rather than modifying it immediately, I think I'm going to leave it exactly as it is and measure it both ways. I have a feeling I'll learn more by understanding what the balun is doing than by simply replacing it.

What I retained

The things that stuck with me were:

• Simplify the display before trying to understand it.
• Decide what frequencies you're actually interested in.
• Calibrate with the measurement cable attached.
• Save the calibration before measuring anything.
• S11 LogMag is the graph I'll probably spend the most time looking at while tuning antennas.
• If the measurements don't make sense, don't assume the NanoVNA is wrong. Check what you've actually connected to it.

Building a Cajón

I don't consider myself a woodworker, and I'm certainly not an instrument maker, but that didn't stop me from wondering if I could build a cajón from scratch.

The project started in SolidWorks, where I designed the enclosure before preparing the parts for my LowRider CNC in Alphacam. After sourcing a proper snare assembly, I spent time researching how different construction techniques influenced the sound, then experimented with a few ideas of my own.

One of the more interesting experiments was a magnetic snap-on ring for the rear sound hole. The idea was to quickly change the opening size and see how it affected the tone and resonance without permanently modifying the instrument.

This was very much a prototype, and looking back a year later I already have a list of improvements I'd make for Version 2. That said, it turned out better than I expected. I built it for a friend who's a percussionist, and hearing that it still rides around in his vehicle and gets played regularly is probably the best feedback I could ask for.

This sparked my interest in woodworking more and I have since acquired more tools to make these projects easier.

SQL

I completed this SoloLearn certificate as part of the same development roadmap as HTML, although SQL was already something I worked with regularly.

Much of my day-to-day involved supporting Microsoft SQL Server installations for Cabinet Vision, troubleshooting connectivity, permissions, and database issues. As I became more involved with Combit List & Label report development, I found myself writing increasingly complex queries rather than simply supporting the database.

SoloLearn's interactive exercises were a great way to reinforce the fundamentals and become more fluent writing SQL. It helped build on knowledge I already had and gave me greater confidence when developing reports and working with T-SQL.

Introduction to Python

I completed this certificate as part of the same web development roadmap through SoloLearn. While I wouldn't call myself a Python developer, the course provided a solid foundation in the language and reinforced the basics of scripting.

Python has become one of those tools that's incredibly useful for automating repetitive tasks, especially when working in Linux environments. Whether it's processing files, creating small utilities, or simplifying day-to-day workflows, having a fundamental understanding of Python has proven to be a valuable addition to my toolbox.

HTML fundamentals certificate

Back in 1996-1997 I spent countless hours teaching myself HTML (between hours of playing Diablo) using HotDog HTML Editor—a piece of software my dad had picked up from a bargain bin. It was my first real introduction to creating something on a computer from scratch, and I probably learned more by trial and error than by following any guide.

I completed this certificate a while back in part of a web development roadmap with Sololearn. While web development has become less of an interest of mine, it's use is still valuable in many IOT development projects using devices such as the esp32 for back end user interfaces for configurations.

OpenAI: Applied AI Foundations

Today I wrapped up another OpenAI Academy's course: Applied AI Foundations.

This wasn't about learning what ChatGPT can do but rather strengthening the fundamentals behind using it effectively. The mini course reinforced how to build better workflows, ask better questions, and collaborate with AI in a way that actually improves the end result, by providing focused goals, documents, images and deloping skills.

.

Building a Foundation in AI

 

While I've already spent a fair amount of time experimenting with AI, I recently completed OpenAI Academy's AI Foundations course.

Much of the material reinforced concepts I had already begun exploring on my own, but that was exactly the reason for taking it. Before diving further into areas such as automation, local models, and security research, I wanted to ensure my understanding was built on a solid foundation rather than assumptions.

Artificial Intelligence feels very similar to the early growth of the Internet or the evolution of search engines. At first, they were interesting technologies that few people fully understood. Over time, they became fundamental tools that changed nearly every industry. AI is following a similar path, with organizations rapidly adapting it into products, workflows, and everyday operations.

Whether you're excited about AI or skeptical of it, its influence on technology is difficult to ignore. Understanding the fundamentals—what these models are, where they're effective, where they fall short, and how they should be applied—is becoming just as important as understanding the technologies that came before them.

For me, this course wasn't about earning a certificate. It was about taking the time to strengthen the basics before continuing to explore a field that's evolving faster than almost anything else in technology.

Orca slicer

Repurposing an Old Tablet: A Time Hole of SDKs, Bootloops, and Stubborn Curiosity

What started as a small idea — turning an old Samsung Galaxy Tab 4 (SM-T230NU) into a dedicated FluidNC pendant — turned into a full dive into Android development, debugging, firmware archaeology, and system recovery.

Here’s the real takeaway from today.

Coming Up With a Simple Goal

The original goal wasn’t complicated:

• Old tablet
• FluidNC web interface
• Fullscreen
• Landscape
• Launch on boot

A normal person would’ve added the webpage to the home screen in Chrome and been done with it - and I might regret not stopping there - but it all came from curiosty.

Learning the SDK Environment

I spent time in Android Studio learning:

• How project structure is laid out
• Where manifests, layouts, Kotlin files, and themes actually live
• How Gradle build files fit together
• How SDK versions impact compatibility

I went from not knowing where things were to being able to navigate the project tree quickly and edit the right files without guessing.

I built a working APK — even if the target browser engine didn’t support what FluidNC needed, the app did exactly what I wrote it to do.

Using ADB and PowerShell

I pushed deeper into device-level interaction:

• Installed platform-tools
• Added ADB to system PATH
• Queried the device
• Verified connection in developer mode
• Used ADB to sideload, inspect, and test

Following the Rabbit Hole Further

Once it became obvious that Android 4.4 was the real limitation, not the app, I kept going.

That led me into:

• Hunting down discontinued libraries (Crosswalk, old .aar packages)
• Trying different browser runtimes
• Experimenting with launching Chrome in kiosk-like modes
• Testing fullscreen flags and orientation locks
• Dealing with missing APIs and deprecated functions

It stopped being about FluidNC at that point.
It became about a carefree environment for testing Android development that sparked from a simple project.

Stepping Into Firmware Territory

When software limits hit a wall, I decided to try upgrading the tablet entirely — aiming for LineageOS or anything newer than KitKat.

That started a different rabbit hole:

• Searching for factory firmware for a device long out of support
• Sorting through mismatched builds and dead download links
• Learning how PIT files map partitions
• Understanding (or trying to) why Odin fails during writes
• Flashing TWRP
• Watching the tablet "soft-brick" into recovery loops
• Figuring out how Samsung’s download mode actually behaves
• Attempting to restore system partitions manually

A lot of it was trial and error.
A lot of it was frustrating.
None of it was wasted.

It was about chasing a small idea until it forced me to learn:

• Android app fundamentals
• Legacy WebView limitations
• How Chrome vs system web engines differ
• ADB usage
• Firmware flashing and partition mapping
• Bootloader interactions
• How older hardware complicates everything

And honestly — it was interesting the whole way through.

Even if the tablet fought back at every step, I walked away knowing a lot more than when I started.

Creality Ferret 3D Scanner

 

The above photo is the third attempt at using the Creality Ferret - and the results are looking promising! While setup did not come without some of its challanges and learning curves, I believe it will be a useful tool for design going forward.

From the Creality website:

Based on the specs alone, we are to safe assume that we are limited by the .1mm accuracy, resolution and point distance of .16mm and the NIR ( near infrared) light source limiting our scanning ability for certain materials and thin objects, opposed to laser scanners, but overall a seemingly great entry level scanner.

Challanges

Getting started, I began with my phone which is a Samsung Ultra 23. To note, this version ood the scanner did not include the wifi bridge - so what's included is a 4500 mah battery boom, high speed USB C connector and the scaning unit. Connecting it to my phone was a tad frustrating, as I could not get it to remain connected. Thinking this was an issue with lint in my input, I spent a lot of time fiddling with what I thought was a hardware issue that seemly fixed itself after I happened to reboot my phone. It turns out, I will need to reboot my phone following every scan from this point forward, an annoyance for sure. 

Following a scan, it warned me that my capture was large and require much time to mesh, and I should bring my project to my PC for meshing. I seemed to quickly have found the limitations of my phone hardware.

Switching to PC, I discovered that I was not utilizing my dedicated GPU (Graphics processing unit) and that Creality Scan was using the integrated display adapter. Once I changed this, the performance was great. I was able to use my high speed USB C cable that was purchased for my Oculus 2 before I figured out an Airlink solution, allowing me some addition travel while wired.

Laptop specs:

I9 14th Gen

64GB RAM

SSD's 

4070

To play with a bit of a use case, I took my 1994 Tiger Power Rangers hand held and scanned it to design a battery cover off of it.

These pointcloud captures came out excellent. I used a few tips shared in the Facebook group and I think I am getting the technique for it.

CrealityScan has a feature to merge objects together and to achieve the best results and success of a merge, you must get overlapping surfaces for reference. I was able to do so with this scan and applying the image overlay turned out awesome 

Here we can see some distortion in what is otherwise a great looking scan. The areas seemingly affected were the bottom edge of the objects position on the table. I think rotating the part and placing up off a table would allow for a crisper scan in these areas.

Over all, the scanner is great when connected to my computer. The software felt clunky at first - but such is the case when coming into any cad type software as controls can be different. 

Looking forward to scanning other items and use them for practical designs.