@hybridlabor-api/bdb-hardware-pcb 0.1.0

package/mcp_servers/kicad-mcp-server/src/kicad_mcp_server/templates/tests/unity_gpio_test.c.j2

@@ -0,0 +1,113 @@
+/*
+ * GPIO Pin Tests - Auto-generated from KiCad schematic
+ * Generated by: kicad-mcp-server
+ * Framework: Unity Test Framework
+ */
+
+#include "unity.h"
+#include <stdint.h>
+
+/* Mock hardware definitions */
+#define GPIO_PIN_HIGH  1
+#define GPIO_PIN_LOW   0
+#define GPIO_OUTPUT    1
+#define GPIO_INPUT     0
+#define GPIO_BIDIR     2
+
+/* Hardware abstraction layer */
+extern void gpio_init(uint32_t pin, uint32_t direction);
+extern void gpio_write(uint32_t pin, uint32_t state);
+extern uint32_t gpio_read(uint32_t pin);
+
+{% for pin in gpio_pins %}
+/* Test GPIO pin {{ pin.number }} - {{ pin.net }} */
+void test_gpio_{{ pin.number }}_init(void) {
+    /* Test GPIO {{ pin.number }} initialization */
+    gpio_init({{ pin.number }}, {{ pin.direction }});
+
+    /* Verify pin direction */
+    TEST_ASSERT_MESSAGE(1, "GPIO {{ pin.number }} initialization failed");
+}
+
+{% if pin.direction == 'output' %}
+void test_gpio_{{ pin.number }}_output_high(void) {
+    /* Test GPIO {{ pin.number }} output high */
+    gpio_init({{ pin.number }}, GPIO_OUTPUT);
+    gpio_write({{ pin.number }}, GPIO_PIN_HIGH);
+
+    uint32_t state = gpio_read({{ pin.number }});
+    TEST_ASSERT_EQUAL_UINT32(GPIO_PIN_HIGH, state);
+}
+
+void test_gpio_{{ pin.number }}_output_low(void) {
+    /* Test GPIO {{ pin.number }} output low */
+    gpio_init({{ pin.number }}, GPIO_OUTPUT);
+    gpio_write({{ pin.number }}, GPIO_PIN_LOW);
+
+    uint32_t state = gpio_read({{ pin.number }});
+    TEST_ASSERT_EQUAL_UINT32(GPIO_PIN_LOW, state);
+}
+
+{% elif pin.direction == 'input' %}
+void test_gpio_{{ pin.number }}_input(void) {
+    /* Test GPIO {{ pin.number }} input */
+    gpio_init({{ pin.number }}, GPIO_INPUT);
+
+    uint32_t state = gpio_read({{ pin.number }});
+    TEST_ASSERT(state == GPIO_PIN_LOW || state == GPIO_PIN_HIGH);
+}
+
+{% endif %}
+void test_gpio_{{ pin.number }}_continuity(void) {
+    /* Test continuity for GPIO pin {{ pin.number }} */
+    /* Expected net: {{ pin.net }} */
+
+    /* TODO: Implement continuity test */
+    TEST_ASSERT_MESSAGE(1, "Continuity test not implemented");
+}
+
+{% endfor %}
+
+/* Test interactions */
+void test_multiple_gpio_outputs(void) {
+    /* Test multiple GPIO outputs */
+    {% for pin in gpio_pins[:4] %}
+    {% if pin.direction == 'output' %}
+    gpio_init({{ pin.number }}, GPIO_OUTPUT);
+    gpio_write({{ pin.number }}, GPIO_PIN_HIGH);
+    {% endif %}
+    {% endfor %}
+
+    /* Verify all outputs */
+    {% for pin in gpio_pins[:4] %}
+    {% if pin.direction == 'output' %}
+    uint32_t state_{{ pin.number }} = gpio_read({{ pin.number }});
+    TEST_ASSERT_EQUAL_UINT32(GPIO_PIN_HIGH, state_{{ pin.number }});
+    {% endif %}
+    {% endfor %}
+}
+
+void test_gpio_pin_conflicts(void) {
+    /* Test for GPIO pin conflicts */
+    uint32_t pins_tested = {{ gpio_pins|length }};
+    TEST_ASSERT(pins_tested > 0);
+}
+
+int main(void) {
+    UNITY_BEGIN();
+
+    {% for pin in gpio_pins %}
+    RUN_TEST(test_gpio_{{ pin.number }}_init);
+    {% if pin.direction == 'output' %}
+    RUN_TEST(test_gpio_{{ pin.number }}_output_high);
+    RUN_TEST(test_gpio_{{ pin.number }}_output_low);
+    {% elif pin.direction == 'input' %}
+    RUN_TEST(test_gpio_{{ pin.number }}_input);
+    {% endif %}
+    RUN_TEST(test_gpio_{{ pin.number }}_continuity);
+    {% endfor %}
+    RUN_TEST(test_multiple_gpio_outputs);
+    RUN_TEST(test_gpio_pin_conflicts);
+
+    return UNITY_END();
+}

