@hybridlabor-api/bdb-hardware-pcb 0.1.0

package/mcp_servers/kicad-mcp-server/src/kicad_mcp_server/templates/st_hal/hal_test.c.j2

@@ -0,0 +1,313 @@
+/**
+ * STM32 HAL Test Suite for {{ project_name }}
+ * Generated from {{ schematic_path }}
+ *
+ * Connectivity and functional tests using STM32 HAL library.
+ */
+
+{% if target_mcu %}
+#ifdef {{ target_mcu.upper().replace('-', '_') }
+#include "stm32{{ target_mcu.lower().replace('stm32', '').replace('x', '') }}xx_hal.h"
+#else
+#include "stm32xxxx_hal.h"
+#endif
+{% endif %}
+
+#include <stdio.h>
+#include <stdint.h>
+
+/* Private defines */
+#define TEST_PASS 1
+#define TEST_FAIL 0
+
+/* Test statistics */
+static uint32_t g_tests_passed = 0;
+static uint32_t g_tests_failed = 0;
+
+/* UART handle for debug output */
+extern UART_HandleTypeDef huart2; /* Adjust to your UART */
+
+/* Private function prototypes */
+static void test_init(void);
+static void test_power_supply(void);
+static void test_gpio_connectivity(void);
+{% if test_type == "functional" %}
+static void test_i2c_scan(void);
+static void test_spi_loopback(void);
+{% endif %}
+static void print_summary(void);
+
+/* Helper functions */
+static void test_log(const char* message) {
+    HAL_UART_Transmit(&huart2, (uint8_t*)message, strlen(message), HAL_MAX_DELAY);
+}
+
+static void test_log_num(const char* prefix, int32_t num) {
+    char buffer[64];
+    snprintf(buffer, sizeof(buffer), "%s%ld\n", prefix, num);
+    test_log(buffer);
+}
+
+/**
+ * @brief Initialize test suite
+ */
+static void test_init(void) {
+    test_log("\r\n========================================\r\n");
+    test_log("{{ project_name }} - STM32 HAL Test Suite\r\n");
+    test_log("========================================\r\n\r\n");
+
+    /* Initialize HAL */
+    HAL_Init();
+
+    /* Configure system clock */
+    SystemClock_Config();
+
+    /* Initialize peripherals */
+    MX_GPIO_Init();
+    MX_USART2_UART_Init();
+    {% if test_type == "functional" %}
+    MX_I2C1_Init();
+    MX_SPI1_Init();
+    {% endif %}
+
+    test_log("Test initialization complete\r\n\r\n");
+}
+
+/**
+ * @brief Test power supply presence
+ */
+static void test_power_supply(void) {
+    test_log("[TEST] Power Supply Check\r\n");
+
+    {% if target_mcu and "stm32" in target_mcu %}
+    /* Use internal reference and ADC to check VDD */
+    ADC_HandleTypeDef hadc1;
+    ADC_ChannelConfTypeDef sConfig = {0};
+
+    /* Enable ADC clock */
+    __HAL_RCC_ADC1_CLK_ENABLE();
+
+    hadc1.Instance = ADC1;
+    hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
+    hadc1.Init.ContinuousConvMode = DISABLE;
+    hadc1.Init.DiscontinuousConvMode = DISABLE;
+    hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
+    hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
+    hadc1.Init.NbrOfConversion = 1;
+    HAL_ADC_Init(&hadc1);
+
+    /* Configure VREFINT channel */
+    sConfig.Channel = ADC_CHANNEL_VREFINT;
+    sConfig.Rank = ADC_REGULAR_RANK_1;
+    sConfig.SamplingTime = ADC_SAMPLETIME_239CYCLES_5;
+    HAL_ADC_ConfigChannel(&hadc1, &sConfig);
+
+    /* Start conversion */
+    HAL_ADC_Start(&hadc1);
+    HAL_ADC_PollForConversion(&hadc1, HAL_MAX_DELAY);
+    uint32_t adc_value = HAL_ADC_GetValue(&hadc1);
+    HAL_ADC_Stop(&hadc1);
+
+    /* Calculate VDD (simplified) */
+    float vdd = 1.2f * 4096.0f / adc_value;
+
+    test_log("VDD: ");
+    test_log_num("VDD = ", (int32_t)(vdd * 1000));
+    test_log(" mV\r\n");
+
+    if (vdd > 2.7f && vdd < 3.6f) {
+        test_log("[PASS] Power supply OK\r\n\r\n");
+        g_tests_passed++;
+    } else {
+        test_log("[FAIL] Power supply out of range\r\n\r\n");
+        g_tests_failed++;
+    }
+    {% else %}
+    test_log("[SKIP] Power test requires MCU-specific ADC\r\n\r\n");
+    {% endif %}
+}
+
+/**
+ * @brief Test GPIO connectivity
+ */
+static void test_gpio_connectivity(void) {
+    test_log("[TEST] GPIO Connectivity\r\n");
+
+    /* Test input pins */
+    GPIO_TypeDef* ports[] = {
+        {% for pin in test_pins %}
+        GPIO{{ pin.port }}, /* {{ pin.name }} */
+        {% endfor %}
+    };
+
+    const uint16_t pins[] = {
+        {% for pin in test_pins %}
+        GPIO_PIN_{{ pin.pin_number }}, /* {{ pin.name }} */
+        {% endfor %}
+    };
+
+    const char* pin_names[] = {
+        {% for pin in test_pins %}
+        "{{ pin.name }}",
+        {% endfor %}
+    };
+
+    for (size_t i = 0; i < sizeof(pins)/sizeof(pins[0]); i++) {
+        GPIO_PinState state = HAL_GPIO_ReadPin(ports[i], pins[i]);
+
+        test_log(pin_names[i]);
+        test_log(": ");
+        test_log(state == GPIO_PIN_SET ? "HIGH\r\n" : "LOW\r\n");
+    }
+
+    test_log("[PASS] GPIO connectivity test complete\r\n\r\n");
+    g_tests_passed++;
+}
+
+{% if test_type == "functional" %}
+/**
+ * @brief Scan I2C bus for devices
+ */
+static void test_i2c_scan(void) {
+    test_log("[TEST] I2C Device Scan\r\n");
+
+    /* I2C handle - adjust to your configuration */
+    I2C_HandleTypeDef hi2c1;
+
+    HAL_StatusTypeDef status;
+    uint8_t devices_found = 0;
+
+    for (uint8_t addr = 1; addr < 128; addr++) {
+        status = HAL_I2C_IsDeviceReady(&hi2c1, addr << 1, 1, 10);
+
+        if (status == HAL_OK) {
+            char buffer[64];
+            snprintf(buffer, sizeof(buffer), "Device found at 0x%02X\r\n", addr);
+            test_log(buffer);
+            devices_found++;
+        }
+    }
+
+    test_log_num("Total I2C devices: ", devices_found);
+    test_log("\r\n[PASS] I2C scan complete\r\n\r\n");
+    g_tests_passed++;
+}
+
+/**
+ * @brief SPI loopback test
+ */
+static void test_spi_loopback(void) {
+    test_log("[TEST] SPI Loopback Test\r\n");
+
+    /* SPI handle - adjust to your configuration */
+    SPI_HandleTypeDef hspi1;
+
+    uint8_t tx_data = 0xAA;
+    uint8_t rx_data = 0x00;
+
+    HAL_SPI_TransmitReceive(&hspi1, &tx_data, &rx_data, 1, 100);
+
+    test_log("TX: 0xAA, RX: ");
+    char buffer[32];
+    snprintf(buffer, sizeof(buffer), "0x%02X\r\n", rx_data);
+    test_log(buffer);
+
+    /* Note: Loopback requires hardware connection */
+    test_log("[PASS] SPI test complete\r\n\r\n");
+    g_tests_passed++;
+}
+{% endif %}
+
+/**
+ * @brief Print test summary
+ */
+static void print_summary(void) {
+    test_log("\r\n========================================\r\n");
+    test_log("Test Summary\r\n");
+    test_log("========================================\r\n");
+
+    test_log("Passed: ");
+    test_log_num("", g_tests_passed);
+    test_log("Failed: ");
+    test_log_num("", g_tests_failed);
+    test_log("Total:  ");
+    test_log_num("", g_tests_passed + g_tests_failed);
+
+    test_log("\r\n========================================\r\n");
+}
+
+/**
+ * @brief Main test runner
+ */
+int main(void) {
+    /* Initialize test suite */
+    test_init();
+
+    /* Run tests */
+    test_power_supply();
+    test_gpio_connectivity();
+    {% if test_type == "functional" %}
+    test_i2c_scan();
+    test_spi_loopback();
+    {% endif %}
+
+    /* Print summary */
+    print_summary();
+
+    /* Loop forever */
+    while (1) {
+        HAL_Delay(1000);
+    }
+}
+
+/**
+ * @brief System Clock Configuration (stub)
+ */
+void SystemClock_Config(void) {
+    /* Implement based on your MCU and clock requirements */
+}
+
+/**
+ * @brief GPIO Initialization (stub)
+ */
+void MX_GPIO_Init(void) {
+    /* Enable GPIO clocks */
+    __HAL_RCC_GPIOA_CLK_ENABLE();
+    __HAL_RCC_GPIOB_CLK_ENABLE();
+    __HAL_RCC_GPIOC_CLK_ENABLE();
+
+    /* Configure GPIO pins based on schematic */
+    {% for pin in test_pins %}
+    /* {{ pin.name }}: PA{{ pin.pin_number }} */
+    {% endfor %}
+}
+
+/**
+ * @brief UART Initialization (stub)
+ */
+void MX_USART2_UART_Init(void) {
+    /* Implement UART initialization for debug output */
+}
+
+{% if test_type == "functional" %}
+/**
+ * @brief I2C Initialization (stub)
+ */
+void MX_I2C1_Init(void) {
+    /* Implement I2C initialization */
+}
+
+/**
+ * @brief SPI Initialization (stub)
+ */
+void MX_SPI1_Init(void) {
+    /* Implement SPI initialization */
+}
+{% endif %}
+
+/**
+ * @brief SysTick Handler
+ */
+void SysTick_Handler(void) {
+    HAL_IncTick();
+}

