Final Project: JeLamp — AI Gesture Reactive Desk Lamp

Step 1 — Schematic Design (KiCad, Week 6)

1. Create project HelloworldNew in KiCad 8 with Fab Academy library (fab.kicad_sym, fab.pretty).
2. Place XIAO ESP32-C3 module (U1), two 1×6 pin headers (J1, J2), tactile switch (SW1), two 1206 LEDs (D1, D2), and current-limiting resistors.
3. Add 10 kΩ pull-up on the button input net (revised after first test).
4. Run ERC until zero errors; annotate components and assign SMD footprints (1206 resistors, SMA diode if used).

Step 2 — PCB Layout

1. Update PCB from schematic; set board outline to match XIAO module + header breakout area.
2. Set design rules for in-house milling: ≥ 0.38 mm trace/space, ≥ 0.5 mm preferred for power paths.
3. Place XIAO with USB-C edge accessible; route signal traces at 0.4 mm, keep ground pour on copper layer.
4. Add silkscreen labels for pin functions and board title.
5. Run DRC; export Gerbers (F.Cu, Edge.Cuts) for milling.

Step 3 — G-code Generation (Mods CE)

1. Convert Gerber to PNG via Gerber2PNG — white traces on black background.
2. Open Mods CE in Chrome → program → Open Program.
3. Load traces_toplayer_0.png; set 40° #502 V-bit preset; calculate and save trace G-code.
4. Reload outline PNG; use 1.5 mm ball-end mill preset; calculate and save outline G-code.
5. Simulate 3D preview before cutting — verify no stray dots or missing isolation paths.

Step 4 — CNC Milling (KEXU)

1. Secure 1.6 mm FR-4 copper-clad on sacrificial plate with double-sided tape.
2. Install V-bit; set X/Y origin at front-left corner; Z zero with paper-drag test.
3. Run trace G-code at 14,000 rpm, 4 mm/s feed, 0.23 mm cut depth.
4. Swap to ball-end mill; re-zero Z; run outline pass to cut board free.
5. Deburr with sandpaper; wash board with soap and water before soldering.

Step 5 — Soldering & Board Test

1. Solder SMD passives first (resistors, LEDs, switch), then pin headers, then XIAO module last.
2. Inspect joints under magnification; check no bridges on castellated pads.
3. Multimeter: no short between 5 V and GND.
4. Flash HelloWorldWeek8.ino — button on D7 toggles LEDs on D8/D9.
5. After pull-up fix, order revised board from JLCPCB for reliable production units used in JeLamp.

Step 1 — CAD Design (Onshape)

1. Import STS3215 motor model as reference

1. Create a new Onshape document (Jelamp); set workspace units to mm (File → Units).
2. Download or import the Feetech STS3215 STEP model into the document (appears as SCS215 v5 in the parts list).
3. Insert the servo into an Assembly tab — do not redesign the motor body; treat it as a fixed reference volume.
4. Add a Mate connector at the output horn center (Z along shaft axis) — this becomes the anchor for every joint above it.
5. Measure horn bolt circle, body width, and shaft height from the imported model before sketching any custom plastic.

2. Lamp base — Assembly mates define placement

1. Switch to a new Part Studio for the base; sketch the footprint on the Top plane using projected servo edges from the assembly.
2. Extrude / revolve the base shell with a central pocket that clears the STS3215 body and exposes the mounting ears.
3. Model horn-adaptor features (circular boss + 4× M2 holes) that match the mate connector orientation from Step 1.
4. Return to Assembly; insert the base part and Fasten it to the bottom servo mate connector — adjust offset until the base sits flush on the desk plane.
5. Add cable pass-through slots for I2C wiring before exporting STL.

3. Lamp arm connections — sized to STS3215 interface

1. For each joint, create a separate part (lower arm, upper arm, neck) with its own mate connector at the STS3215 horn center.
2. Sketch horn-adaptor profiles by projecting the STS3215 top face — match the 4-hole pattern and splined bore clearance.
3. Extrude arm tubes with Up to vertex / Up to face so link length updates when mate offsets change in Assembly.
4. Mate each arm segment to the next STS3215 instance in Assembly; verify clearance and that the fixed pose matches the intended lamp silhouette.

4. Lamp head — measure electronics, then set dimensions

