CrunchLabs Label Maker: Build, Plot, and Print

Robots that move, react, and follow instructions often hide surprising complexity beneath simple ideas. The first two Hack Pack projects demonstrated this well. The IR Turret explored controlled rotation with servos, while the Domino Robot introduced sensors, feedback, and the basics of autonomous behaviour. The third kit in the series shifts the focus once again. The Label Maker is still playful in appearance, yet it brings builders closer to the principles that guide real plotters and CNC machines.

On the surface, the Label Maker writes text on a roll of tape. Behind the scenes, it interprets characters, converts them into drawing paths, and coordinates two stepper motors and a servo with consistent precision. This combination of mechanical design and software structure creates a machine that feels very different from the earlier projects.

The design of the label maker is quite ingenious, it "prints" on marking tape using a permanent marker.

This article explores that transition. It looks inside the hardware that enables precise motion, examines the state machine that organizes the robot’s behaviour, and explains how each letter is encoded as a series of movements. From there, it explores freehand drawing and reflects on how the Label Maker builds on the ideas introduced in the earlier Hack Packs. The result is a deeper understanding of how simple components can form a reliable, repeatable tool when guided by well-structured code.

💡

CrunchLabs has updated the order in which Hack Pack robots are shipped, placing several fan favorites into the first year. This part of an on-going effort to optimize how builders learn and progress. That said, Technodabbler will continue to refer to this as the third robot in the series, but new members may receive their Hack Pack projects in a different order. Thanks to Hack Pack Hackers for pointing out the changes in the lineup.

Inside the Box

The Label Maker introduces a collection of components to enable more advanced forms of motion control. These additions shift the project into a new category of robotics: one centered on precision rather than momentum or timing.

A joystick typically uses five wires: power and ground, two analog outputs for horizontal and vertical movement, and a digital switch line that activates when the joystick is pressed.

The most visible hardware change is the joystick. It replaces the infrared remote from the IR Turret and the simple sensors from the Domino Robot with a true analog control. Inside the joystick are two potentiometers that measure how far the stick is pushed along the horizontal and vertical axes. By reading the voltages from these potentiometers, the microcontroller can detect the direction and the magnitude of the movement. This allows smooth menu navigation and lays the foundation for freehand drawing in sketch mode. It is the first time in the series that the robot responds to a continuous analog input rather than a digital on or off signal.

An LCD screen is provided to display the content of the label to be printed.

The second major addition is the LCD screen mounted on the front panel. Earlier projects relied on physical movement alone to communicate what the robot was doing. The Label Maker instead uses a display to preview the text being printed and show its current state. Rather than driving the screen directly from individual GPIO pins, the LCD is paired with an I²C interface board that handles the low-level signaling and lets the controller communicate with the display.

At its core, I²C uses just two shared wires: one for data (SDA) and one for the clock (SCL). Every device on the bus listens to these same lines, and each device has a unique address. When the controller wants to talk to a specific component, it sends that address first, and only the matching device responds. This makes it easy to add displays, sensors, or memory chips without rewiring the entire board.

In the case of the LCD, the screen itself normally requires many parallel data and control lines, which would quickly exhaust the available GPIO pins. The small I²C interface board mounted on the back of the display handles that translation internally. From the controller’s perspective, sending text to the screen becomes a matter of writing characters over the I²C bus, while the interface board takes care of toggling the correct pins on the LCD.

This is the rear of the LCD module, showing the I²C backpack that reduces the display to four connections for power and data while handling all communication with the controller.

A familiar ESP32-based controller sits at the center of the machine, mounted on the custom breadboard included in the kit. While the microcontroller itself has not changed, this project makes far greater use of its capabilities. The joystick, LCD, two stepper drivers, and pen servo each require dedicated inputs and outputs, which results in a noticeably larger portion of the ESP32’s GPIO and I²C pins being active.

The ESP32 controller mounted on the custom breadboard, with many of its pins in use to connect the joystick, LCD, stepper drivers, servo, and power switch.

