ELLA ZHOU

A Halloween figure and lantern

For my first laser-cutting project, I made a Halloween scene with a ghost-like figure holding a small lantern. The lantern has bat-shaped openings, and the figure stands on a rectangular cardboard base. My aim was to turn a flat design into an object with depth, using separate parts for the figure, face, lantern, and support.

From sketch to physical parts

My sketch shows the overall composition: a tall figure, an outstretched arm, a lantern, and a base. The photos document the project at several stages, from separate cut panels to the assembled scene. I have arranged them below as a visual explanation of the construction, rather than a record of the exact order in which every photo was taken.

1. Plan the composition. The drawing brings together the figure and lantern and includes a box-like support beneath the lantern.
2. Break the object into flat pieces. The photographed parts include a slotted base, rectangular panels with tabs and openings, and panels with X-shaped details. These pieces show how a three-dimensional structure can be divided into two-dimensional profiles.
3. Build the lantern. Close-up photos show the bat-cutout walls between top and bottom pieces. The exposed corrugated edges make the material thickness and layered construction visible.
4. Bring the scene together. One photo shows the figure and lantern without the separate face layer. Other views show the face in place and the figure on its base, with the lantern beside the outstretched arm.

Challenges and what the photos reveal

The main design challenge was the relationship between the flat profiles and the assembled object: the lantern walls, top, bottom, and handle have to meet, while the larger figure needs support at its base. The close-ups show uneven edges and visible gaps around some lantern connections. These are useful details to inspect in a future fit test, although a photograph alone cannot establish whether a joint is too loose or too tight.

My documentation is incomplete in an important way: it does not record the material thickness, slot dimensions, kerf test results, laser power or speed, or a sequence of failed cuts and recuts. I cannot reliably reconstruct those values from the finished object. For the next iteration, I would measure the cardboard, cut a small joint test, record the settings, and photograph each change before cutting the full design again. I would also keep the source design file alongside the process notes.

A failure in publishing the process

I also encountered a documentation problem. Uploading the original iPhone HEIC photos failed, and an early conversion produced black images on the website. The original photos still displayed correctly in Preview. With assistance, they were converted again, reduced to web-sized JPEGs, and uploaded in smaller batches. This taught me to check the actual published images rather than assume that a successful upload means the photos are readable.

Result: the photographs document a physical cardboard Halloween scene and a separately assembled lantern. They do not show a lighting test. My next improvement would be to document the dimensions, fitting tests, and assembly changes as carefully as the final appearance.

Photo record

Sketch, separate parts, lantern details, and assembly views. Click any photo to see it full size.

Goal and setup

After assembling my QPAD-XIAO, I wanted its OLED screen to display a beating heart. The controller is a Seeed Studio XIAO RP2040, connected to my Mac by USB-C. I used an AI-assisted MicroPython program saved as main.py. It contains a small SSD1306-compatible driver for the 128 × 64 OLED, so the display code does not need a separate driver package.

Week 2 photo record

These two photos show my assembled QPAD-XIAO during the initial USB-C setup, before the firmware recovery and successful animation test described below.

What went wrong

At first, the board had power but the display was blank. I had opened main.py on my Mac, which did not upload it to the board. The suggested Thonny workflow was also blocked because Thonny was not installed. With Codex assisting on my Mac, I used MicroPython's official mpremote tool instead.

The Mac detected the XIAO RP2040 as a USB serial device, but the board did not respond to MicroPython commands. The connection failed with could not enter raw repl. Interrupt commands, a soft-reset attempt, and unplugging and reconnecting the cable did not restore communication. Attempts to enter the bootloader manually also did not produce an accessible RPI-RP2 drive. These failures showed that detecting a USB device was not enough to prove that a usable MicroPython environment was running.

Recovery and upload

1. Enter recovery mode. A 1200-baud USB serial reset signal switched the board into its RP2 bootloader. The Mac could detect the bootloader even though a normal upload drive did not mount.
2. Back up before changing firmware. Raspberry Pi's picotool saved and verified a complete backup of the board's 2 MB flash.
3. Install the correct firmware. The official MicroPython v1.29.0 firmware for the Seeed XIAO RP2040 was written, verified, and the board restarted. After this, MicroPython commands worked. This resolved the connection problem; the exact cause of the old firmware's lack of response was not established.
4. Check the display connection. An I2C scan on bus 1, with SCL on GPIO 7 and SDA on GPIO 6, detected address 0x3C. This confirmed that the OLED responded over I2C.
5. Save and verify the program. The heart code was copied to the board as main.py, read back, and compared with the original file. The two copies matched.
6. Restart and test. A soft reboot started the saved program. The serial output reported OLED connected. Preparing heartbeat... followed by Heartbeat running., with no traceback during the startup observation.

How the animation works

The program calculates six heart images at different sizes and stores them in memory. It displays them in a sequence of two quick pulses followed by a longer pause, producing a “lub-dub” rhythm. Calculating the frames once avoids redrawing the mathematical shape for every frame. Saving the program as main.py allows MicroPython to start it automatically at boot.

Result and reflection

