Mek core ctrl

Home Automation Electronics

This repository contains the electronics, embedded firmware, support software, and reference material for a collection of home-automation and workshop projects. Hardware designs are primarily created with KiCad, firmware targets Raspberry Pi Pico/Pico W and MicroPython-compatible boards, and the host-side controller tools are written in .NET, C++, and Python.

Repository layout

.
├── firmware/              Embedded C/C++, Arduino, and MicroPython projects
├── hardware/              KiCad projects, libraries, footprints, and 3D models
├── software/              Desktop, command-line, monitoring, and test tools
├── irrigation_wiring.txt  Irrigation wiring notes
└── README.md              Repository overview

Generated build output, IDE state, KiCad backup/session files, and caches are excluded by .gitignore.

Hardware projects

Each board directory contains its KiCad project (.kicad_pro), schematic (.kicad_sch), and PCB layout (.kicad_pcb) where applicable. Some projects also include manufacturing Gerber archives or exported 3D models.

Shared hardware resources include:

• hardware/kicad/ — the canonical KiCad resource tree, containing symbols, footprints, Python modules, and action plugins.
• hardware/fusion360_modules/ — Fusion 360 helper scripts.
• hardware/pcb-checklist.xlsx — PCB design/review checklist.

Open a hardware project by loading its .kicad_pro file in KiCad. Keep the repository layout intact so that relative library and 3D-model references continue to resolve.

Generating JLCPCB production files

Use hardware/kicad/modules/generate_jlcpcb.py to generate the fabrication and assembly files for a board. Run it from the repository root and pass the name of the project under hardware/. For example, to generate the LED controller:

python3 hardware/kicad/modules/generate_jlcpcb.py led_controller

The project argument selects which board is generated; it is not hard-coded in the script. A full project directory, .kicad_pro file, or .kicad_pcb file can also be supplied, for example hardware/led_controller/led_controller.kicad_pro.

The script requires KiCad 7 or newer. It automatically finds a native kicad-cli executable or the org.kicad.KiCad Flatpak. For another installation, provide the executable explicitly:

python3 hardware/kicad/modules/generate_jlcpcb.py \
  --kicad-cli /path/to/kicad-cli led_controller

Files are written to a gerber/ directory beside the board. For a project named led_controller, the upload files are:

The Gerber ZIP is generated automatically. Do not add the BOM and CPL to that ZIP: JLCPCB expects the fabrication ZIP, BOM, and CPL as three separate uploads when ordering assembled boards. For a bare PCB order, only the Gerber ZIP is required.

The generator uses these JLCPCB-compatible export settings:

• One Gerber file per enabled copper layer, including all inner copper layers.
• Front and back solder mask, silkscreen, and paste layers, plus Edge.Cuts.
• KiCad's Protel-style Gerber extensions and Gerber X2/netlist attributes.
• Excellon drill format in millimetres, with plated and non-plated holes in the KiCad default combined drill output.
• CPL output in millimetres for both board sides, using the board's absolute origin. KiCad's columns are converted to Designator, Mid X, Mid Y, Rotation, and Layer, with the sides written as Top and Bottom.
• BOM columns Comment, Designator, Footprint, and LCSC Part #. Identical parts are grouped, and symbols without an LCSC Part # are omitted.

Always inspect the uploaded board preview, part matches, placement rotations, and board side in JLCPCB before submitting an order. Component-specific rotation corrections are not applied automatically by this script.

Firmware projects

Raspberry Pi Pico SDK

The root firmware/CMakeLists.txt configures a Pico W build using CMake and the Raspberry Pi Pico SDK. It currently includes these targets:

Reusable Pico code lives in firmware/common/ and covers communication, memory management, PIO, RTC, flash storage, CRC, I2C, inter-core synchronization, and general utilities.

To configure and build the Pico SDK targets:

export PICO_SDK_PATH=/path/to/pico-sdk
cmake -S firmware -B firmware/build
cmake --build firmware/build

The project requires Pico SDK 1.3.0 or later and uses C11 and C++17.

MicroPython and Python device firmware

Device-specific config.py files hold each firmware project's configuration. Review these before deploying to a board and avoid committing private credentials.

Arduino projects

Development and protocol tools

• firmware/bluetooth_test/ contains Python Bluetooth client and server test programs.
• firmware/rp2040_registers.docx is an RP2040 register reference.
• firmware/common/communication/ defines the device communication and message protocol shared by firmware components.

Support software

.NET controller tools

software/Controller/Controller.sln is a Visual Studio/.NET 6 solution containing:

Build the solution with:

dotnet build software/Controller/Controller.sln

Other tools

• software/CodeTestHarness/ is a Visual C++ test harness for native code experiments.
• software/mmwave_sensor/ is a Python serial/data-analysis utility using pyserial and numpy.

Install the Python utility dependencies with:

python -m pip install -r software/mmwave_sensor/requirements.txt

Reference material

• irrigation_wiring.txt documents irrigation-system wiring.
• Project-specific VS Code configuration and workspace files are retained where they provide useful build, debugging, or MicroPython tooling settings.
• Fabrication ZIP, Gerber, drill, and CNC files are retained where they represent deliberate manufacturing outputs; automatic KiCad backups, local history, lock files, and session state are ignored.

Working in this repository

• Preserve the existing directory structure because firmware, KiCad libraries, and 3D models may use relative paths.
• Do not commit generated build, bin, obj, cache, or automatic backup directories.
• Review hardware changes with hardware/pcb-checklist.xlsx before ordering boards.
• Treat device configuration and application settings as potentially environment-specific and check them for secrets before committing.