The mechanical systems inside the Label Maker are more sophisticated than those in the previous kits. Instead of pushing wheels or rocking a scotch yoke, the robot must move a pen with millimeter accuracy across the surface of a rotating tape roll. To achieve this, the design introduces a lead screw and rail carriage. Rotating the lead screw converts the motion of a stepper motor into precise linear travel along two metal rails. This mechanism is common in desktop 3D printers and CNC machines. It ensures that the pen travels along the correct vertical path while maintaining rigidity and alignment.

The lead screw converts the stepper motor’s rotation into controlled vertical movement of the pen carriage, while the rails guide and constrain that motion to keep it aligned.

Tape movement is handled by a grit wheel mounted on a spring-loaded arm. As the motor rotates the wheel, the tape advances under the pen. The spring ensures that the wheel applies consistent pressure on tape rolls of different diameters. If a motor was place at the center of the tape, the text would stretch or compress as the tape spool grew smaller. The tensioning system is completed by a badge retractor and a set of light springs that pull the pen carriage gently into the tape. These elements ensure that the marker maintains a steady contact force on the surface without scraping or drifting.

This grit wheel, mounted on a spring-loaded arm, advances the tape at a consistent linear speed, ensuring the lettering stays evenly spaced even as the tape roll diameter changes.

Together, these components transform the Label Maker into the most mechanically complex project in the Hack Pack series so far. The joystick and LCD bring richer interaction, while the lead screw, rails, grit wheel, and tensioning system allow the robot to move with the precision required for drawing letters.

Stepper Motors, Servos, and DC Motors

The three CrunchLabs robots form a natural progression in how machines move. The IR Turret introduced servos, which rotate to a specific angle and hold that position using an internal feedback system. Servos are ideal when a project needs controlled rotation within a limited range. They make it simple to aim, tilt, or open a small mechanism because the servo interprets its signal as a target angle and moves until it reaches that point.

This servo motor uses three wires: power, ground, and a control signal.

The Domino Robot expanded the toolkit with DC motors. These motors spin freely as long as power flows and respond to changes in voltage or polarity. The H bridge in the Domino Robot controlled each motor so the robot could speed up, slow down, or turn while following a line. DC motors are useful when a project needs continuous rotation and quick response. However, they cannot track their own position. Without additional sensors, the robot cannot know exactly how far a DC motor has turned.

This DC motor uses two wires for power, and its speed and direction are determined by the amount of current supplied and the polarity of the voltage.

The Label Maker faces a different challenge. It must place a pen at precise coordinates and follow a planned path that forms each letter. Neither servos nor DC motors offer the repeatable accuracy needed for this task. This is why the kit introduces stepper motors. A stepper turns in small, fixed increments, and each increment represents a predictable movement. When paired with a lead screw or a grit wheel, those steps translate into linear motion that the microcontroller can track simply by counting pulses. As long as the motor does not skip steps, the robot always knows the exact position of the tape and the pen carriage.

This stepper motor uses four control wires connected to separate coils, allowing the driver to energize them in sequence and move the motor in precise, repeatable steps for accurate positioning.

To drive these motors, the Label Maker relies on dedicated stepper driver boards mounted on the side panels. The ESP32 cannot energize the motor coils directly, so the drivers accept simple step and direction signals and translate them into the precise sequence of coil activations required for controlled movement. This separation of control and power ensures that the microcontroller can focus on timing and coordination while the driver handles the electrical demands of the stepper.

This stepper driver board takes simple control signals from the controller and translates them into the precise coil activation sequence needed to drive the stepper motor accurately.

This capability changes the nature of the project. Earlier robots reacted to sensor input or executed simple movements on command. The Label Maker behaves more like a small CNC plotter. It must travel to a coordinate, lift or lower the pen, and then move again with millimeter accuracy. A small error not only shifts the letter but affects every stroke that follows. Stepper motors provide the precision necessary for consistent writing, which is why they are widely used in 3D printers, engravers, and other computer-controlled machines.

Building the Label Maker

As with the earlier Hack Pack projects, the Label Maker arrives as a collection of wood panels, motors, electronic boards, and carefully designed mechanical parts. The build is more involved than the IR Turret or the Domino Robot, but the structure is logical and introduces new mechanical ideas in a clear sequence.