1. Measure physical parts with calipers: XIAO ESP32-S3 Sense module, Week 8 / carrier PCB, NeoPixel ring OD, and camera lens field-of-view cone.
2. Import or sketch simplified envelope solids for each board; place them inside a head Assembly to find required cavity length, width, and height.
3. Design the hex shell with internal shelf for the PCB, ring recess for NeoPixels, and a front opening aligned to the OV2640 camera.
4. Add a sloped face or light pipe gap for the acrylic laser-cut panel; mate the head to the top STS3215 via horn adaptor + mate connector.
5. Run interference check in Assembly; adjust wall thickness until all boards fit with ≥ 1 mm clearance, then export STLs.

Step 2 — Slicing & Print Settings

1. Import STLs into PrusaSlicer / Bambu Studio; orient parts to minimize overhangs on servo pockets.
2. Layer height 0.2 mm; infill 20–30% for structural parts, 15% for decorative shell.
3. Enable supports only where bridging exceeds ~ 10 mm (e.g. under lamp head overhang).
4. Print brim or raft on tall narrow parts to reduce warping on the heat bed.
5. Group small parts on one plate only if they share material and layer time.

Step 3 — FDM Printing

1. Load PLA filament (blue for arm segments; white optional for lamp shade).
2. Level bed and verify first-layer adhesion before long prints.
3. Print base and arm segments sequentially; monitor first layers for warping.
4. Remove support structures carefully; deburr servo pocket edges with a small file.
5. Dry-fit STS3215 connectors and laser-cut panel before final assembly.

Step 1 — Vector Design

1. Create hex outline in an Onshape sketch (derived from lamp head opening dimension) or Inkscape; size to press-fit into the 3D-printed recess.
2. Add decorative floral pattern as vector paths for raster engraving (not cut-through).
3. Place "Jelamp" logo text at bottom of panel; convert text to paths.
4. Assign cut layer (hex perimeter) vs engrave layer (decorative lines) in separate colors for the laser job.
5. Export as SVG or DXF; verify stroke widths and closed paths.

Step 2 — Laser Job Setup

1. Material: 3 mm translucent blue acrylic (verify no PVC / chlorine content).
2. Focus lens to material surface; enable fume extraction before starting.
3. Cut settings (reference from Week 3 group tests): adjust power/speed for clean edge on acrylic.
4. Engrave settings: lower power, higher speed — test on scrap first to avoid melting fine lines.
5. Apply kerf offset (~ 0.15 mm per side) so panel press-fits into 3D-printed recess.

Step 3 — Cutting & Post-processing

1. Secure acrylic sheet flat on honeycomb bed; run cut pass for hex perimeter.
2. Run engrave pass for floral pattern and logo.
3. Remove protective film; peel off any smoke residue with mild soap and water.
4. Test press-fit into lamp head; lightly sand edges if too tight.

Architecture — Dual Board + I2C

Dual-board architecture: ESP32-S3 (Master) → I2C → ESP32-C3 (Slave)

Board 1 — ESP32-S3 Sense (base)
  • OV2640 camera + SenseCraft AI / SSCMA_Micro_Core inference
  • I2C master: sends Box / Class packets to slave 0x08

Board 2 — ESP32-C3 (Week 8 PCB, lamp head)
  • I2C slave @ 0x08
  • NeoPixel ring on D3
  • Optional Wi-Fi web UI (Week 15)

Step 1 — I2C Wiring

ESP32-S3 (Master) → I2C → ESP32-C3 (Slave)

  XIAO ESP32-S3          XIAO ESP32-C3
  ┌──────────┐          ┌──────────┐
  │ SDA(D4)  ├──────────┤ SDA(D4)  │
  │ GPIO5    │          │ GPIO6    │
  │          │          │          │
  │ SCL(D5)  ├──────────┤ SCL(D5)  │
  │ GPIO6    │          │ GPIO7    │
  │          │          │          │
  │ GND      ├──────────┤ GND      │
  └──────────┘          └──────────┘

Signal	ESP32-S3 (Master)	ESP32-C3 (Slave)
SDA	D4 / GPIO5 (Arduino pin 5)	D4 / GPIO6
SCL	D5 / GPIO6 (Arduino pin 6)	D5 / GPIO7
GND	GND	GND (common)
Bus speed	100 kHz (Wire.setClock(100000) on master)
Slave address	0x08

3-wire cable (GND, SDA, SCL) through hollow arm from base to lamp head.

Step 2 — SenseCraft AI Model Deployment

