
Thermostat v3
Connicpu/thermostat
DIY Zigbee thermostat (ESP32-C6) with day/night schedule and a Home Assistant Lovelace card

Hardware design for the Eveningstar ESP32-based Morningstar MeterBus interface.
EveningStar is an open-source printed circuit board by ciaassured, from the ciaassured/eveningstar-hardware repository on GitHub, published under the AGPL-3.0 licence. It is a 2-layer board of 81.2 × 71.6 mm with 153 parts on 119 nets, routed with 1,024 tracks and 212 vias.
It is built around the ESP32-C6-WROOM-1-N8, GD5F2GM7UEYIGR and APH0630T150M, with the 74HC14D, 78L05G and W5500 among its other parts. Its parts include 56 resistors, 38 capacitors, 9 diodes, 8 ICs and 2 connectors. It belongs with the power boards and the ESP32 and RISC-V boards of this library.
This directory contains the KiCad project for the Eveningstar PCB.
The PCB should remain openable from this repository in the future, even if external KiCad libraries, plugin indexes, vendor APIs, or downloaded data sources disappear or change shape.
The rule of thumb is:
pcb/lib.flake.lock.KICAD_SYMBOL_DIR, which is set by
the Nix tooling to the flake-pinned KiCad package.If a part needs local customization, copy the symbol, footprint, or model into a project-owned library and reference that copy.
The root flake owns the lock file and imports the PCB-specific Nix module from
pcb/nix. Use the flake from the repository root.
Open a shell with the pinned KiCad version:
nix developThe dev shell includes KiCad plus the project helper scripts. Inside the shell,
the scripts are available as eveningstar-* commands.
Entering the development shell installs or updates the repo's pre-commit hook for the current clone. It can also be installed explicitly from the shell:
lefthook installGit does not automatically trust and execute hooks from cloned repositories.
Entering nix develop is the developer's explicit trust step: the shell uses
the Nix-provided Lefthook to sync .git/hooks, so Nix remains the only tooling
dependency. Lefthook then runs the same Nix-backed check suite used by CI.
Run every automated check:
nix run .#checks
# or, inside nix develop:
eveningstar-checksThe aggregate command runs all checks even if an earlier one fails, then exits non-zero if any failed. It is the entry point used by Lefthook and GitHub Actions.
The individual checks remain available for diagnosing a failure.
Run KiCad ERC and DRC, including warnings:
nix run .#drc
# or, inside nix develop:
eveningstar-drcThis writes reports/erc.rpt and reports/drc.rpt, prints both reports, and
exits non-zero if ERC or DRC reports violations.
Check for references to local, non-repo KiCad libraries or model paths:
nix run .#kicad-locality
# or, inside nix develop:
eveningstar-kicad-localityThis fails on absolute paths, KiCad third-party plugin variables, missing
repo-local 3D models, footprint library table entries outside ${KIPRJMOD}, and
symbol library table entries outside ${KIPRJMOD} or pinned KICAD_SYMBOL_DIR.
Check that every copper zone contains saved fill data on each of its layers:
nix run .#zones-filled
# or, inside nix develop:
eveningstar-zones-filledAfter any board edit that can affect copper geometry, open the board in the pinned KiCad PCB Editor, press B to refill all zones, and save before committing. Production plotting uses the fills stored in the board, so this is required even if DRC passes. The automated check detects absent saved fills; it cannot prove that existing fills are current for the latest board edits.
Check that the vendored JLCPCB subtree has not been edited directly:
nix run .#subtree-drift
# or, inside nix develop:
eveningstar-subtree-driftThis verifies pcb/lib/JLCPCB-Kicad-Library still matches the recorded subtree
squash commit and rejects uncommitted changes under that subtree.
Publish tools generate the complete artifact set for one hardware revision. They are available through Nix, but are intentionally not run by Lefthook or CI.
Generate publish artifacts for the current checkout:
nix build --max-jobs auto .#publish
# or, to also link the result at reports/publish:
nix run .#publish
# inside nix develop:
eveningstar-publishThe output is exactly the set of GitHub release assets, in one flat directory because releases hold no folders:
| File | Contents |
|---|---|
EveningStar-gerbers.zip | Gerber and drill files for JLCPCB |
EveningStar-bom.csv | JLCPCB bill of materials |
EveningStar-cpl.csv | JLCPCB component placement list |
EveningStar-netlist.ipc | IPC-D-356 netlist for electrical test |
EveningStar-schematic.pdf | every schematic sheet |
EveningStar-board.pdf | composite front and back views, then each layer |
EveningStar-step.zip | STEP model of the assembled board, for enclosure CAD |
EveningStar.glb | browser-optimized 3D model |
EveningStar-render-*.png | top, bottom, front, back, and isometric renders |
EveningStar-turntable.webp | the turntable animation |
SHA256SUMS | checksums of every other file |
Names carry no version, so releases/latest/download/<name> always links the
newest board, and the output depends only on the source rather than on the tag
it is released under. The production files are the .#production payload, which
uses the same names; the Toolkit's designators.csv is left out of both because
it only repeats the BOM. The per-sheet and per-layer SVGs are review artifacts
rather than release assets, built by nix run .#review.
nix build exposes the Nix store output through result; the command form also links that immutable output at
reports/publish. Because this is a derivation of the filtered PCB source and
pinned publishing tools, unchanged outputs are reused from the local Nix store
and can be shared through the configured Cachix cache. Release metadata and
changelog generation can be added to this same artifact contract without
changing the review workflow.
Generate only the JLCPCB production payload:
nix build .#production
# or, to also link the result at reports/production:
nix run .#production
# inside nix develop:
eveningstar-productionThe production payload contains the Gerber/drill archive, BOM, placement list,
and IPC-D-356 netlist, under the same names as the GitHub release. Its settings
pin the Fabrication Toolkit 5.3.1 JLCPCB placement translations used for V1. The
build runs DRC and schematic-parity validation, then plots the zone fills
committed in the KiCad board without refilling them. Fill and save zones in the
pinned KiCad editor after relevant design changes; plotting the reviewed stored
fills avoids nondeterministic polygon decomposition between independent KiCad
processes. Project-specific corrections live as hidden FT Rotation Offset
fields on the affected KiCad footprints; update them only after checking
component pin 1 orientation against the datasheet and assembly preview. The
Toolkit's built-in rotations match footprint names by pattern, such as
^SOT-23, and are meant for KiCad's standard footprints, so EasyEDA-named
footprints that happen to match, such as D7's
SOT-23-3_L3.0-W1.7-P0.95-LS2.9-BR, carry a 180° offset that cancels them.
Through-hole parts are placed at the centre of their pads unless FT Origin is
Anchor, which RJ2 uses because JLCPCB's model for it sits on the footprint
anchor. U1's SOT-89 counts as through-hole because its tab has plated holes, so
it needs the same. Generated timestamps, ZIP entry metadata, permissions, and
file order are normalized for reproducible builds. The Toolkit source revision
is pinned by the root flake.lock alongside KiCad and the rest of the
toolchain. KiCad provides the underlying fabrication exporters; the pinned
Toolkit is retained for its JLCPCB-specific component-origin and rotation
translations and for compatibility with the production process used for the
original board.
Production files are build artifacts and are not committed. Local output is
ignored under pcb/production and reports; published manufacturing files
belong in the GitHub release for the exact source tag that produced them. The
original as-ordered files remain available from the historical v1.0.0 tag.
To force a fresh build and have Nix compare it with the existing store output:
nix build .#production --rebuildThe aggregate is assembled from independent schematic-document, PCB-document,
plan-render, side-render, isometric-render, turntable-render, GLB, STEP, and
production derivations. Nix can schedule those components in parallel and reuse
them individually. They are also directly inspectable with commands such as
nix build .#render-plan or nix build .#model-step, without exposing
additional imperative applications.
Build the looping turntable animation used to showcase the board:
nix build --max-jobs auto .#render-turntableThat leaves the usual result symlink, which is a garbage-collection root, so
the animation is at result/EveningStar-turntable.webp. It is not committed:
.#publish carries it as EveningStar-turntable.webp, and
nix run .#release attaches it to the GitHub release, which the top-level
README.md embeds through the releases/latest/download/ alias so the link
survives future releases untouched. Print the store path with
nix build --print-out-paths if something needs to consume the output without
relying on result.
The render is a chain of derivations of the filtered PCB source and the pinned toolchain, each reused from the store, and shareable through Cachix, while its inputs are unchanged:
| Package | Produces |
|---|---|
.#board-glb | the board as fitted, as an uncompressed kicad-cli GLB |
.#turntable-frames | one PNG per frame, rendered from it by Cycles |
.#render-turntable | EveningStar-turntable.webp, encoded from the frames |
.#model-glb, the browser model in the release, is .#board-glb compressed
with gltfpack. Changing the render script re-renders the frames without
re-exporting the board, and changing the encoding re-encodes without rendering.
The board stands upright on its bottom edge, the way round it is drawn, leans 20°, and rides a turntable in front of a level, still camera, sweeping front face to edge-on sliver to back face. The lean belongs to the board rather than to the viewer, so it swings round with the spin: the component side is seen from above, the bare copper side from below half a turn later, and the board rocks from side to side through the edge-on quarters. Key, fill, and rim area lights stay put while the board turns, so shadows sweep across it as they would in a studio. The animation is 180 frames of a full revolution at a 33 ms frame delay, so it runs at 30 fps and takes just under six seconds to come round. It is encoded as an animated WebP with an alpha channel, so it sits on light and dark README backgrounds alike.
pcb/nix/scripts/turntable.py runs inside Blender. Its options are the knobs:
--tilt (20 reverses the lean), --stand to turn the board within its own
plane before it is stood up, --frames, --width, --height, --fill,
--focal-length, --samples, and --mask-colour. --only renders just the
listed frames, which is the quick way to try a change:
nix build .#board-glb
nix shell --inputs-from . nixpkgs#blender -c blender -b --factory-startup \
--python-exit-code 1 -P pcb/nix/scripts/turntable.py -- \
--model result/EveningStar.glb --output reports/turntable --only 0,45,90At a 760x720 canvas the animation lands around 4.5 MB. The WebP settings live in
the .#render-turntable derivation. Quality 65 is already low enough that the
frames are visually indistinguishable from the PNGs, and method 6 took around
forty times longer than method 4 on one core for about 4% smaller output, so the
frame count and canvas size are where the remaining bytes are.
The camera distance is solved once from the geometry, so that the widest point
of the whole revolution reaches --fill of the canvas and the board stays the
same size in every frame. Every vertex rides a circle of radius r at height z
about the spin axis. Seen from distance D, it reaches at most r / sqrt(D² − r²)
across the frame and |z| / (D − r) up or down, each scaled by the lens, so the
maximum over the vertices bounds the continuous revolution exactly, and a
bisection on D lands it on the fill.
kicad-cli gives the board layers materials of their own, on meshes named
<board>_soldermask, <board>_pad, and so on, and the script sets those to a
coated mask in --mask-colour, gold pads and vias, white silkscreen, and FR4.
Component models carry only a colour through the export, so they arrive at
glTF's defaults of fully metallic and fully rough, which renders plastic as dull
metal. These models paint bare metal in light neutral colours up to pure white:
leads, terminals, the magjack and ESP32 shields, and the electrolytic's can,
some with a blue cast. The script makes those and gold-ish ones polished metal,
and the dark and strongly coloured rest plastic. Metal needs something to
mirror, so the world behind the transparent film is a studio backdrop, bright
overhead and dark underfoot. Do-not-populate parts are left out of the export.
The frames use Blender's AgX view transform with its punchy look, which keeps
the mask a deep blue and the plastics dark under studio lights.
Cycles renders on the CPU, since the build sandbox has no GPU, at 32 samples with denoising, which came within 45 dB PSNR of 64 samples at well under two thirds of the time. One Blender process uses every core Nix grants the build; splitting the frames across several processes measured no faster. With a fixed seed the frames are reproducible: two runs on the same machine render identical pixels. On a 32-core machine the frames take about nine minutes. Blender's closure is about 3.8 GB, fetched once from the binary cache.
The render used to be done by kicad-cli pcb render, which cannot keep lights
still while the board turns. It builds its own lights fixed to the board and
ignores any in its settings, so cast shadows stayed glued to the board while its
view-following camera light, which casts none, moved the shading. Its framing
also took probe renders, since it fits each image to the canvas individually and
zooms in perspective by moving the camera.
Because the animation is hosted rather than committed, a rebuild does not disturb anything that is already published. Each release attaches the animation rendered from its own source, so the README always shows the latest released board.
Including the animation in .#publish adds about nine minutes to a
publish whenever the board has changed, more on machines with fewer cores. It is
not part of the review artifacts, so nix run .#review does not render it.
Release versions describe the hardware revision, not the volume or significance of changes to the surrounding checks, rendering, review, or publishing tools. Tooling-only changes do not normally require a hardware release.
v1.0.0 is a historical source tag and intentionally has no GitHub Release.
v1.0.1 is the first release produced with the pinned, reproducible production
and publishing pipeline.
To prepare a release, first merge all intended changes to main, refill and
save copper zones after relevant board edits, and create a Markdown release
notes file. Review the changes and choose the version based primarily on the
schematics, board, and production outputs since the previous hardware tag:
nix run .#review -- v1.0.0 main
nix run .#release -- --dry-run v1.0.1 /path/to/release-notes.mdInspect the rendered comparison and the staged assets under
reports/release/v1.0.1/. The dry run executes the complete checks and publish
build but does not create a tag or GitHub Release. When the result is ready to
publish, run:
nix run .#release -- v1.0.1 /path/to/release-notes.mdThe release command requires a clean checkout of the latest origin/main,
rejects conflicting tags or releases, runs nix run .#checks, and builds the
full publish output locally. It checks that output against its SHA256SUMS and
stages it unchanged as the release assets; then it creates and pushes an
annotated tag and creates the GitHub Release. If GitHub release creation fails after the tag is pushed, correct the
problem and rerun the same command; an existing tag is accepted only when it
identifies the same main commit.
Review tools generate artifacts for a human to inspect or compare. They are available through Nix, but are intentionally not run by Lefthook or CI.
Generate a comparison from a pull request number or URL:
nix run .#review -- 31
# equivalent explicit form:
nix run .#review -- --pr 31
# URLs also work:
nix run .#review -- https://github.com/ciaassured/eveningstar-hardware/pull/31
# or, inside nix develop:
eveningstar-review 31Compare any two locally available commits, branches, or tags by listing the destination revision first and the source revision second:
nix run .#review -- v0.2.0 v0.3.0
nix run .#review -- main feature/new-layout
nix run .#review -- 2c5bf31 96e61e4Compare a revision with the current working tree using --worktree. This
includes staged, unstaged, untracked, and deleted files, but excludes files
ignored by Git:
nix run .#review -- main --worktree
# HEAD is the default destination revision:
nix run .#review -- --worktreeFor pull requests, the command resolves the exact source and destination
commits recorded by GitHub without changing or depending on the checkout. Git
revision comparisons archive the exact requested trees, while worktree
comparisons create an isolated temporary snapshot without switching branches or
modifying local files. Nix realizes the same publish derivation for either form.
Cached artifact sets are reused, then linked under
reports/review and compared through their browser-viewable SVG, PNG, and GLB
outputs. It serves the comparison on an ephemeral 127.0.0.1 port and prints
the URL; press Ctrl+C when the review is finished.
It also opens the URL in the default browser when a desktop opener is available;
the foreground server exits when interrupted and does not remain orphaned.
The view picker covers native vector schematic and board views, deterministic
KiCad 3D renders, and the interactive Three.js board model. Every view supports
overlay/reveal, side-by-side, pixel-difference, and highlighted-change modes.
Documents can be panned and zoomed without rasterizing SVGs; side-by-side
navigation can optionally be synchronized. Use ← and → to
change view, ↑ and ↓ to change comparison mode, and
[ and ] to move through the current view's pages, layers,
images, or presets. Pull-request comparisons use gh for metadata and Git to
fetch missing commit objects; both are provided by Nix.
Generate the report without starting the local server:
nix run .#review -- --no-serve 31
nix run .#review -- --no-serve main --worktreeBecause the review tool comes from the current checkout while the hardware inputs come from the requested snapshots, a feature branch can test changes to the review tooling against an existing PR or pair of revisions.
Artifacts are written under reports/.
Pull requests to main run .github/workflows/checks.yml.
The workflow:
nix run .#checks, the same aggregate command used by Lefthook.The aggregate command attempts every check, so a failure in an earlier check does not prevent ERC/DRC reports from being generated and uploaded.
Vendored and project-owned libraries live under pcb/lib.
pcb/lib/
custom/
custom_symbols.kicad_sym
EasyEDA/
EasyEDA.kicad_sym
EasyEDA.pretty/
EasyEDA.3dshapes/
JLCPCB-Kicad-Library/
symbols/
footprints/
3dmodels/The KiCad library nicknames are kept stable in sym-lib-table and
fp-lib-table, so schematic references like EasyEDA:...,
custom_symbols:..., and PCM_JLCPCB:... remain readable.
This board has used external KiCad plugins and data sources during development:
Those tools are useful if you are actively adding or updating parts, generating fabrication outputs, or syncing vendor metadata. Someone working on the board will probably want them installed in their interactive KiCad setup.
They should not be required just to open, check, or review the project. Any symbols, footprints, or 3D models required by the board should be present in this repository, and KiCad itself should be obtained through Nix.
When adding a part from a plugin or external source:
pcb/lib.${KIPRJMOD}/lib/..., not through
${KICAD*_3RD_PARTY}, absolute paths, or plugin cache paths.nix run .#checks.For the vendored JLCPCB subtree, do not edit files in
pcb/lib/JLCPCB-Kicad-Library directly. Update the subtree as a subtree, or
copy the asset into a project-owned library before customizing it.
| Qty | Value | Footprint | References |
|---|---|---|---|
| 18 | 10kΩ | PCM_JLCPCB:R_0603 | R6, R10, R13, R17, R20, R21, R24, R39, R40, R41, R52, R57, R58, R59, R60, R61 +2 |
| 16 | 100nF | PCM_JLCPCB:C_0603 | C2, C3, C5, C6, C7, C13, C16, C20, C22, C24, C26, C27, C28, C30, C35, C41 |
| 13 | 33Ω | PCM_JLCPCB:R_0603 | R8, R33, R34, R35, R36, R37, R50, R51, R55, R62, R63, R64, R65 |
| 4 | 0Ω | PCM_JLCPCB:R_0603 | R7, R12, R25, R32 |
| 4 | 10uF | PCM_JLCPCB:C_0603 | C4, C19, C33, C40 |
| 4 | 49.9Ω | PCM_JLCPCB:R_0603 | R38, R42, R43, R44 |
| 4 | MountingHole | EasyEDA:JLC_PCBA_Tooling_Mount | H1, H2, H3, H4 |
| 3 | 47uF | PCM_JLCPCB:C_1206 | C9, C10, C15 |
| 3 | GND | custom:TestPoint_Plated_Hole_D2.0mm | TP19, TP31, TP32 |
| 3 | MOSI | custom:TestPoint_Pad_D1.0mm | TP17, TP23, TP34 |
| 2 | 100kΩ | PCM_JLCPCB:R_0603 | R2, R11 |
| 2 | 10nF | PCM_JLCPCB:C_0603 | C23, C29 |
| 2 | 18pF | PCM_JLCPCB:C_0603 | C17, C18 |
| 2 | 1MΩ | PCM_JLCPCB:R_0603 | R3, R31 |
| 2 | 20pF | PCM_JLCPCB:C_0603 | C11, C12 |
| 2 | 330Ω | PCM_JLCPCB:R_0603 | R46, R47 |
| 2 | 5.1kΩ | PCM_JLCPCB:R_0603 | R18, R19 |
| 2 | 6.8nF | PCM_JLCPCB:C_0603 | C31, C32 |
| 2 | 62kΩ | PCM_JLCPCB:R_0603 | R15, R26 |
| 2 | MISO | custom:TestPoint_Pad_D1.0mm | TP16, TP20 |
| 2 | SS210 | PCM_JLCPCB:D_SMA | D5, D15 |
| 1 | +3V3A | custom:TestPoint_Pad_D1.0mm | TP35 |
| 1 | 1.8kΩ | PCM_JLCPCB:R_0603 | R1 |
| 1 | 100nF | PCM_JLCPCB:C_0805 | C14 |
| 1 | 100Ω | PCM_JLCPCB:R_0603 | R14 |
| 1 | 10MΩ | PCM_JLCPCB:R_0603 | R23 |
| 1 | 10uF | PCM_JLCPCB:C_1206 | C1 |
| 1 | 10Ω | PCM_JLCPCB:R_0603 | R45 |
| 1 | 15uH | EasyEDA:IND-SMD_L7.1-W6.6 | U11 |
| 1 | 1A | EasyEDA:FUSE-SMD_L6.1-W2.6 | F1 |
| 1 | 1nF | PCM_JLCPCB:C_1206 | C21 |
| 1 | 2.4kΩ | PCM_JLCPCB:R_0603 | R4 |
| 1 | 220Ω | PCM_JLCPCB:R_0603 | R22 |
| 1 | 22nF | PCM_JLCPCB:C_0603 | C34 |
| 1 | 22uF | PCM_JLCPCB:C_0603 | C8 |
| 1 | 22uF 160V | EasyEDA:CAP-SMD_BD10.0-L10.3-W10.3-FD | C36 |
| 1 | 25MHz | EasyEDA:OSC-SMD_4P-L3.2-W2.5-BL | Y1 |
| 1 | 27kΩ | PCM_JLCPCB:R_0603 | R16 |
| 1 | 2N7002 | PCM_JLCPCB:Q_SOT-23 | Q1 |
| 1 | 32.768kHz | custom:FC-135R_L3.2-W1.5 | X1 |
| 1 | 4.7uF | PCM_JLCPCB:C_0603 | C25 |
| 1 | 5201-6P6C | custom:RJ45-TH_RRCH-5201-6P6C | RJ2 |
| 1 | 74HC14D | PCM_JLCPCB:SOIC-14_L8.7-W3.9-P1.27-LS6.0-BL | U5 |
| 1 | 78L05G | custom:SOT-89-3_L4.5-W2.5-P1.50-LS4.2-BR | U1 |
| 1 | BAT | custom:TestPoint_Plated_Hole_D2.0mm | TP26 |
| 1 | BLM18PG121SN1D_C14709 | EasyEDA:L0603 | L2 |
| 1 | BUS | custom:TestPoint_Pad_D1.0mm | TP22 |
| 1 | DEBUG | custom:PinHeader_2x03_P2.54mm_Vertical | J2 |
| 1 | ESP32-C6-WROOM-1-N8 | EasyEDA:WIRELM-SMD_ESP32-C6-WROOM-1 | U7 |
| 1 | ETH_CS | custom:TestPoint_Pad_D1.0mm | TP10 |
| 1 | ETH_INT | custom:TestPoint_Pad_D1.0mm | TP18 |
| 1 | ETH_RST | custom:TestPoint_Pad_D1.0mm | TP11 |
| 1 | ETH_SCK | custom:TestPoint_Pad_D1.0mm | TP14 |
| 1 | FLASH_CS | custom:TestPoint_Pad_D1.0mm | TP15 |
| 1 | FLASH_SCK | custom:TestPoint_Pad_D1.0mm | TP33 |
| 1 | GD5F2GM7UEYIGR | EasyEDA:WSON-8_L8.0-W6.0-P1.27-TL-1 | U8 |
| 1 | GND_ISO | custom:TestPoint_Plated_Hole_D2.0mm | TP25 |
| 1 | GR01M1HXA001 | EasyEDA:RJ45-TH_GR01M1HXA001 | RJ1 |
| 1 | GT-USB-7055BB | EasyEDA:USB-C-TH_GT-USB-7055BB | USB1 |
| 1 | ISO6721RBDR | EasyEDA:SOP-8_L4.9-W3.9-P1.27-LS6.0-BL_ISO6721RBDR | U3 |
| 1 | LMR38020SDDAR | EasyEDA:ESOP-8_L4.9-W3.9-P1.27-LS6.0-BL-EP-1 | U6 |
| 1 | LOGO | LOGO | G*** |
| 1 | NetTie_3_Tee | custom:NetTie-3_SMD_Pad0.5mm | NT3 |
| 1 | NetTie_3_Tee | custom:NetTie-3_SMD_Pad0.5mm_Stock | NT2 |
| 1 | PSM712-LF-T7 | PCM_JLCPCB:SOT-23-3_L3.0-W1.7-P0.95-LS2.9-BR | D7 |
| 1 | READ | custom:TestPoint_Pad_D1.0mm | TP28 |
| 1 | RX | PCM_JLCPCB:D_0805 | D6 |
| 1 | RX_ISO | custom:TestPoint_Pad_D1.0mm | TP24 |
| 1 | SMBJ17CA | EasyEDA:SMB_L4.3-W3.6-LS5.4-BI | D3 |
| 1 | SMBJ40CA_C151262 | EasyEDA:SMB_L4.6-W3.6-LS5.3-BI | D2 |
| 1 | TX | PCM_JLCPCB:D_0805 | D4 |
| 1 | TX_ISO | custom:TestPoint_Pad_D1.0mm | TP27 |
| 1 | Tactile Button, 160gf | PCM_JLCPCB:SW_TS-1088-AR02016 | S1 |
| 1 | USBLC6-2P6 | EasyEDA:SOT-666-6_L1.6-W1.2-P0.50-LS1.6-BR | D1 |
| 1 | VCC_ISO | custom:TestPoint_Pad_D1.0mm | TP21 |
| 1 | VIN_PROTECTED | custom:TestPoint_Plated_Hole_D2.0mm | TP36 |
| 1 | W5500 | custom:LQFP-48_7x7mm_P0.5mm | U9 |
| 1 | WJ15EDGRC-3.81-2P | custom:CONN-TH_2P-P3.81_WJ15EDGRC-3.81-2P_CLIPPED | P1 |
| 1 | WRITE | custom:TestPoint_Pad_D1.0mm | TP29 |
| 1 | White | PCM_JLCPCB:D_0805 | D12 |

