Skip to the content
PCBKitNew board
2 layers68.6 × 53.3 mmWatchmen shield v2, the printed circuit board in 3D

Watchmen shield v2

Codexzier/Watchmen

Anwendung für den Arduino UNO Q, die ich zunächst mit Claude entwickle.

Size
68.6 × 53.3 mm
Copper layers
2
Thickness
1.6 mm
Parts
44
Nets
35
Pads
142
Tracks, vias
252, 191
Pours
11
Routed
Yes
KiCad
KiCad 7 (file 20221018)
Created
2 Oct 2026
Updated
25 Oct 2026

Overview

Watchmen shield v2 is an open-source printed circuit board by Codexzier, from the Codexzier/Watchmen repository on GitHub, published under the GPL-3.0 licence. It is a 2-layer board of 68.6 × 53.3 mm with 44 parts on 35 nets, routed with 252 tracks and 191 vias.

It is built around the 74AHCT1G125SE, RD-03D and ULN2003A, with the AO3401A, BAT54S and WS2812B among its other parts. Its parts include 13 resistors, 12 connectors, 7 capacitors, 2 ICs and 2 diodes.

Main components

6

README

README.md

Watchmen

Anwendung für den Arduino UNO Q (2 GB) mit UNO Media Carrier und IMX219-Kamera: Eine dreh- und neigbare Plattform erkennt Personen, Autos und ein markantes Muster (ArUco-Marker), folgt Personen bzw. dem Muster mit der Kamera, nutzt ein AI-Thinker RD-03D Human-Radar zur Auswahl der nächsten Person, spart im Ruhemodus Strom und wird über Radar oder Vibration (MPU6050) wieder geweckt. Kalibrierung und Live-Ansicht laufen über eine Webseite, die der UNO Q selbst ausliefert. Dazu gibt es ein passendes Shield (KiCad-Projekt).

Weboberfläche – Live-Ansicht (Simulation)

Inhalt

OrdnerInhalt
app.yamlApp-Beschreibung für Arduino App Lab (Bricks: web_ui, object_detection)
sketch/Mikrocontroller-Teil (STM32U585): Servos, Schrittmotor, Schalter, WS2812B, LED-Matrix, RD-03D, MPU6050, A0
python/Linux-Teil: Zustandsmaschine, Kamera, Erkennung, Nachführung, Radar, Kalibrierung, Webschnittstelle
assets/Webseite (Live-Bild, Halbkreis-Radar, Kalibrierung, Einstellungen, Marker-Druck)
hardware/Shield für den UNO Q in zwei Versionen (v1 mit, v2 ohne Fenster über der LED-Matrix): Schaltplan, Platine, Gerber – siehe hardware/README.md
docs/Verdrahtung und Pinbelegung, Bilder
tests/Simulationstests für Sketch, Python-Logik und Webseite

Der gesamte Code im Sketch und in python/ ist Zeile für Zeile auf Deutsch kommentiert.

Systemaufbau

text
           Linux (QRB2210, Debian, Python)                       MCU (STM32U585, Zephyr-Sketch)
 ┌───────────────────────────────────────────────┐   Bridge   ┌──────────────────────────────────┐
 │ controller.py  Zustände, Ruhemodus, Ausgaben  │◄──────────►│ Servos (A1, A2) sanft + Ausgleich │
 │ vision.py      Kamera IMX219, ArUco, KI       │  (RPC)     │ 28BYJ-48 + Referenzfahrt (D2)     │
 │ tracker.py     Nachführung (P-Regler)         │            │ WS2812B über SPI-MOSI (D11)       │
 │ radar.py       RD-03D-Ziele, nächste Person   │            │ LED-Matrix-Text / Lauftext        │
 │ calibration.py Kalibrierung 2 (automatisch)   │            │ RD-03D (Serial1, 256000 Baud)     │
 │ webapi.py      Webseite, MJPEG, Marker-PNG    │            │ MPU6050: Vibration + Lage         │
 │ config.py      /app/data/watchmen_config.json │            │ A0: Motoren angeschlossen?        │
 └───────────────────────────────────────────────┘            └──────────────────────────────────┘
        ▲ http://<UNO-Q>:7000 (Socket.IO + MJPEG)

Zeitkritisches (Schrittimpulse, Servo-Rampen, LED-Timing, Radar-Protokoll, Vibration) erledigt der Mikrocontroller. Entscheidungen (Kalibrierung, Erkennung, Ruhemodus) trifft die Linux-Seite.

