@hybridlabor-api/bdb-hardware-pcb 0.1.0

package/mcp_servers/kicad-mcp-server/src/kicad_mcp_server/server.py

@@ -0,0 +1,71 @@
+"""Main MCP server setup for KiCad integration."""
+
+from fastmcp import FastMCP
+
+from .config import config
+
+# Create MCP server
+mcp = FastMCP(
+    name="kicad-mcp-server",
+    instructions="""KiCad MCP Server - A server for analyzing KiCad schematics and PCBs,
+    and performing design rule checks.
+
+    Available capabilities:
+    - Schematic analysis (components, nets, symbols)
+    - PCB analysis (footprints, tracks, statistics)
+    - Design rule checking (ERC/DRC)
+    - Schematic summarization
+    - Hierarchical sheet and net tracing
+    - Pin/power/bus extraction and device tree generation
+    """,
+)
+
+
+# Import and register tools
+from .tools import (  # noqa: F401, E402
+    device_tree,
+    hierarchical_analysis,
+    netlist,
+    parts_registry,
+    pcb,
+    pcb_layout,
+    pin_analysis,
+    project,
+    schematic,
+    schematic_editor,
+    schematic_search,
+    validation,
+    visualization,
+)
+
+
+# Resources
+@mcp.resource("kicad://config")
+def get_config() -> dict:
+    """Get current server configuration."""
+    return {
+        "project_paths": config.kicad_project_paths,
+        "default_summary_detail_level": config.default_summary_detail_level,
+        "include_nets_in_summary": config.include_nets_in_summary,
+        "include_power_in_summary": config.include_power_in_summary,
+        "default_test_framework": config.default_test_framework,
+        "default_test_type": config.default_test_type,
+    }
+
+
+def create_server() -> FastMCP:
+    """Create and configure the MCP server instance.
+
+    Returns:
+        Configured FastMCP server instance
+    """
+    return mcp
+
+
+def get_server() -> FastMCP:
+    """Get the singleton MCP server instance.
+
+    Returns:
+        The FastMCP server instance
+    """
+    return mcp

package/mcp_servers/kicad-mcp-server/src/kicad_mcp_server/templates/__init__.py

@@ -0,0 +1 @@
+"""Jinja2 templates for test code generation."""

package/mcp_servers/kicad-mcp-server/src/kicad_mcp_server/templates/arduino/connectivity_test.cpp.j2