package/mcp_servers/kicad-mcp-server/src/kicad_mcp_server/templates/tests/pytest_gpio_test.py.j2

@@ -0,0 +1,99 @@
+"""GPIO Pin Tests - Auto-generated from KiCad schematic
+Generated by: kicad-mcp-server
+"""
+
+import pytest
+from unittest.mock import Mock
+{% if hardware_interaction %}
+import RPi.GPIO as GPIO  # Raspberry Pi
+{% endif %}
+
+
+{% for pin in gpio_pins %}
+class TestGPIO{{ pin.number }}:
+    """Test GPIO pin {{ pin.number }} - {{ pin.net }}"""
+
+    {% if pin.direction == 'output' %}
+    def test_gpio_output(self):
+        """Test GPIO {{ pin.number }} output functionality"""
+        # Setup pin as output
+        {% if hardware_interaction %}
+        GPIO.setup({{ pin.number }}, GPIO.OUT)
+        {% endif %}
+
+        # Test high state
+        {% if hardware_interaction %}
+        GPIO.output({{ pin.number }}, GPIO.HIGH)
+        assert GPIO.input({{ pin.number }}) == GPIO.HIGH
+        {% endif %}
+
+        # Test low state
+        {% if hardware_interaction %}
+        GPIO.output({{ pin.number }}, GPIO.LOW)
+        assert GPIO.input({{ pin.number }}) == GPIO.LOW
+        {% endif %}
+
+    {% elif pin.direction == 'input' %}
+    def test_gpio_input(self):
+        """Test GPIO {{ pin.number }} input functionality"""
+        # Setup pin as input
+        {% if hardware_interaction %}
+        GPIO.setup({{ pin.number }}, GPIO.IN)
+        initial_state = GPIO.input({{ pin.number }})
+        {% endif %}
+
+        # Pin should be readable
+        {% if hardware_interaction %}
+        state = GPIO.input({{ pin.number }})
+        assert state in [GPIO.LOW, GPIO.HIGH]
+        {% endif %}
+
+    {% endif %}
+    def test_gpio_{{ pin.number }}_continuity(self):
+        """Test continuity for GPIO pin {{ pin.number }}"""
+        # This test verifies the connection exists
+        # Expected net: {{ pin.net }}
+        # Pin: {{ pin.number }}
+
+        # TODO: Add continuity test logic
+        # For multimeter-based testing, verify resistance is low
+        assert True, "Continuity test not implemented"
+
+{% endfor %}
+
+
+class TestGPIOInteractions:
+    """Test interactions between multiple GPIO pins"""
+
+    {% if gpio_pins|length > 1 %}
+    def test_multiple_gpio_outputs(self):
+        """Test multiple GPIO output pins simultaneously"""
+        {% for pin in gpio_pins[:4] %}
+        {% if pin.direction == 'output' %}
+        # GPIO {{ pin.number }} configuration
+        {% if hardware_interaction %}
+        GPIO.setup({{ pin.number }}, GPIO.OUT)
+        GPIO.output({{ pin.number }}, GPIO.HIGH)
+        {% endif %}
+        {% endfor %}
+        {% endfor %}
+
+        # Verify all outputs are set correctly
+        {% if hardware_interaction %}
+        {% for pin in gpio_pins[:4] %}
+        {% if pin.direction == 'output' %}
+        assert GPIO.input({{ pin.number }}) == GPIO.HIGH
+        {% endif %}
+        {% endfor %}
+        {% endif %}
+
+    {% endif %}
+    def test_gpio_pin_conflicts(self):
+        """Test for GPIO pin conflicts"""
+        # Verify no pins are configured with conflicting functions
+        pins_tested = {{ gpio_pins|length }}
+        assert pins_tested > 0, "No GPIO pins found to test"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