The Label Maker, all components before assembly.

The front interface panel is assembled first. Mounting the LCD and joystick gives the robot a defined control surface before anything else is added. This order is intentional. The Label Maker’s behavior is driven through menu interaction rather than direct motion. Placing the interface at the beginning helps builders understand the robot as a tool that accepts instructions rather than a machine that simply reacts to inputs.

The build starts with the assembly of the front panel, including both LCD and joystick.

The two stepper motor drivers are attached to the side panels next. Their placement mirrors the overall motion system. The X-axis driver sits on the left and controls tape movement, while the Y-axis driver sits on the right and controls the vertical travel of the pen carriage. This separation mirrors the plotter design introduced later in the code. It also keeps the wiring straightforward, with each motor running to the side where its driver is mounted.

The X-axis driver is a grit wheel that will roll the tape along.

Building the X axis highlights the mechanical design that compensates for changes in tape roll diameter. The grit wheel, powered by a step motor, is pressed against the tape using a spring-loaded arm. As the roll becomes smaller, the arm maintains constant pressure, which keeps the tape’s linear motion predictable. During assembly, this system appears deceptively simple, but it plays a critical role in maintaining consistent letter width throughout the label.

The Y-axis is a lead screw controlled by a step motor. A small servo attached to the board controls if the pen touches the tape or not.

The Y axis introduces the lead screw and rail carriage. Rotating the lead screw, powered by the second step motor, moves the carriage smoothly along two metal rails. This mechanism is common in 3D printers and CNC machines, and seeing it in a compact kit helps younger builders understand how linear motion is achieved without wobble or drift. The pen holder slides onto the carriage, and a servo motor’s bearing is mounted so it can lift (push back) or lower (bring forward) the marker as instructions require.

With the top part assembled, the Label Maker is ready for final assembly.

Both axes come together when the carriage is installed through the central opening of the main wood panel. A badge retractor is added, providing gentle and consistent tension. This tensioning system ensures that the carriage remains in contact with the tape while still moving freely across its range of motion.

Cabling is managed through elastic, ensuring they don't get snagged in the mechanism.

The final steps focus on electronics and cable routing. The microcontroller sits on a small breadboard mounted at the top of the structure. Power, ground, stepper signals, and servo lines are organized with elastic loops, which prevents wires from drifting into the path of the moving carriage.

Programmatic Label Creation

The Label Maker’s program is more than a simple loop that reads inputs and turns motors. It behaves like a small plotting machine, with distinct phases for editing text, rendering characters, and idling once a label is complete. To keep all of this manageable, the code is organized around three ideas: a state machine that defines what the robot is doing, a joystick input layer that feeds that state machine, and a motion layer that translates decisions into stepper and servo movement.

State machines

Earlier CrunchLabs projects relied mostly on branching logic. The main loop checked a sensor or remote code, then reacted immediately. The Label Maker introduces a formal state machine. Instead of asking “what input did I just see,” the program begins by asking “what state am I in right now.”

The behavior of the Label Maker is determined by its state, tracked by several variables. This diagram illustrates how these states can transition.

In practice, the code defines a set of named states such as “MainMenu,” “Editing”, “PrintConfirmation,” and “Printing.” Variable tracks both the current and previous states, and every pass through the main loop calls a handler that corresponds to the current state. Each handler decides whether to remain in the same state or move to another. For example, while in the editing state, pressing the joystick switches to the "PrintConfirmation" state. When the user selects “Yes,” the program switches to the "Printing" state, where joystick input is ignored and the machine focuses on stepping through the stored vector data.

if (button1.isPressed()) {
    // Single click: Add character and reset alphabet scroll
    if (currentCharacter == 0) {
      text += ' ';  //add a space if the character is _
    } else {
      text += alphabet[currentCharacter];  //add the current character to the text
      currentCharacter = 0;                // reset for the next character
    }

  lcd.clear();
  currentState = PrintConfirmation;
  prevState = Editing;
}

If the joystick is pressed while "Editing" mode, the code transitions to the "PrintConfirmation" mode, which should start the next time the code loops around.