@@ -0,0 +1,189 @@
+/**
+ * Arduino Connectivity Test for {{ project_name }}
+ * Generated from {{ schematic_path }}
+ *
+ * This sketch provides automated connectivity verification for
+ * Arduino-based projects based on schematic netlist.
+ */
+
+#include <Arduino.h>
+
+{% if target_mcu and target_mcu.startswith("esp") %}
+// ESP32/ESP8266 specific
+{% if target_mcu == "esp32" %}
+#include <WiFi.h>
+{% else %}
+#include <ESP8266WiFi.h>
+{% endif %}
+{% endif %}
+
+// Pin definitions from schematic
+{% for pin in test_pins %}
+#define {{ pin.name }} {{ pin.number }}
+{% endfor %}
+
+// Test configuration
+const unsigned long SERIAL_BAUD = 115200;
+const int TEST_DELAY_MS = 100;
+
+// Test point structure
+struct TestPoint {
+    const char* name;
+    int pin;
+    bool is_input;
+    bool expected_state;
+};
+
+// Test points based on schematic
+TestPoint test_points[] = {
+{% for test in tests %}
+    { "{{ test.name }}", {{ test.pin }}, {{ test.is_input | lower }}, {{ test.expected | lower }} },
+{% endfor %}
+};
+
+const int num_test_points = sizeof(test_points) / sizeof(TestPoint);
+
+void setup() {
+    // Initialize serial
+    Serial.begin(SERIAL_BAUD);
+    while (!Serial && millis() < 3000); {% if target_mcu and target_mcu.startswith("esp") %}{% else %} // Wait for serial (Leonardo, Zero){% endif %}
+
+    delay(1000);
+    Serial.println(F("{{ project_name }} - Connectivity Test"));
+    Serial.println(F("=" * 50));
+
+    // Initialize pins
+    Serial.println(F("Initializing test pins..."));
+    for (int i = 0; i < num_test_points; i++) {
+        if (test_points[i].is_input) {
+            pinMode(test_points[i].pin, INPUT_PULLUP);
+        } else {
+            pinMode(test_points[i].pin, OUTPUT);
+            digitalWrite(test_points[i].pin, test_points[i].expected_state ? HIGH : LOW);
+        }
+    }
+
+    Serial.println(F("Pins initialized"));
+    Serial.println();
+}
+
+void loop() {
+    static int test_count = 0;
+
+    Serial.println(F("Running connectivity tests..."));
+    Serial.println();
+
+    int passed = 0;
+    int failed = 0;
+
+    // Run tests
+    for (int i = 0; i < num_test_points; i++) {
+        TestPoint& tp = test_points[i];
+
+        if (tp.is_input) {
+            int reading = digitalRead(tp.pin);
+
+            Serial.print(F("Test: "));
+            Serial.print(tp.name);
+            Serial.print(F(" (Pin "));
+            Serial.print(tp.pin);
+            Serial.print(F(")... "));
+
+            // For pull-up inputs, expect HIGH unless externally pulled low
+            bool test_passed = (reading == tp.expected_state);
+
+            if (test_passed) {
+                Serial.println(F("PASS"));
+                passed++;
+            } else {
+                Serial.print(F("FAIL (expected "));
+                Serial.print(tp.expected_state ? F("HIGH") : F("LOW"));
+                Serial.print(F(", got "));
+                Serial.print(reading ? F("HIGH") : F("LOW"));
+                Serial.println(F(")"));
+                failed++;
+            }
+
+            delay(TEST_DELAY_MS);
+        }
+    }
+
+    // Print summary
+    Serial.println();
+    Serial.println(F("=" * 50));
+    Serial.print(F("Test Summary: "));
+    Serial.print(passed);
+    Serial.print(F(" passed, "));
+    Serial.print(failed);
+    Serial.print(F(" failed out of "));
+    Serial.print(num_test_points);
+    Serial.println(F(" tests"));
+
+    if (failed == 0) {
+        Serial.println(F("All tests PASSED!"));
+    } else {
+        Serial.println(F("Some tests FAILED!"));
+    }
+
+    Serial.println();
+    Serial.println(F("Press any key to run tests again..."));
+
+    // Wait for user input
+    while (!Serial.available()) {
+        delay(100);
+    }
+
+    // Clear serial buffer
+    while (Serial.available()) {
+        Serial.read();
+    }
+
+    test_count++;
+    Serial.println();
+    delay(1000);
+}
+
+{% if test_type == "functional" %}
+/**
+ * Additional functional tests
+ */
+void test_analog_inputs() {
+    Serial.println(F("Testing analog inputs..."));
+
+    // Read analog pins and report values
+    {% for pin in analog_pins %}
+    {
+        int raw = analogRead({{ pin }});
+        float voltage = raw * (3.3 / 4095.0); {% if target_mcu and "esp32" in target_mcu %}
+        Serial.print(F("{{ pin }}: "));
+        Serial.print(raw);
+        Serial.print(F(" ("));
+        Serial.print(voltage);
+        Serial.println(F("V)"));
+        delay(TEST_DELAY_MS);
+    }
+    {% endif %}
+
+    Serial.println();
+}
+
+void test_i2c_scan() {
+    Serial.println(F("Scanning I2C bus..."));
+
+    Wire.begin();
+
+    for (byte addr = 1; addr < 127; addr++) {
+        Wire.beginTransmission(addr);
+        byte error = Wire.endTransmission();
+
+        if (error == 0) {
+            Serial.print(F("I2C device found at 0x"));
+            if (addr < 16) Serial.print(F("0"));
+            Serial.println(addr, HEX);
+        }
+    }
+
+    Serial.println(F("I2C scan complete"));
+    Serial.println();
+}
+{% endif %}

package/mcp_servers/kicad-mcp-server/src/kicad_mcp_server/templates/device_tree/atmega.dts.j2

@@ -0,0 +1,77 @@
+/* Device Tree for ATmega SOC */
+/* Auto-generated from KiCad schematic */
+/* Generated by: kicad-mcp-server */
+
+#include <dt-bindings/gpio/gpio.h>
+
+/ {
+  model = "{{ board_name }}";
+  compatible = "atmel,atmega";
+
+  /* GPIO Configuration */
+  pinctrl: pin-controller {
+    {% for pin in gpio_pins %}
+    gpio_{{ pin.number }}: gpio@{{ pin.number }} {
+      gpio-controller;
+      #gpio-cells = <2>;
+      status = "okay";
+    };
+    {% endfor %}
+  };
+
+  /* I2C Devices (TWI) */
+  {% for bus in i2c_buses %}
+  twi{{ bus.number }}: i2c@{{ bus.address }} {
+    compatible = "atmel,atmega-twi";
+    #address-cells = <1>;
+    #size-cells = <0>;
+    status = "okay";
+    clock-frequency = <100000>;
+
+    {% for device in bus.devices %}
+    {{ device.name }}: {{ device.compatible }}@{{ device.address }} {
+      compatible = "{{ device.compatible }}";
+      reg = <{{ device.address }}>;
+      {% if device.properties %}
+      {% for key, value in device.properties.items() %}
+      {{ key }} = <{{ value }}>;
+      {% endfor %}
+      {% endif %}
+    };
+    {% endfor %}
+  };
+
+  {% endfor %}
+
+  /* SPI Devices */
+  {% for bus in spi_buses %}
+  spi{{ bus.number }}: spi@{{ bus.address }} {
+    compatible = "atmel,atmega-spi";
+    #address-cells = <1>;
+    #size-cells = <0>;
+    status = "okay";
+
+    {% for device in bus.devices %}
+    {{ device.name }}: {{ device.compatible }}@{{ device.cs }} {
+      compatible = "{{ device.compatible }}";
+      reg = <{{ device.cs }}>;
+      spi-max-frequency = <{{ device.frequency }}>;
+      {% if device.properties %}
+      {% for key, value in device.properties.items() %}
+      {{ key }} = <{{ value }}>;
+      {% endfor %}
+      {% endif %}
+    };
+    {% endfor %}
+  };
+
+  {% endfor %}
+
+  /* UART Devices */
+  {% for uart in uarts %}
+  usart{{ uart.number }}: serial@{{ uart.address }} {
+    compatible = "atmel,atmega-usart";
+    status = "okay";
+  };
+  {% endfor %}
+};