package/mcp_servers/kicad-mcp-server/src/kicad_mcp_server/templates/tests/unity_i2c_test.c.j2

@@ -0,0 +1,101 @@
+/*
+ * I2C Device Tests - Auto-generated from KiCad schematic
+ * Generated by: kicad-mcp-server
+ * Framework: Unity Test Framework
+ */
+
+#include "unity.h"
+#include <stdint.h>
+
+/* I2C hardware abstraction */
+extern void i2c_init(uint32_t bus);
+extern uint8_t i2c_read_byte(uint32_t bus, uint8_t address, uint8_t reg);
+extern void i2c_write_byte(uint32_t bus, uint8_t address, uint8_t reg, uint8_t data);
+
+{% for device in i2c_devices %}
+/* Test I2C device {{ device.reference }} - {{ device.value }} */
+void test_i2c_device_{{ loop.index }}_detection(void) {
+    /* Test I2C device detection at address 0x{{ "%02X"|format(device.address) }} */
+    uint8_t expected_address = 0x{{ "%02X"|format(device.address) }};
+
+    /* Attempt to read from device */
+    i2c_init(1);
+    uint8_t data = i2c_read_byte(1, expected_address, 0x00);
+
+    /* If we get here without timeout, device was detected */
+    TEST_ASSERT_MESSAGE(1, "I2C device detection test passed");
+}
+
+void test_i2c_device_{{ loop.index }}_communication(void) {
+    /* Test I2C communication with {{ device.value }} */
+    uint8_t expected_address = 0x{{ "%02X"|format(device.address) }};
+
+    /* Test read operation */
+    uint8_t chip_id = i2c_read_byte(1, expected_address, 0x00);
+
+    /* Verify we can read from device */
+    TEST_ASSERT(chip_id != 0xFF || chip_id != 0x00, "Failed to communicate with device");
+}
+
+void test_i2c_device_{{ loop.index }}_specific(void) {
+    /* Test {{ device.value }} specific functionality */
+    /* Compatible: {{ device.compatible }} */
+
+    /* TODO: Add device-specific tests */
+    /* Examples: */
+    /* - Read chip ID register */
+    /* - Verify sensor readings */
+    /* - Test configuration registers */
+    TEST_ASSERT_MESSAGE(1, "Device-specific tests not implemented");
+}
+
+{% endfor %}
+
+/* Test I2C bus */
+void test_i2c_bus_scan(void) {
+    /* Test I2C bus scan functionality */
+
+    /* Expected devices */
+    const uint8_t expected_addresses[] = {
+        {% for device in i2c_devices %}
+        0x{{ "%02X"|format(device.address) }},
+        {% endfor %}
+    };
+
+    /* Scan I2C bus */
+    uint8_t found_count = 0;
+    for (uint8_t i = 0; i < sizeof(expected_addresses); i++) {
+        uint8_t address = expected_addresses[i];
+        uint8_t data = i2c_read_byte(1, address, 0x00);
+        if (data != 0xFF && data != 0x00) {
+            found_count++;
+        }
+    }
+
+    /* Verify at least some devices were found */
+    TEST_ASSERT(found_count > 0, "No I2C devices found on bus");
+}
+
+void test_i2c_bus_voltage_levels(void) {
+    /* Test I2C bus voltage levels */
+
+    /* TODO: Implement voltage level testing */
+    /* - Verify pull-up resistors are present */
+    /* - Check bus idle state (high) */
+    /* - Measure voltage levels */
+    TEST_ASSERT_MESSAGE(1, "Voltage level test not implemented");
+}
+
+int main(void) {
+    UNITY_BEGIN();
+
+    {% for device in i2c_devices %}
+    RUN_TEST(test_i2c_device_{{ loop.index }}_detection);
+    RUN_TEST(test_i2c_device_{{ loop.index }}_communication);
+    RUN_TEST(test_i2c_device_{{ loop.index }}_specific);
+    {% endfor %}
+    RUN_TEST(test_i2c_bus_scan);
+    RUN_TEST(test_i2c_bus_voltage_levels);
+
+    return UNITY_END();
+}

package/mcp_servers/kicad-mcp-server/src/kicad_mcp_server/templates/tests/unity_spi_test.c.j2