package/mcp_servers/kicad-mcp-server/src/kicad_mcp_server/templates/tests/pytest_i2c_test.py.j2

@@ -0,0 +1,117 @@
+"""I2C Device Tests - Auto-generated from KiCad schematic
+Generated by: kicad-mcp-server
+"""
+
+import pytest
+{% if hardware_interaction %}
+from smbus2 import SMBus, i2c_msg
+{% endif %}
+
+
+{% for device in i2c_devices %}
+class TestI2CDevice{{ loop.index }}:
+    """Test I2C device {{ device.reference }} - {{ device.value }}"""
+
+    def test_i2c_device_detection(self):
+        """Test I2C device detection at address 0x{{ "%02X"|format(device.address) }}"""
+        expected_address = 0x{{ "%02X"|format(device.address) }}
+        device_name = "{{ device.value }}"
+
+        {% if hardware_interaction %}
+        # Scan I2C bus
+        found_devices = []
+        for address in range(0x03, 0x78):
+            try:
+                with SMBus(1) as bus:
+                    bus.read_byte(address)
+                    found_devices.append(address)
+            except:
+                pass
+
+        # Verify device is present
+        assert expected_address in found_devices, f"{device_name} not found at 0x{expected_address:02X}"
+        {% else %}
+        # Mock test - verify address is valid
+        assert 0x03 <= expected_address <= 0x77, "Invalid I2C address"
+        {% endif %}
+
+    def test_i2c_device_communication(self):
+        """Test I2C communication with {{ device.reference }}"""
+        expected_address = 0x{{ "%02X"|format(device.address) }}
+
+        {% if hardware_interaction %}
+        try:
+            with SMBus(1) as bus:
+                # Test basic read operation
+                data = bus.read_byte_data(expected_address, 0x00)
+                assert isinstance(data, int), "Failed to read from device"
+        except Exception as e:
+            pytest.skip(f"I2C communication failed: {e}")
+        {% else %}
+        # Mock test - verify device can be addressed
+        assert expected_address != 0x00, "I2C address cannot be 0x00"
+        {% endif %}
+
+    def test_i2c_device_{{ device.compatible.split(',')[1] if ',' in device.compatible else device.compatible }}_specific(self):
+        """Test {{ device.value }} specific functionality"""
+        # Device-specific tests for {{ device.value }}
+        # Compatible: {{ device.compatible }}
+
+        # TODO: Add device-specific test cases
+        # Examples:
+        # - Read chip ID register
+        # - Verify sensor readings
+        # - Test configuration registers
+        assert True, "Device-specific tests not implemented"
+
+{% endfor %}
+
+
+class TestI2CBus:
+    """Test I2C bus functionality"""
+
+    def test_i2c_bus_scan(self):
+        """Test I2C bus scan"""
+        expected_devices = {
+            {% for device in i2c_devices %}
+            0x{{ "%02X"|format(device.address) }}: "{{ device.value }}",
+            {% endfor %}
+        }
+
+        {% if hardware_interaction %}
+        # Scan I2C bus
+        found_devices = []
+        for address in range(0x03, 0x78):
+            try:
+                with SMBus(1) as bus:
+                    bus.read_byte(address)
+                    found_devices.append(address)
+            except:
+                pass
+
+        # Verify expected devices are present
+        for address, device_name in expected_devices.items():
+            if address in found_devices:
+                print(f"✓ Found {device_name} at 0x{address:02X}")
+            else:
+                pytest.fail(f"✗ {device_name} not found at 0x{address:02X}")
+        {% else %}
+        # Mock test - verify expected device configuration
+        assert len(expected_devices) > 0, "No I2C devices configured"
+        {% endif %}
+
+    def test_i2c_bus_voltage_levels(self):
+        """Test I2C bus voltage levels"""
+        # I2C buses typically operate at:
+        # - 3.3V for modern MCUs
+        # - 5.0V for legacy systems
+
+        # TODO: Add voltage level testing
+        # - Verify pull-up resistors are present
+        # - Check bus idle state (high)
+        # - Measure voltage levels
+        assert True, "Voltage level test not implemented"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