Inbetriebnahme

  1. Kamera am Media Carrier aktivieren (App Lab ≥ Image 523): Einstellungen (Zahnrad) → Carriers → „Enable external carriers …“ einschalten, für Camera0 type1-2lanes (IMX219) wählen, Apply and reboot.
  2. App auf den UNO Q bringen, z. B. im Terminal des UNO Q:
    bash
    cd ~/ArduinoApps && git clone https://github.com/Codexzier/Watchmen.git watchmen
    Danach erscheint die App in App Lab unter My Apps. Beim ersten Start lädt App Lab die Bricks (Webserver, Objekterkennung mit YOLOX-Modell) und die Sketch-Bibliotheken (Servo, ArduinoGraphics).
  3. Starten und im Browser http://<IP-des-UNO-Q>:7000 öffnen.
  4. Verdrahtung siehe docs/Verdrahtung.md – mit dem Shield ist alles gesteckt.

Ablauf und Anzeigen

ZustandLED 1LED 2LED-Matrix
Start / nicht kalibriert / Kalibrierungrot blinkendrot blinkend–
Referenzfahrt nach dem Einschaltentürkis blinkendtürkis blinkend–
Kalibrierung abgeschlossengrün (5 s)grün (5 s)–
Erkennung aktiv, nichts im Bildausaus–
Auto erkanntblauausCAR
Person erkannt (Kamera folgt)rotausHUMEN (Lauftext)
Muster erkannt (Kamera hält es mittig)weißausMARK
Ruhemodus (1 min nichts erkannt)ausorange blinkend, 1 Hz–
Vibration über Schwellwertbeide 3× lila
Fehler (Schalter nicht gefunden)rot schnellrot schnellERR

Priorität: Muster > Person > Auto. Texte, Schwellwerte usw. sind auf der Webseite einstellbar.

  • Ruhemodus: Nach 60 s ohne Erkennung wird die Kamera abgeschaltet, Kamera- und Radar-Servo gehen waagerecht, die Spulen des Schrittmotors werden stromlos.
  • Aufwachen: ein Lebewesen im Radar näher als Weckabstand (Standard 3 m), mit mindestens Mindestgeschwindigkeit in N Meldungen hintereinander – oder eine Vibration über der Vibrationsschwelle (Standard 150 mg). Beides ist einstellbar.
  • Mehrere Personen: Die Radar-Ziele werden über ihren Winkel den Personen im Bild zugeordnet; die Kamera folgt der nächsten Person. Ohne Radar-Zuordnung wird die größte (vermutlich nächste) gewählt. Die Webseite zeigt das Radar als Halbkreis mit allen Zielen, der verfolgten Person, dem Kamera- Sichtfeld und dem Weckabstand.
  • Deckenmontage (Sonderpunkt 2): Zeigt der MPU6050 „kopfüber“, wird das Kamerabild um 180° gedreht. Die Nachführung rechnet intern im Rohbild weiter, die Kalibrierung bleibt gültig.
  • Ohne Motoren (Sonderpunkt 1): Liegen an A0 keine 3,3 V an, gibt es keine Kalibrierung und keine Bewegung – Erkennung, Anzeige, Ruhemodus und Wecken funktionieren trotzdem.

Kalibrierung

Kalibrierseite (Simulation)

Kalibrierung 1 – Bereiche (Reiter Kalibrierung):

  1. Referenzfahrt drücken: Die Drehachse fährt bis zum Kontaktschalter (= Position 0). Fährt sie in die falsche Richtung, Stopp, „Drehrichtung umkehren“ setzen und erneut starten.
  2. Mit den Schiebereglern Servo 1 (Kamera) und Servo 2 (Radar) bewegen und mit Aktuell → Minimum / Waagerecht / Maximum die Grenzen übernehmen.
  3. Mit den Jog-Tasten die Drehachse an die Grenzen fahren und Minimum / Grundstellung / Maximum übernehmen.
  4. Ausgleich testen drücken und Servo 1 bewegen: Das Radar muss waagerecht bleiben. Kippt es mit, das Vorzeichen des Ausgleichsfaktors umdrehen.
  5. Einstellungen speichern.

Kalibrierung 2 – Richtungen: Kamera auf eine strukturierte Umgebung richten und „Bereit zur Kamerabewegung einstellen“ drücken. Das System dreht und neigt um je 6° hin und zurück und misst per Phasenkorrelation, wohin und wie weit sich das Bild verschiebt (Richtung und Maßstab). Klappt das (Plausibilitätsprüfung), ist die Kalibrierung abgeschlossen. Sonst die beiden Richtungen von Hand eintragen und Speichern drücken. Danach leuchten beide LEDs 5 s grün und die Objekterkennung startet.