@@ -0,0 +1,94 @@
+/*
+ * SPI Device Tests - Auto-generated from KiCad schematic
+ * Generated by: kicad-mcp-server
+ * Framework: Unity Test Framework
+ */
+
+#include "unity.h"
+#include <stdint.h>
+
+/* SPI hardware abstraction */
+extern void spi_init(uint32_t bus, uint32_t cs);
+extern uint8_t spi_transfer_byte(uint32_t bus, uint32_t cs, uint8_t data);
+
+{% for device in spi_devices %}
+/* Test SPI device {{ device.reference }} - {{ device.value }} */
+void test_spi_device_{{ loop.index }}_detection(void) {
+    /* Test SPI device detection on CS {{ device.cs }} */
+    uint32_t cs_pin = {{ device.cs }};
+    uint32_t frequency = {{ device.frequency }};
+
+    /* Initialize SPI */
+    spi_init(0, cs_pin);
+
+    /* Test basic communication */
+    uint8_t response = spi_transfer_byte(0, cs_pin, 0x9F); /* JEDEC ID command */
+
+    /* Verify we got a response */
+    TEST_ASSERT(response != 0xFF || response != 0x00, "No response from device");
+}
+
+void test_spi_device_{{ loop.index }}_communication(void) {
+    /* Test SPI communication with {{ device.value }} */
+    uint32_t cs_pin = {{ device.cs }};
+
+    /* Test data transfer */
+    uint8_t test_data = 0xAA;
+    uint8_t response = spi_transfer_byte(0, cs_pin, test_data);
+
+    /* Verify communication */
+    TEST_ASSERT_MESSAGE(1, "SPI communication test passed");
+}
+
+void test_spi_device_{{ loop.index }}_specific(void) {
+    /* Test {{ device.value }} specific functionality */
+    /* Compatible: {{ device.compatible }} */
+
+    /* TODO: Add device-specific tests */
+    /* Examples: */
+    /* - Read JEDEC ID */
+    /* - Verify register access */
+    /* - Test data transfer */
+    TEST_ASSERT_MESSAGE(1, "Device-specific tests not implemented");
+}
+
+{% endfor %}
+
+/* Test SPI bus */
+void test_spi_bus_configuration(void) {
+    /* Test SPI bus configuration */
+
+    /* TODO: Implement bus configuration tests */
+    /* - Verify clock polarity and phase */
+    /* - Check appropriate clock frequency */
+    /* - Test proper chip select handling */
+    TEST_ASSERT_MESSAGE(1, "SPI bus configuration test not implemented");
+}
+
+void test_spi_data_transfer(void) {
+    /* Test SPI data transfer */
+
+    /* Test multiple bytes */
+    uint8_t test_data[] = {0xAA, 0x55, 0xFF, 0x00};
+
+    for (uint8_t i = 0; i < sizeof(test_data); i++) {
+        uint8_t response = spi_transfer_byte(0, 0, test_data[i]);
+        /* Verify response */
+    }
+
+    TEST_ASSERT_MESSAGE(1, "SPI data transfer test passed");
+}
+
+int main(void) {
+    UNITY_BEGIN();
+
+    {% for device in spi_devices %}
+    RUN_TEST(test_spi_device_{{ loop.index }}_detection);
+    RUN_TEST(test_spi_device_{{ loop.index }}_communication);
+    RUN_TEST(test_spi_device_{{ loop.index }}_specific);
+    {% endfor %}
+    RUN_TEST(test_spi_bus_configuration);
+    RUN_TEST(test_spi_data_transfer);
+
+    return UNITY_END();
+}

package/mcp_servers/kicad-mcp-server/src/kicad_mcp_server/templates/unittest/test_schematic.py.j2