package/mcp_servers/kicad-mcp-server/src/kicad_mcp_server/templates/device_tree/esp32.dts.j2

@@ -0,0 +1,77 @@
+/* Device Tree for ESP32 SOC */
+/* Auto-generated from KiCad schematic */
+/* Generated by: kicad-mcp-server */
+
+#include <dt-bindings/gpio/gpio.h>
+
+/ {
+  model = "{{ board_name }}";
+  compatible = "espressif,esp32";
+
+  /* GPIO Configuration */
+  pinctrl: pin-controller {
+    {% for pin in gpio_pins %}
+    gpio_{{ pin.number }}: gpio@{{ pin.number }} {
+      gpio-controller;
+      #gpio-cells = <2>;
+      status = "okay";
+    };
+    {% endfor %}
+  };
+
+  /* I2C Devices */
+  {% for bus in i2c_buses %}
+  i2c{{ bus.number }}: i2c@{{ bus.address }} {
+    compatible = "espressif,esp32-i2c";
+    #address-cells = <1>;
+    #size-cells = <0>;
+    status = "okay";
+    clock-frequency = <100000>;
+
+    {% for device in bus.devices %}
+    {{ device.name }}: {{ device.compatible }}@{{ device.address }} {
+      compatible = "{{ device.compatible }}";
+      reg = <{{ device.address }}>;
+      {% if device.properties %}
+      {% for key, value in device.properties.items() %}
+      {{ key }} = <{{ value }}>;
+      {% endfor %}
+      {% endif %}
+    };
+    {% endfor %}
+  };
+
+  {% endfor %}
+
+  /* SPI Devices */
+  {% for bus in spi_buses %}
+  spi{{ bus.number }}: spi@{{ bus.address }} {
+    compatible = "espressif,esp32-spi";
+    #address-cells = <1>;
+    #size-cells = <0>;
+    status = "okay";
+
+    {% for device in bus.devices %}
+    {{ device.name }}: {{ device.compatible }}@{{ device.cs }} {
+      compatible = "{{ device.compatible }}";
+      reg = <{{ device.cs }}>;
+      spi-max-frequency = <{{ device.frequency }}>;
+      {% if device.properties %}
+      {% for key, value in device.properties.items() %}
+      {{ key }} = <{{ value }}>;
+      {% endfor %}
+      {% endif %}
+    };
+    {% endfor %}
+  };
+
+  {% endfor %}
+
+  /* UART Devices */
+  {% for uart in uarts %}
+  uart{{ uart.number }}: serial@{{ uart.address }} {
+    compatible = "espressif,esp32-uart";
+    status = "okay";
+  };
+  {% endfor %}
+};

package/mcp_servers/kicad-mcp-server/src/kicad_mcp_server/templates/device_tree/nrf52.dts.j2