Connicpu/thermostat
DIY Zigbee thermostat (ESP32-C6) with day/night schedule and a Home Assistant Lovelace card

alexanderjg85/simple_pic12_pdip8_universal_devboard
A simple development board with an LED and GPIOs on Pin headers. includes an ICSP Header and selectable dual power supply with a screw terminal

EOSCogniton/ELIZ-2022
Le Git Artemiz de l'EPSA. Contient le Catia, ainsi que la documentation en cours et quelques modèles.

AndreiVladescu/LibrePLC32
The goal of the project is to create a compact, hackable, and well-documented PLC platform for industrial automation experiments, prototyping, education, and open hardware development.

DerRKDCB/meshphone
meshtastic Samsung Galaxy A5 standalone offline dual node

ahdrage/leafy
DIY Wi-Fi climate-control prototype for Nissan Leaf: KiCad PCB, ESP32-C3 firmware, Blender enclosure and build notes. Inspired by OVMS.

Atif6894/automotive-ble-can-pcb
A small 4-layer board that sits on a vehicle's 12/24 V harness, talks CAN FD through a TCAN4550-Q1, and exposes it over Bluetooth LE through a CC2340R5-Q1.

ISS-Lab-Unibo/Agro_LoRaInductiveFruitGauge
An open-source, low-cost and low-power LoRaWAN sensor node for continuous, non-destructive monitoring of fruit growth directly on the tree, together with the high-resolution inductive fruit gauges (pliers) it reads.
It measures 81.2 × 71.6 mm and has 2 copper layers, 1.6 mm thick.
153 parts, built around the ESP32-C6-WROOM-1-N8, GD5F2GM7UEYIGR, APH0630T150M and 74HC14D. 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.
From the ciaassured/eveningstar-hardware repository on GitHub, at the commit this page was made from: the board is pcb/EveningStar.kicad_pcb and its schematic pcb/EveningStar.kicad_sch. PCBKit opens the board in the browser, with nothing to install.
Its repository publishes it under the AGPL-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).