Semi-automatic
honey packager
A weighing-and-filling machine for a beekeeper who needed to scale.
Why this matters
After EDAPI, the same beekeeper came back with a different problem. His honey packaging was fully manual: open a valve, watch a scale, close the valve when the jar looked full.
- Overfill loss — inconsistent manual fills meant lost product over hundreds of units a day
- Heavy lifting — moving honey from 1-ton tanks into smaller containers was physically demanding
- Crystallization — once partially solid, honey won't flow through valves or pumps
He needed a system that could dispense accurately into 1 kg jars unsupervised, keep honey warm enough to flow (30–35°C) without degrading it (honey breaks down above ~40°C), and continuously homogenize it to prevent crystallization.
How I solved it
A closed-loop dispensing cycle controlled by a finite state machine. The operator presses a footswitch to start a fill; the PCB does the rest.
| Pump (AC) | Moves honey from bulk container to the packaging vessel. |
|---|---|
| Heater | Maintains honey at 30–35°C — fluid enough to flow, cool enough to preserve quality. |
| Mixer (in the lid) | Eccentric agitator with flat beater attachment — continuous homogenization during packaging. |
| Valve + load cell | Solenoid valve releases honey into the jar on the scale; load cell provides real-time weight feedback. |
Multi-domain ownership
| Electronics | Custom mixed-signal PCB: AC power switching for pump and heater, DC motor control for the mixer, solenoid valve driver, HX711 amplifier interface, footswitch input, temperature reading. Multiple voltage domains (AC mains, DC logic, isolated analog). |
|---|---|
| Mechanical (mixer) | Designed from scratch around the container lid, the motor I was given, and the need to keep honey moving without splashing: an eccentric shaft coupled to the motor with a flat beater attachment (kitchen-mixer style, for viscous mixtures). Fully integrated into the lid so the container could be sealed. |
| Firmware | Finite state machine in C/C++ tracking valve state, pump state, and fill progress. Closed-loop fill: rolling average of 6 weight samples, valve stays open until 15 g below target — accounting for honey still in transit when the valve closes. |
Key technical decision
Rather than building a custom load cell mount, I opened a commercial electronic scale and intercepted its load cell signal directly. The HX711 amplifier was already inside, outputting a clean analog voltage. I wired that into the microcontroller's ADC and used the existing scale chassis as the weighing platform — faster development, mechanical reliability inherited from a proven product, and one less subsystem to debug.
What it achieved
Video — Packager filling jars on-site
What didn't fully work
- Mixer vibration — the eccentric agitator transferred too much motion to the container
- Pump reliability — under highly viscous or partially crystallized batches, the AC pump occasionally stalled
- Adaptive threshold (planned, partial) — the deployed firmware I have doesn't contain the adaptive 15 g offset; unclear if it shipped
What I took from it
Honey is harder to engineer for than it looks. It's a non-Newtonian fluid that changes viscosity with temperature, time, and history. The 15 g calibration constant wasn't a bug in our design — it was a physical inevitability of fluid still in transit between the valve and the jar. Engineering the system meant accepting that no amount of cleverness erases the physics, and designing around it: oversample, predict, close early.