Nach jedem Einschalten wird bei abgeschlossener Kalibrierung zuerst automatisch die Referenzfahrt ausgeführt (Offset des Schrittmotors), danach startet die Erkennung.

Das Muster (ArUco-Marker)

Reiter Muster: Marker anzeigen und ausdrucken (Standard: Wörterbuch DICT_4X4_50, jede ID). Der weiße Rand muss erhalten bleiben. Sobald der Marker im Bild ist, hat er Vorrang vor allem anderen.

Tests (am PC, ohne Hardware)

bash
# Sketch mit Ersatz-Headern übersetzen und Hardware simulieren (g++)
tests/host_sketch/run_tests.sh

# Python-Logik mit simuliertem Mikrocontroller, Kamera-Welt und KI (numpy, opencv-python-headless, fastapi)
python3 tests/python/test_system.py

# Webseite mit simulierter Hardware ausprobieren (zusätzlich uvicorn, python-socketio)
python3 tests/python/sim_server.py --port 7000     # dann http://localhost:7000

# Browser-Test der Webseite (zusätzlich playwright + Chromium)
python3 tests/python/ui_check.py

Abgedeckt sind u. a.: Referenzfahrt inkl. Schrittverlust, Rampen, Servo-Grenzen und Radar-Ausgleich, RD-03D-Rahmen, WS2812-Bitmuster, Matrix-Text, Vibration, A0-Erkennung; in Python die komplette Kalibrierung (automatisch und von Hand), Verfolgen von Person und Muster (auch kopfüber), Auswahl der nächsten Person per Radar, Ruhemodus und Wecken per Radar/Vibration, Betrieb ohne Motoren und Neustart.

Was vor dem Einsatz am echten Gerät zu prüfen ist

Die Software wurde gegen die offiziellen Quellen (App-Lab-Bricks, Arduino Zephyr-Core, RouterBridge, Servo-Bibliothek) geschrieben und in Simulationen getestet. Auf echter Hardware konnte ich sie nicht laufen lassen; ein Übersetzen mit der originalen Arduino-Toolchain war in meiner Umgebung nicht möglich (Download gesperrt). Besonders beachten:

  • Beim ersten Übersetzen in App Lab eventuelle Compiler-Meldungen prüfen.
  • WS2812B: Das SPI-Timing geht von 5 MHz SPI-Takt aus (SPI2 an 160 MHz). Falsche Farben → Pegelwandler und Verdrahtung prüfen.
  • RD-03D: Seitenrichtung je nach Einbau → ggf. „Radar-X-Achse spiegeln“.
  • MPU6050: „oben“-Achse passend zur Einbaulage einstellen (siehe Verdrahtung).
  • Shield v1: Lage des Fensters über der LED-Matrix mit der 1:1-Vorlage prüfen (siehe hardware/README.md). Das Shield v2 hat kein Fenster und verdeckt die Matrix.

Parts

44
QtyValueFootprintReferences
5100nFCapacitor_SMD:C_0805_2012MetricC2, C3, C4, C6, C7
4M3MountingHole:MountingHole_3.2mm_M3H1, H2, H3, H4
210kResistor_SMD:R_0805_2012MetricR1, R13
21kResistor_SMD:R_0805_2012MetricR5, R10
2220Resistor_SMD:R_0805_2012MetricR7, R8
2470Resistor_SMD:R_0805_2012MetricR11, R12
1100kResistor_SMD:R_0805_2012MetricR6
110uFCapacitor_SMD:C_0805_2012MetricC5
115kResistor_SMD:R_0805_2012MetricR3
11k5Resistor_SMD:R_0805_2012MetricR2
128BYJ-48Connector_JST:JST_XH_B5B-XH-A_1x05_P2.50mm_VerticalJ6
1330Resistor_SMD:R_0805_2012MetricR14
133kResistor_SMD:R_0805_2012MetricR4
13A holdFuse:Fuse_1812_4532MetricF1
1470uF 10VCapacitor_THT:CP_Radial_D8.0mm_P3.50mmC1
15V->VMOTJumper:SolderJumper-2_P1.3mm_Open_RoundedPad1.0x1.5mmJP2
174AHCT1G125Package_TO_SOT_SMD:SOT-23-5U2
1A0 QuelleConnector_PinHeader_2.54mm:PinHeader_1x03_P2.54mm_VerticalJP1
1AO3401APackage_TO_SOT_SMD:SOT-23Q1
1BAT54SPackage_TO_SOT_SMD:SOT-23D2
1MOTOR 5VTerminalBlock_Phoenix:TerminalBlock_Phoenix_MKDS-1,5-2-5.08_1x02_P5.08mm_HorizontalJ5
1MPU6050 GY-521Connector_PinSocket_2.54mm:PinSocket_1x08_P2.54mm_VerticalJ11
1RD-03DConnector_PinHeader_2.54mm:PinHeader_1x04_P2.54mm_VerticalJ10
1REF SCHALTERConnector_PinHeader_2.54mm:PinHeader_1x02_P2.54mm_VerticalJ9
1SERVO 1 KameraConnector_PinHeader_2.54mm:PinHeader_1x03_P2.54mm_VerticalJ7
1SERVO 2 RadarConnector_PinHeader_2.54mm:PinHeader_1x03_P2.54mm_VerticalJ8
1ULN2003APackage_SO:SOIC-16_3.9x9.9mm_P1.27mmU1
1UNO AnalogConnector_PinHeader_2.54mm:PinHeader_1x06_P2.54mm_VerticalJ2
1UNO D0-D7Connector_PinHeader_2.54mm:PinHeader_1x08_P2.54mm_VerticalJ3
1UNO D8-SCLConnector_PinHeader_2.54mm:PinHeader_1x10_P2.54mm_VerticalJ4
1UNO PowerConnector_PinHeader_2.54mm:PinHeader_1x08_P2.54mm_VerticalJ1
1WS2812BConnector_PinHeader_2.54mm:PinHeader_1x03_P2.54mm_VerticalJ12
1gruenLED_SMD:LED_0805_2012MetricD1