This structure has several advantages. It keeps unrelated behavior separated, so code that handles menus does not interfere with the motion routines, and vice versa. It also makes the program easier to read, since each state has a clear purpose and limited responsibilities.

Reading input from the joystick

The joystick replaces the IR Turret’s event-driven input system. In that earlier project, the robot received discrete infrared codes that represented single button presses. Each press triggered one action, such as rotating the turret or firing the foam dart.

void loop() {

  button1.loop();
  button1State = button1.getState();

  joystickX = analogRead(joystickXPin);
  joystickY = analogRead(joystickYPin);
  joyUp = joystickY < (512 - joystickButtonThreshold);
  joyDown = joystickY > (512 + joystickButtonThreshold);
  joyLeft = joystickX < (512 - joystickButtonThreshold);
  joyRight = joystickX > (512 + joystickButtonThreshold);
}

At each loop, the state of the joystick is read.

The Label Maker behaves differently. Because everything runs inside a continuous event loop, the joystick does not produce isolated events. Instead, the program samples the analog stick position repeatedly, converting the readings into a set of boolean states such as joyUp, joyDown, joyLeft, and joyRight. If the user holds the joystick to the left, that state remains true across multiple passes through the loop. The effect is deliberate: holding the joystick down cycles through menu characters, advances selection fields, or scrolls through available options at a natural pace.

if (joyUp) {  //UP (previous character)

  if (currentCharacter > 0) {
    currentCharacter--;
    lcd.print(alphabet[currentCharacter]);
    //Serial.println("Character UP");
  }

  delay(250);  // Delay to prevent rapid scrolling

} else if (joyDown) {  //DOWN (next character)

  if (currentCharacter < (alphabetSize - 1)) {
    currentCharacter++;  //increment character value
    lcd.print(alphabet[currentCharacter]);
    //Serial.println("Character DOWN");
  }

  delay(250);  // Delay to prevent rapid scrolling
}

While in "Editing" mode, the up or down state on the joystick cycles a character at every event loop.

The joystick button is handled the same way. It is checked every loop, and if pressed, it triggers a confirmation action appropriate for the current state. Because the joystick does not interact directly with the motors, its code remains the same regardless of what the robot is physically doing.

Vector Encoding of Characters

Inside the code, every character described as a a sequence of three digit numbers (for example 024). These numbers determine whether the pen should be up or down, and the next destination of the pen. Each character is drawn on a five by five grid, with both x and y running from 0 to 4.

• Hundreds digit = pen state (0 is up, 1 is down)
• Tens digit = x coordinate
• Ones digit =y coordinate
• 200 marks the end of the data for that letter
• 222 means plot a single point

The label maker draws a letter by decoding each of these instructions, and actioning them through the various motors.

The encoding of the letter A, as see in the Crunch Labs video. This shows the movement of the pen for the letter, but doesn't properly illustrate the pen down mechanism.

In the case of the letter A, the instruction { 000, 124, 140, 012, 132, 200 } can be interpreted as

• 000: Start pen up at (0,0)
• 124: Pen down, and draw up to (2,4)
• 140: Keeping the pen down, move to (4,0)
• 012 : Raise the pen, and move it to (1,2)
• 132 : Pen back down, and come back to (3,2)
• 200 : Raise the pen back up, we are done

The result is a compact, human-readable way to describe letters. Updating the shape of a character is as simple as changing a few numbers in the table, while the motion code remains the same.

Controlling the motors

Once the program transitions to the printing state, it begins interpreting the stored drawing instructions. The positions from the encoded instructions represent conceptual drawing coordinates on a five by five grid. The motion code must convert them into the actual number of steps needed to move the tape and the pen carriage.

The X motor advances the tape by rotating the grit wheel, while the Y motor moves the pen carriage along the lead screw. For each target coordinate, the program calculates how many steps each axis must take and issues pulses in the correct ratio so both axes arrive at the new location at the same time. This coordination is what produces clean, straight lines between drawing points.

💡

The stock code used to control the steppers is an implementation of Bresenhams line algorithm. This algorithm, given a target X and Y, finds the slope between any two points, thus determining how many steps each motor should do to move smoothly to the target.