@@ -0,0 +1,172 @@
+"""
+Unit test suite for {{ project_name }}
+Generated from {{ schematic_path }}
+
+This test suite provides connectivity and functional verification
+using Python's unittest framework.
+"""
+
+import unittest
+from typing import Dict, List, Any
+
+
+# Netlist derived from schematic
+NETLIST = {
+{% for net in nets %}
+    "{{ net.name }}": {
+        "code": {{ net.code }},
+        "pins": {{ net.pins | tojson }},
+    },
+{% endfor %}
+}
+
+# Component information
+COMPONENTS = {
+{% for comp in components %}
+    "{{ comp.reference }}": {
+        "value": "{{ comp.value }}",
+        "footprint": "{{ comp.footprint or 'N/A' }}",
+    },
+{% endfor %}
+}
+
+
+class TestSchematicConnectivity(unittest.TestCase):
+    """Test cases for schematic connectivity."""
+
+    def test_power_nets_exist(self):
+        """Verify power nets are present."""
+        net_names = list(NETLIST.keys())
+        power_keywords = ["GND", "VCC", "VDD", "+3V3", "+5V"]
+
+        power_nets = [
+            name for name in net_names
+            if any(pw in name.upper() for pw in power_keywords)
+        ]
+
+        self.assertGreater(len(power_nets), 0, "No power nets found")
+        print(f"Power nets: {power_nets}")
+
+    def test_component_references_unique(self):
+        """Verify all component references are unique."""
+        refs = list(COMPONENTS.keys())
+        unique_refs = set(refs)
+
+        self.assertEqual(len(refs), len(unique_refs), "Duplicate references found")
+
+    def test_components_have_values(self):
+        """Verify components have valid values."""
+        missing_values = []
+
+        for ref, data in COMPONENTS.items():
+            if not data["value"] or data["value"] in ["", "?"]:
+                missing_values.append(ref)
+
+        self.assertEqual(len(missing_values), 1, f"Missing values: {missing_values}")
+
+
+class TestFunctionalVerification(unittest.TestCase):
+    """Test cases for functional verification."""
+
+    def test_mcu_power_supply(self):
+        """Verify MCU has proper power connections."""
+        # Find MCU components
+        mcu_refs = [
+            ref for ref, data in COMPONENTS.items()
+            if any(mcu in data["value"].lower() for mcu in ["mcu", "micro", "atmega", "stm32", "esp"])
+        ]
+
+        if not mcu_refs:
+            self.skipTest("No MCU found in schematic")
+
+        # Check for VCC and GND connections to MCU
+        mcu_ref = mcu_refs[0]
+        vcc_connected = any(
+            f"{mcu_ref}:" in pin
+            for net in NETLIST.values()
+            for pin in net["pins"]
+        )
+
+        self.assertTrue(vcc_connected, f"{mcu_ref} may not be properly powered")
+
+    def test_communication_interfaces(self):
+        """Verify communication interface signals."""
+        interface_nets = {
+            "UART": ["tx", "rx"],
+            "I2C": ["sda", "scl"],
+            "SPI": ["mosi", "miso", "sck"],
+        }
+
+        detected_interfaces = []
+
+        for interface, signals in interface_nets.items():
+            net_names = list(NETLIST.keys())
+            if any(
+                any(sig in name.lower() for sig in signals)
+                for name in net_names
+            ):
+                detected_interfaces.append(interface)
+
+        print(f"Detected interfaces: {detected_interfaces}")
+
+
+{% if test_type == "production" %}
+class TestProductionReadiness(unittest.TestCase):
+    """Test cases for production readiness."""
+
+    def test_footprint_completeness(self):
+        """Verify all components have footprints."""
+        missing_footprints = []
+
+        for ref, data in COMPONENTS.items():
+            if data["footprint"] in ["N/A", "", None]:
+                missing_footprints.append(ref)
+
+        self.assertEqual(
+            len(missing_footprints), 0,
+            f"Components without footprints: {missing_footprints}"
+        )
+
+    def test_net_connectivity(self):
+        """Verify critical nets have proper connections."""
+        # Find nets with only one pin (possible unconnected pins)
+        single_pin_nets = [
+            name for name, data in NETLIST.items()
+            if len(data["pins"]) <= 1
+        ]
+
+        # Allow some single-pin nets (e.g., test points, no-connects)
+        self.assertLess(
+            len(single_pin_nets), 20,
+            f"Too many single-pin nets: {single_pin_nets[:10]}"
+        )
+{% endif %}
+
+
+def run_tests() -> None:
+    """Run all tests and print results."""
+    # Create test suite
+    loader = unittest.TestLoader()
+    suite = unittest.TestSuite()
+
+    # Add all test cases
+    suite.addTests(loader.loadTestsFromTestCase(TestSchematicConnectivity))
+    suite.addTests(loader.loadTestsFromTestCase(TestFunctionalVerification))
+    {% if test_type == "production" %}
+    suite.addTests(loader.loadTestsFromTestCase(TestProductionReadiness))
+    {% endif %}
+
+    # Run tests
+    runner = unittest.TextTestRunner(verbosity=2)
+    result = runner.run(suite)
+
+    # Print summary
+    print("\n" + "=" * 70)
+    print(f"Tests run: {result.testsRun}")
+    print(f"Failures: {len(result.failures)}")
+    print(f"Errors: {len(result.errors)}")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    run_tests()

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

@@ -0,0 +1,36 @@
+"""KiCad MCP Server Tools
+
+Core KiCad operations - simplified and focused.
+"""
+
+from . import (
+    device_tree,
+    hierarchical_analysis,
+    netlist,
+    parts_registry,
+    pcb,
+    pcb_layout,
+    pin_analysis,
+    project,
+    schematic,
+    schematic_editor,
+    schematic_search,
+    validation,
+    visualization,
+)
+
+__all__ = [
+    "project",
+    "schematic",
+    "schematic_editor",
+    "pcb",
+    "pcb_layout",
+    "netlist",
+    "device_tree",
+    "hierarchical_analysis",
+    "pin_analysis",
+    "schematic_search",
+    "validation",
+    "parts_registry",
+    "visualization",
+]