Questions

How big is the Watchmen shield v2 PCB?

It measures 68.6 × 53.3 mm and has 2 copper layers, 1.6 mm thick.

What parts does the Watchmen shield v2 use?

44 parts, built around the 74AHCT1G125SE, RD-03D, ULN2003A and AO3401A. The full list of its parts is on this page, with links to each part's symbol and footprint where PCBKit's library has them.

Where can I download the Watchmen shield v2 KiCad files?

From the Codexzier/Watchmen repository on GitHub, at the commit this page was made from: the board is hardware/watchmen-shield-v2/watchmen-shield-v2.kicad_pcb and its schematic hardware/watchmen-shield-v2/watchmen-shield-v2.kicad_sch. PCBKit opens the board in the browser, with nothing to install.

Can I use the Watchmen shield v2 design in my own project?

Its repository publishes it under the GPL-3.0 licence: you may reuse it on that licence's terms (keep the author's notice, and for a copyleft licence share your changes alike).

Similar boards

  • 4 layers63.7 × 55 mmTX2 2.4G, the printed circuit board in 3D

    TX2 2.4G

    Momozavur/Mravka-v3

    Open the appropriate .kicadpro file in KiCad; .pro entries are legacy projects. Keep schematics, boards, local libraries, library tables, and supporting files together.

    78 parts
  • 4 layers84 × 100 mmEsp32s3-can sd logger, the printed circuit board in 3D

    Esp32s3-can sd logger

    MrBlahhhh/esp32-autosport

    A data logger you wire straight into a race car: 12 V and CAN come in on one 4-pin plug, sensor readings and CAN traffic get written to a microSD card.

    206 parts
  • 4 layers50 × 50 mmFlightController Drone, the printed circuit board in 3D

    FlightController Drone

    damnitzhemanth-oss/Flight_Controller

    Custom STM based flightcontroller designed from scratch.

    157 parts
  • 2 layers44.6 × 53.7 mmNO2C, the printed circuit board in 3D

    NO2C

    turboedge/SpeedyBoards

    EMS boards powered by Speeduino

    88 parts110GPL-2.0
  • 2 layers100 × 70 mmUPSMonitorModule, the printed circuit board in 3D

    UPSMonitorModule

    enriquewph/esp-map

    Modular hardware for IoT & home automation

    76 parts4MIT
  • 4 layers100 × 100 mmEc30-tee, the printed circuit board in 3D

    Ec30-tee

    justinpirie/ec30

    Onan EC30 Tee Board with ESP32 Control

    130 partsApache-2.0
  • 4 layers100 × 100 mmIdeal groove box, the printed circuit board in 3D

    Ideal groove box

    centrevillage/ideal-groove-box

    理想のグルーブボックスは俺たちの手で作る

    180 parts10MIT
  • 2 layers100 × 102 mmMpair, the printed circuit board in 3D

    Mpair

    marpi82/mpair

    Advanced Air Quality Monitoring Station based on ESP32's

    198 parts2