package/mcp_servers/kicad-mcp-server/src/kicad_mcp_server/templates/tests/pytest_pinmux_test.py.j2

@@ -0,0 +1,43 @@
+"""Pin Multiplexing Tests - Auto-generated from KiCad schematic
+Generated by: kicad-mcp-server
+"""
+
+import pytest
+
+
+class TestPinMultiplexing:
+    """Test pin multiplexing configuration"""
+
+    def test_no_pin_conflicts(self):
+        """Test that there are no pin conflicts"""
+        # This test verifies that no pins are configured
+        # with conflicting functions
+
+        # TODO: Add pin conflict detection logic
+        # - Multiple functions on same pin
+        # - Incompatible peripheral assignments
+        assert True, "Pin conflict test not implemented"
+
+    def test_gpio_alternate_functions(self):
+        """Test GPIO alternate function assignments"""
+        # Verify that GPIO pins are correctly assigned
+        # to their alternate functions
+
+        # TODO: Add alternate function verification
+        # - Check peripheral assignments
+        # - Verify function compatibility
+        assert True, "Alternate function test not implemented"
+
+    def test_peripheral_pin_mapping(self):
+        """Test peripheral-to-pin mappings"""
+        # Verify that peripherals are mapped to correct pins
+
+        # TODO: Add peripheral mapping tests
+        # - I2C SDA/SCL pin assignments
+        # - SPI MOSI/MISO/SCK/CS pin assignments
+        # - UART TX/RX pin assignments
+        assert True, "Peripheral mapping test not implemented"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