1. Open SenseCraft AI Model Assistant.
2. Select board: XIAO ESP32-S3 Sense.
3. Choose the pretrained hand gesture model (paper / stone — 布 / 石头).
4. Flash the model firmware via USB-C; confirm Serial output shows class labels.
5. Install the SSCMA_Micro_Core library in Arduino IDE (bundled with SenseCraft export).
6. Merge custom I2C send code (JeLamp_S3_Master.ino) with the inference loop.

Step 3 — I2C Packet Protocol

Master packs SenseCraft inference into byte arrays. First byte = packet type:

Type	Len	Format
0x01 Box	12 B	[0x01][x][y][w][h][score][target] — coords ×100, big-endian int16
0x02 Class	4 B	[0x02][score_hi][score_lo][target]
0x03 Point	10 B	[0x03][x][y][z][score][target]
0xFF Perf	7 B	[0xFF][preprocess][inference][postprocess] ms timings

SenseCraft class targets → NeoPixel (C3 slave):

target	Gesture	Default effect
0	Paper (布 bu)	Blue wave
1	Stone (石头 shitou)	Red pulse
−1	No detection (2 s timeout)	Warm idle breathe

Step 4 — Source Code

All files in public/files/final-project/. Download links below — full source, not snippets.

File	Board	Description
JeLamp_S3_Master.ino	ESP32-S3 Sense	SenseCraft AI + camera + sendBox / sendClass / sendPoint / sendPerf
JeLamp_C3_Slave.ino	ESP32-C3	Basic I2C slave — paper wave / stone pulse / idle breathe
JeLamp_C3_Slave_Web.ino	ESP32-C3	Advanced — web UI for color + pattern + speed; requires types.h
types.h	ESP32-C3	PatternType, GestureConfig, IdleConfig — place next to Web .ino

Board 1 — ESP32-S3 Master (excerpt)

#include <SSCMA_Micro_Core.h>
#include <Wire.h>

#define C3_SLAVE_ADDR 0x08
#define I2C_SDA       5    // ESP32-S3 D4 / GPIO5
#define I2C_SCL       6    // ESP32-S3 D5 / GPIO6

void sendClass(const SSCMAMicroCore::Class& cls) {
    uint8_t buf[4];
    buf[0] = 0x02;
    int16_t score = (int16_t)(cls.score * 100);
    buf[1] = (score >> 8) & 0xFF;
    buf[2] = score & 0xFF;
    buf[3] = (int8_t)cls.target;
    Wire.beginTransmission(C3_SLAVE_ADDR);
    Wire.write(buf, 4);
    Wire.endTransmission();
}

void setup() {
    Wire.begin(I2C_SDA, I2C_SCL);
    Wire.setClock(100000);
    capture.begin(SSCMAMicroCore::VideoCapture::DefaultCameraConfigXIAOS3);
    instance.begin(SSCMAMicroCore::Config::DefaultConfig);
}

void loop() {
    auto frame = capture.getManagedFrame();
    instance.invoke(frame);
    for (const auto& cls : instance.getClasses()) sendClass(cls);
    delay(100);
}

Board 2 — ESP32-C3 Slave (excerpt)

#define I2C_SLAVE_ADDR  0x08
#define NEOPIXEL_PIN    D3
#define NUM_PIXELS      8

Wire.begin(I2C_SLAVE_ADDR);
Wire.onReceive(onReceive);

// MSG_CLASS: buf[1..2]=score, buf[3]=target
// target 0 -> effectPaper (blue wave)
// target 1 -> effectStone (red pulse)
// timeout 2 s -> effectIdle (warm breathe)

Upload settings

Board	Sketch	Libraries
XIAO ESP32-S3 Sense	JeLamp_S3_Master.ino	SSCMA_Micro_Core (SenseCraft AI)
XIAO ESP32-C3	JeLamp_C3_Slave.ino or JeLamp_C3_Slave_Web.ino + types.h	Adafruit NeoPixel · Web version also: WiFi, WebServer, DNSServer, Preferences

Step 5 — On-device Validation

1. Flash C3 slave first; confirm boot animation (blue / red sweep) then idle breathe.
2. Connect I2C; flash S3 master; Serial @ 115200 — watch Class: target=… score=….
3. Show paper (target 0) → blue wave; show stone (target 1) → red pulse.
4. Remove hand for 2 s → idle warm breathe returns.
5. Web version: connect to AP RPS-XXXX, open http://192.168.4.1, tune colors/patterns.