The pen servo operates alongside the steppers. When the instruction indicates that the pen should draw, the servo rotates to press the bearing gently against the tape. When the instruction calls for travel without marking, the servo lifts the marker clear by pushing the pen carrier back. The state machine ensures uninterrupted execution of these movements until all instructions have been processed.

 //used to handle lifting or lowering the pen
void plot(boolean penOnPaper) {

  if (penOnPaper) {   //if the pen is already up, put it down
    angle = 80;
  } else {  //if down, then lift up.
    angle = 25;
  }

  //actuate the servo to either position.
  servo.write(angle);

  //gives the servo time to move before jumping into the next action
  if (penOnPaper != pPenOnPaper) delay(50);

  //store the previous state.
  pPenOnPaper = penOnPaper;
}

The following lift or lowers the pen.

It is this combination of coordinated motor stepping, mechanical compensation from the grit wheel assembly, and controlled pen motion that enable the Label Maker produces letters that remain consistent regardless of how much tape remains on the roll.

Beyond the Design

Once the Label Maker can plot characters reliably, the most natural extension is to let the user draw freely with the joystick. This mode replaces structured vector instructions with direct control. Instead of moving between fixed coordinates on a five by five grid, the robot steps in small increments according to the current joystick position. The result is similar to an Etch A Sketch, where the user moves a cursor along the X and Y axis.

if (joyUp) {
  yStepper.step(3);
  ypos++;
}

if (joyDown) {
  yStepper.step(-3);
  ypos--;
}

if (joyLeft) {
  xStepper.step(1);
  xpos--;
}

if (joyRight) {
  xStepper.step(-1);
  xpos++;
}

if (button1.isPressed()){
  if (!pPenOnPaper){
    plot(1);
  } else {
    plot(0);
  }
}

In freehand, the joystick directly controls the steppers.

The shift in behaviour illustrates the difference between planned and continuous motion. In printing mode, the robot follows a series of encoded coordinates. The program calculates the exact number of steps needed on both axes and coordinates them to produce straight lines between those points. Freehand drawing uses none of this planning. The joystick is sampled each time through the loop, and the direction states determine which axis should step next. Holding the joystick to the left repeatedly triggers leftward steps, while a slight upward tilt produces a diagonal. Movement appears smooth to the user because these small steps accumulate quickly, even though each step is issued independently.

Beyond motion, the Label Maker can also be viewed as an encoding tool. Text does not move directly to the motors. It is first transformed into an internal representation that the machine knows how to draw. Changing that representation opens the door to entirely new outputs without modifying the hardware. Instead of plotting standard letters, the system could output Morse code as a sequence of short and long marks, or apply a simple cipher such as a Caesar shift before rendering the text. In this mode, the Label Maker becomes a physical encoder, turning information into patterns that are readable only by someone who understands the scheme.

Final Thoughts

Across the three Hack Pack robots, there is a clear learning path that gradually shifts from simple motion to structured, purposeful behavior. The Label Maker pushes the builder to think about how a machine interprets information, plans its movements, and executes them with precision. The combination of a state machine, a grid-based character system, and coordinated stepper control marks a transition from playful experimentation to the foundations of real computer-controlled motion.

What makes the Label Maker particularly effective is the balance between accessibility and depth. It remains approachable as a project, yet it reveals how plotters, CNC machines, and even 3D printers organise their tasks. Builders can print text, draw freehand, or modify the character tables to explore how the robot converts instructions into physical motion. In doing so, the Label Maker becomes a small, hands-on demonstration of how software structure and mechanical design work together to create reliable, repeatable results.

CrunchLabs Sand Garden: Build, Sweep, and DrawA look at the Sand Garden’s polar gantry, stepper logic, and pattern code. An interesting build, though the advanced math places it beyond typical Hack Pack difficulty.TechnodabblerAlex Denault

Explore the next box of the Hackpack series with the Sand Garden

Have you experimented with plotting or drawing code? Share your results, questions, or favorite customizations in the comments below. If you enjoyed this project, take a look at our article on 3D printing and how modern filament printers achieve the precision that inspires machines like this one.

                        Learn more