@@ -0,0 +1,77 @@
+/* Device Tree for nRF52 SOC */
+/* Auto-generated from KiCad schematic */
+/* Generated by: kicad-mcp-server */
+
+#include <dt-bindings/gpio/gpio.h>
+
+/ {
+  model = "{{ board_name }}";
+  compatible = "nordic,nrf52";
+
+  /* GPIO Configuration */
+  pinctrl: pin-controller {
+    {% for pin in gpio_pins %}
+    gpio_{{ pin.number }}: gpio@{{ pin.number }} {
+      gpio-controller;
+      #gpio-cells = <2>;
+      status = "okay";
+    };
+    {% endfor %}
+  };
+
+  /* I2C Devices (TWI) */
+  {% for bus in i2c_buses %}
+  twi{{ bus.number }}: i2c@{{ bus.address }} {
+    compatible = "nordic,nrf52-twi";
+    #address-cells = <1>;
+    #size-cells = <0>;
+    status = "okay";
+    clock-frequency = <100000>;
+
+    {% for device in bus.devices %}
+    {{ device.name }}: {{ device.compatible }}@{{ device.address }} {
+      compatible = "{{ device.compatible }}";
+      reg = <{{ device.address }}>;
+      {% if device.properties %}
+      {% for key, value in device.properties.items() %}
+      {{ key }} = <{{ value }}>;
+      {% endfor %}
+      {% endif %}
+    };
+    {% endfor %}
+  };
+
+  {% endfor %}
+
+  /* SPI Devices */
+  {% for bus in spi_buses %}
+  spi{{ bus.number }}: spi@{{ bus.address }} {
+    compatible = "nordic,nrf52-spi";
+    #address-cells = <1>;
+    #size-cells = <0>;
+    status = "okay";
+
+    {% for device in bus.devices %}
+    {{ device.name }}: {{ device.compatible }}@{{ device.cs }} {
+      compatible = "{{ device.compatible }}";
+      reg = <{{ device.cs }}>;
+      spi-max-frequency = <{{ device.frequency }}>;
+      {% if device.properties %}
+      {% for key, value in device.properties.items() %}
+      {{ key }} = <{{ value }}>;
+      {% endfor %}
+      {% endif %}
+    };
+    {% endfor %}
+  };
+
+  {% endfor %}
+
+  /* UART Devices */
+  {% for uart in uarts %}
+  uart{{ uart.number }}: serial@{{ uart.address }} {
+    compatible = "nordic,nrf52-uarte";
+    status = "okay";
+  };
+  {% endfor %}
+};

package/mcp_servers/kicad-mcp-server/src/kicad_mcp_server/templates/device_tree/stm32f4.dts.j2

@@ -0,0 +1,89 @@
+/* Device Tree for STM32F4 SOC */
+/* Auto-generated from KiCad schematic */
+/* Generated by: kicad-mcp-server */
+
+#include <dt-bindings/gpio/gpio.h>
+#include <dt-bindings/pinctrl/stm32-pinctrl.h>
+
+/ {
+  model = "{{ board_name }}";
+  compatible = "st,stm32f4";
+
+  /* GPIO Configuration */
+  pinctrl: pin-controller {
+    {% for pin in gpio_pins %}
+    gpio_{{ pin.name }}: gpio@{{ pin.number }} {
+      gpio-controller;
+      #gpio-cells = <2>;
+      status = "okay";
+    };
+    {% endfor %}
+  };
+
+  /* I2C Devices */
+  {% for bus in i2c_buses %}
+  i2c{{ bus.number }}: i2c@{{ bus.address }} {
+    compatible = "st,stm32-i2c";
+    #address-cells = <1>;
+    #size-cells = <0>;
+    status = "okay";
+    clock-frequency = <100000>;
+
+    {% for device in bus.devices %}
+    {{ device.name }}: {{ device.compatible }}@{{ device.address }} {
+      compatible = "{{ device.compatible }}";
+      reg = <{{ device.address }}>;
+      {% if device.properties %}
+      {% for key, value in device.properties.items() %}
+      {{ key }} = <{{ value }}>;
+      {% endfor %}
+      {% endif %}
+    };
+    {% endfor %}
+  };
+
+  {% endfor %}
+
+  /* SPI Devices */
+  {% for bus in spi_buses %}
+  spi{{ bus.number }}: spi@{{ bus.address }} {
+    compatible = "st,stm32-spi";
+    #address-cells = <1>;
+    #size-cells = <0>;
+    status = "okay";
+    cs-gpios = <0>;
+
+    {% for device in bus.devices %}
+    {{ device.name }}: {{ device.compatible }}@{{ device.cs }} {
+      compatible = "{{ device.compatible }}";
+      reg = <{{ device.cs }}>;
+      spi-max-frequency = <{{ device.frequency }}>;
+      {% if device.properties %}
+      {% for key, value in device.properties.items() %}
+      {{ key }} = <{{ value }}>;
+      {% endfor %}
+      {% endif %}
+    };
+    {% endfor %}
+  };
+
+  {% endfor %}
+
+  /* UART Devices */
+  {% for uart in uarts %}
+  usart{{ uart.number }}: serial@{{ uart.address }} {
+    compatible = "st,stm32-usart";
+    status = "okay";
+  };
+  {% endfor %}
+
+  /* Power Domains */
+  {% for regulator in regulators %}
+  {{ regulator.name }}: regulator@{{ regulator.address }} {
+    compatible = "regulator-fixed";
+    regulator-name = "{{ regulator.name }}";
+    regulator-min-microvolt = <{{ regulator.min_voltage }}>;
+    regulator-max-microvolt = <{{ regulator.max_voltage }}>;
+  };
+  {% endfor %}
+};