package/mcp_servers/kicad-mcp-server/src/kicad_mcp_server/templates/tests/pytest_spi_test.py.j2

@@ -0,0 +1,94 @@
+"""SPI Device Tests - Auto-generated from KiCad schematic
+Generated by: kicad-mcp-server
+"""
+
+import pytest
+{% if hardware_interaction %}
+import spidev
+{% endif %}
+
+
+{% for device in spi_devices %}
+class TestSPIDevice{{ loop.index }}:
+    """Test SPI device {{ device.reference }} - {{ device.value }}"""
+
+    def test_spi_device_detection(self):
+        """Test SPI device detection on CS {{ device.cs }}"""
+        cs_pin = {{ device.cs }}
+        device_name = "{{ device.value }}"
+        frequency = {{ device.frequency }}
+
+        {% if hardware_interaction %}
+        try:
+            # Open SPI bus
+            spi = spidev.SpiDev()
+            spi.open(0, cs_pin)
+            spi.max_speed_hz = frequency
+
+            # Test basic communication
+            response = spi.xfer2([0x9F])  # Common JEDEC ID command
+            spi.close()
+
+            assert len(response) > 0, f"No response from {device_name}"
+        except Exception as e:
+            pytest.skip(f"SPI communication failed: {e}")
+        {% else %}
+        # Mock test - verify device can be addressed
+        assert 0 <= cs_pin <= 2, "Invalid CS pin"
+        assert frequency > 0, "Invalid SPI frequency"
+        {% endif %}
+
+    def test_spi_device_{{ device.compatible.split(',')[1] if ',' in device.compatible else device.compatible }}_specific(self):
+        """Test {{ device.value }} specific functionality"""
+        # Device-specific tests for {{ device.value }}
+        # Compatible: {{ device.compatible }}
+
+        # TODO: Add device-specific test cases
+        # Examples:
+        # - Read JEDEC ID
+        # - Verify register access
+        # - Test data transfer
+        assert True, "Device-specific tests not implemented"
+
+{% endfor %}
+
+
+class TestSPIBus:
+    """Test SPI bus functionality"""
+
+    def test_spi_bus_configuration(self):
+        """Test SPI bus configuration"""
+        # SPI bus should be configured with:
+        # - Correct clock polarity and phase
+        # - Appropriate clock frequency
+        # - Proper chip select handling
+
+        # TODO: Add bus configuration tests
+        assert True, "SPI bus configuration test not implemented"
+
+    def test_spi_data_transfer(self):
+        """Test SPI data transfer"""
+        # Test basic SPI data transfer
+
+        {% if hardware_interaction %}
+        try:
+            spi = spidev.SpiDev()
+            spi.open(0, 0)
+            spi.max_speed_hz = 1000000
+
+            # Test write and read
+            test_data = [0xAA, 0x55, 0xFF, 0x00]
+            response = spi.xfer2(test_data)
+            spi.close()
+
+            assert len(response) == len(test_data), "Data length mismatch"
+        except Exception as e:
+            pytest.skip(f"SPI data transfer failed: {e}")
+        {% else %}
+        # Mock test
+        assert True, "SPI data transfer test not implemented"
+        {% endif %}
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])