The verified result was a responding OLED and a running animation loop with no startup errors. The serial log confirms that the program reached the animation; a photo or video of the heart on the physical display would complete the visual record.

The biggest lesson was to separate power, USB detection, firmware communication, file upload, and display operation. A blank screen did not automatically mean bad soldering or a broken OLED. Testing those stages individually made it possible to fix the programming environment before changing the display code. Codex assisted with the code, connection diagnosis, firmware backup and installation, and upload verification.

References: official XIAO RP2040 firmware · MicroPython remote-control tool · Raspberry Pi picotool.

Phone scan, mesh export, and slicing

These process photos document the phone scan on the lab computer, the exported STL file, and the slicer preview. The mesh views show uneven edges and gaps; the slicer images show toolpaths, rather than a completed physical print.

Documentation note: captions describe the supplied photographs and were organized with Codex assistance.

A small control-interface experiment built around the standard Seeed XIAO RP2040: one button input and one external red status LED. The intended behavior is to toggle the LED on each press. This is a starting point for understanding controls that could later inform the final project; this board does not drive a motor.

Authorship: Codex generated the new schematic, PCB layout, example code, and this documentation at Ella’s request. KiCad 10.0.7 performed the checks. Ella still needs to review and understand the design, make the board, and document the lab work. No completed fabrication, group measurements, or physical test results are claimed.

From circuit connections to copper traces

The schematic describes electrical connections; the PCB places the real footprints and routes those connections in copper. This design uses parts represented in the Fab library: a XIAO RP2040, an Omron B3SN-3112P button, a 1206 resistor, and a red 1206 LED. Actual local stock still needs confirmation.

• Input: D0 on the XIAO is GPIO26. The button connects it to ground when pressed, while the MicroPython internal pull-up keeps it high when released.
• Output: D1 is GPIO27. It connects through a 1 kΩ resistor to the LED anode; the cathode goes to ground. Assuming a 2.0 V red LED drop, the estimated current is (3.3 − 2.0) / 1000 = 1.3 mA. This is a calculation, not a measurement.
• Power: the module uses its own USB-C connector. The carrier’s external 3V3 and 5V pads are intentionally unused. The ground flag in the schematic represents USB ground, not another component to buy.

Placement, routing, and fabrication assumptions

The board fits inside a 44 × 28 mm rectangle, with a stepped outline near the USB end. The XIAO sits on the right; the button and LED sit on the left. All routes are on the top copper layer, with no vias or drill holes. A ground route goes around the lower edge, keeping copper away from the module’s underside.

Tracks are 0.6 mm wide. The project checks a minimum track width of 0.4 mm, clearance of 0.4 mm, and copper-to-edge clearance of 0.5 mm. These are proposed fabrication rules, not measurements of the lab’s milling process; the TA must confirm them for the chosen tool and stock.

The Fab XIAO footprint was adapted for castellated soldering: duplicate through-hole pads and underside debug pads were removed, and the matching symbol was reduced to the 14 edge terminals. Obsolete underside labels, the original underside keepout, and 3D-model links were removed; module outlines were moved to the assembly layer. The included local libraries preserve these changes. Check the actual standard RP2040 module and soldering access before fabrication.

Checks and corrections

The first DRC pass caught a swapped button-pad assignment. The correction assigns the upper pad pair to the input signal and the lower pair to ground. Obsolete module graphics also caused silkscreen warnings and were cleaned up. A later comparison found net-name and component-field differences between the schematic and PCB; these were synchronized using KiCad’s exported netlist.

Final checks: zero ERC violations, zero DRC violations, zero unconnected items, and zero schematic-to-PCB parity issues. The full reports are in the download. KiCad’s default ignored categories are listed in those reports; no individual violations were excluded. Passing these checks does not establish that the physical assembly works.

Files and intended firmware

Download the complete KiCad project and documentation (.zip) — editable project, schematic, PCB, local symbols and footprints, SVG exports, copper/outline Gerbers, BOM, ERC/DRC reports, MicroPython example, references, and Chinese lab instructions.

Extract the folder and open ella-button-led.kicad_pro, keeping its companion files together. The example main.py uses GPIO26/GPIO27 and 30 ms button debouncing. It has not been run on this carrier. The Gerbers must go through the lab’s CAM process; they are not machine toolpaths.

Group assignment and next lab steps

Pending: the required group observation using lab test equipment has not been documented. With the TA, confirm components and fabrication rules, make and assemble the board, check for shorts before power, and measure the 3.3 V rail and button’s released/pressed levels. Observe the LED output with an oscilloscope or logic analyzer. Record actual instrument settings, measurements, photos, errors, and the group documentation link here afterward.

References and attribution

• HTMAA electronics-design assignment and Fab inventory.
• Justin Wan, HTMAA 2025 Week 04: consulted for a small button-and-LED project scope. His project files, images, and lab results were not copied.
• Fab electronics library contributors: symbols and footprints, adapted as described above; CC BY 4.0 license included in the archive.
• Seeed XIAO RP2040 documentation for pin mapping and module specifications; KiCad workflow documentation.