test_swd_debugger.py

import unittest

from typing_extensions import override

from edg import *
from .util import run_test_board


class SwdCortexSourceHeader(ProgrammingConnector, FootprintBlock):
    def __init__(self) -> None:
        super().__init__()

        self.pwr = self.Port(VoltageSink(), [Power])
        self.gnd = self.Port(Ground(), [Common])  # TODO pin at 0v
        self.swd = self.Port(SwdTargetPort(), [Input])
        self.reset = self.Port(DigitalSink(), optional=True)
        self.swo = self.Port(DigitalBidir(), optional=True)
        self.tdi = self.Port(DigitalBidir(), optional=True)

    @override
    def contents(self) -> None:
        super().contents()
        self.conn = self.Block(PinHeader127DualShrouded(10)).connected(
            {
                "1": self.pwr,
                ("3", "5", "9"): self.gnd,
                "2": self.swd.swdio,
                "4": self.swd.swclk,
                "6": self.swo,
                "8": self.tdi,
                "10": self.reset,
            }
        )


class SwdCortexSourceTagConnect(ProgrammingConnector, FootprintBlock):
    def __init__(self) -> None:
        super().__init__()

        self.pwr = self.Port(VoltageSink(), [Power])
        self.gnd = self.Port(Ground(), [Common])  # TODO pin at 0v
        self.swd = self.Port(SwdTargetPort(), [Input])
        self.reset = self.Port(DigitalSink(), optional=True)
        self.swo = self.Port(DigitalBidir(), optional=True)

    @override
    def contents(self) -> None:
        super().contents()

        self.conn = self.Block(PinHeader254DualShroudedInline(6)).connected(
            {
                "1": self.pwr,
                "5": self.gnd,
                "2": self.swd.swdio,  # also TMS
                "3": self.reset,
                "4": self.swd.swclk,
                "6": self.swo,
            }
        )


class SwdSourceBitBang(InternalSubcircuit, Block):
    def __init__(self) -> None:
        super().__init__()
        self.reset_in = self.Port(DigitalSink.empty())
        self.swclk_in = self.Port(DigitalSink.empty())
        self.swdio_in = self.Port(DigitalSink.empty())  # driving side
        self.swdio_out = self.Port(DigitalSource.empty())  # target side
        self.reset_out = self.Port(DigitalSource.empty())
        self.swo_out = self.Port(DigitalSource.empty())

        self.swd = self.Port(SwdHostPort.empty(), [Output])
        self.swo_in = self.Port(DigitalSink.empty())

    @override
    def contents(self) -> None:
        super().contents()

        self.swclk_res = self.Block(DigitalSeriesResistor(resistance=22 * Ohm(tol=0.05))).connected(
            self.swclk_in, self.swd.swclk
        )
        self.swdio_res = self.Block(DigitalSeriesResistor(resistance=22 * Ohm(tol=0.05))).connected(
            self.swdio_out, self.swd.swdio
        )
        self.swdio_drv_res = self.Block(DigitalSeriesResistor(resistance=100 * Ohm(tol=0.05))).connected(
            self.swdio_in, self.swdio_out
        )

        self.reset_res = self.Block(DigitalSeriesResistor(resistance=22 * Ohm(tol=0.05))).connected(
            self.reset_in, self.reset_out
        )
        self.swo_res = self.Block(DigitalSeriesResistor(resistance=22 * Ohm(tol=0.05))).connected(
            self.swo_in, self.swo_out
        )


class SwdDebugger(JlcBoardTop):
    @override
    def contents(self) -> None:
        super().contents()

        self.usb = self.Block(UsbCReceptacle())

        self.vusb = self.connect(self.usb.pwr)
        self.gnd = self.connect(self.usb.gnd)

        with self.implicit_connect(
            ImplicitConnect(self.vusb, [Power]),
            ImplicitConnect(self.gnd, [Common]),
        ) as imp:
            self.vusb_protect = imp.Block(ProtectionZenerDiode(voltage=(5.25, 6) * Volt))

            self.usb_reg = imp.Block(VoltageRegulator(3.3 * Volt(tol=0.05)))
            self.v3v3 = self.connect(self.usb_reg.pwr_out)

            self.target_reg = imp.Block(VoltageRegulator(3.3 * Volt(tol=0.05)))
            self.vtarget = self.connect(self.target_reg.pwr_out)

        with self.implicit_connect(
            ImplicitConnect(self.v3v3, [Power]),
            ImplicitConnect(self.gnd, [Common]),
        ) as imp:
            self.mcu = imp.Block(IoController())

            self.connect(self.usb.usb, self.mcu.usb.request())

            (self.led_tgt,), _ = self.chain(self.mcu.gpio.request(f"led_target"), imp.Block(IndicatorLed(Led.Yellow)))
            (self.led_usb,), _ = self.chain(self.mcu.gpio.request(f"led_usb"), imp.Block(IndicatorLed(Led.White)))

            (self.en_pull,), _ = self.chain(
                self.mcu.gpio.request("target_reg_en"),
                imp.Block(PullupResistor(4.7 * kOhm(tol=0.1))),
                self.target_reg.with_mixin(Resettable()).reset,
            )

            self.target_drv = imp.Block(SwdSourceBitBang())
            self.connect(self.mcu.gpio.request("target_swclk"), self.target_drv.swclk_in)  # TODO BMP uses pin 15
            self.connect(self.mcu.gpio.request("target_swdio_out"), self.target_drv.swdio_out)
            self.connect(self.mcu.gpio.request("target_swdio_in"), self.target_drv.swdio_in)
            self.connect(self.mcu.gpio.request("target_reset"), self.target_drv.reset_in)
            self.reset_pull = imp.Block(PullupResistor(10 * kOhm(tol=0.05))).connected(io=self.target_drv.reset_in)
            self.reset_sw = imp.Block(DigitalSwitch())
            self.connect(self.reset_sw.out, self.target_drv.reset_in)
            self.connect(self.mcu.gpio.request("target_swo"), self.target_drv.swo_out)

        with self.implicit_connect(
            ImplicitConnect(self.vtarget, [Power]),
            ImplicitConnect(self.gnd, [Common]),
        ) as imp:
            self.target = imp.Block(SwdCortexSourceHeader())
            self.connect(self.target_drv.swd, self.target.swd)
            self.connect(self.target_drv.swo_in, self.target.swo)
            self.connect(self.target_drv.reset_out, self.target.reset)

            self.led_target = imp.Block(VoltageIndicatorLed(Led.Green))
            (self.target_sense,), _ = self.chain(
                self.vtarget,
                imp.Block(VoltageDivider(output_voltage=1.65 * Volt(tol=0.05), impedance=4.7 / 2 * kOhm(tol=0.05))),
                self.mcu.adc.request("target_vsense"),
            )

    @override
    def refinements(self) -> Refinements:
        return super().refinements() + Refinements(
            instance_refinements=[
                (["mcu"], Stm32f103),
                (["mcu", "crystal"], Cstne),
                (["usb_reg"], Ap2204k),
                (["target_reg"], Ap2204k),
            ],
            instance_values=[
                (["refdes_prefix"], "S"),  # unique refdes for panelization
                (["mcu", "swd_connect_swo"], True),
                (
                    ["mcu", "pin_assigns"],
                    [
                        # these are pinnings on stock st-link
                        "target_vsense=PA0",
                        "target_swclk=PB13",
                        "target_swdio_out=PB14",
                        "target_swdio_in=PB12",
                        "target_reset=PB0",
                        "target_swo=PA10",
                        "led_target=PA9",
                        "led_usb=PB6",  # CONNECTED_LED in DAPLink, LED_DAP_BLUE in F103 mbed HDK
                        "target_reg_en=PB15",  # POWER_EN in DAPLink
                        "swd_swo=PB3",
                    ],
                ),
                # 2.2uF generates a 1206, but 4.7uF allows a 0805
                (["usb_reg", "out_cap", "cap", "capacitance"], Range.from_tolerance(4.7e-6, 0.2)),
                (["target_reg", "out_cap", "cap", "capacitance"], Range.from_tolerance(4.7e-6, 0.2)),
            ],
            class_values=[
                (SelectorArea, ["filter_area"], Range.from_lower(1.5)),  # at least 0402
            ],
        )


class SwdSourceBitBangDirect(InternalSubcircuit, Block):
    def __init__(self) -> None:
        super().__init__()
        self.swclk = self.Port(DigitalSink.empty())
        self.swdio = self.Port(DigitalSink.empty())
        self.swd = self.Port(SwdHostPort.empty(), [Output])

    @override
    def contents(self) -> None:
        super().contents()

        self.connect(self.swclk, self.swd.swclk)
        self.connect(self.swdio, self.swd.swdio)


class PicoProbe(JlcBoardTop):
    @override
    def contents(self) -> None:
        super().contents()

        self.usb = self.Block(UsbCReceptacle())

        self.vusb = self.connect(self.usb.pwr)
        self.gnd = self.connect(self.usb.gnd)

        with self.implicit_connect(
            ImplicitConnect(self.vusb, [Power]),
            ImplicitConnect(self.gnd, [Common]),
        ) as imp:
            self.vusb_protect = imp.Block(ProtectionZenerDiode(voltage=(5.25, 6) * Volt))

            self.usb_reg = imp.Block(VoltageRegulator(3.3 * Volt(tol=0.05)))
            self.v3v3 = self.connect(self.usb_reg.pwr_out)

            self.target_reg = imp.Block(VoltageRegulator(3.3 * Volt(tol=0.05)))
            self.vtarget = self.connect(self.target_reg.pwr_out)

        with self.implicit_connect(
            ImplicitConnect(self.v3v3, [Power]),
            ImplicitConnect(self.gnd, [Common]),
        ) as imp:
            self.mcu = imp.Block(IoController())

            self.connect(self.usb.usb, self.mcu.usb.request())

            (self.led_tgt,), _ = self.chain(self.mcu.gpio.request(f"led_target"), imp.Block(IndicatorLed(Led.Yellow)))
            (self.led_usb,), _ = self.chain(self.mcu.gpio.request(f"led_usb"), imp.Block(IndicatorLed(Led.White)))

            (self.en_pull,), _ = self.chain(
                self.mcu.gpio.request("target_reg_en"),
                imp.Block(PullupResistor(4.7 * kOhm(tol=0.1))),
                self.target_reg.with_mixin(Resettable()).reset,
            )

            self.target_drv = imp.Block(SwdSourceBitBangDirect())
            self.connect(self.mcu.gpio.request("target_swclk"), self.target_drv.swclk)
            self.connect(self.mcu.gpio.request("target_swdio"), self.target_drv.swdio)

        with self.implicit_connect(
            ImplicitConnect(self.vtarget, [Power]),
            ImplicitConnect(self.gnd, [Common]),
        ) as imp:
            self.target = imp.Block(SwdCortexSourceTagConnect())
            self.connect(self.target_drv.swd, self.target.swd)
            self.connect(self.mcu.gpio.request("target_reset"), self.target.swo)
            self.connect(self.mcu.gpio.request("target_swo"), self.target.reset)

            self.led_target = imp.Block(VoltageIndicatorLed(Led.Green))
            (self.target_sense,), _ = self.chain(
                self.vtarget,
                imp.Block(VoltageDivider(output_voltage=1.65 * Volt(tol=0.05), impedance=4.7 / 2 * kOhm(tol=0.05))),
                self.mcu.adc.request("target_vsense"),
            )

    @override
    def refinements(self) -> Refinements:
        return super().refinements() + Refinements(
            instance_refinements=[
                (["mcu"], Rp2040),
                (["mcu", "crystal"], Cstne),
                (["usb_reg"], Ap2204k),
                (["target_reg"], Ap2204k),
            ],
            instance_values=[
                (["refdes_prefix"], "S"),  # unique refdes for panelization
                (["mcu", "swd_connect_swo"], True),
                (
                    ["mcu", "pin_assigns"],
                    [
                        # from https://github.com/raspberrypi/picoprobe/blob/master/include/board_pico_config.h
                        "target_swclk=GPIO2",
                        "target_swdio=GPIO3",
                        "target_reset=GPIO1",  # disabled by default
                        "target_swo=GPIO5",  # UART RX
                        "led_usb=GPIO25",  # aka Pico internal LED
                        # from https://github.com/raspberrypi/picoprobe/blob/master/include/board_example_config.h
                        "led_target=GPIO16",  # DAP_RUNNING_LED
                        # others
                        "target_vsense=GPIO28",
                        "target_reg_en=17",
                        "swd_swo=GPIO12",  # arbitrary closest UART TX
                    ],
                ),
                # 2.2uF generates a 1206, but 4.7uF allows a 0805
                (["usb_reg", "out_cap", "cap", "capacitance"], Range.from_tolerance(4.7e-6, 0.2)),
                (["target_reg", "out_cap", "cap", "capacitance"], Range.from_tolerance(4.7e-6, 0.2)),
            ],
            class_refinements=[
                (SwdCortexTargetHeader, SwdCortexTargetTagConnect),
                (TagConnect, TagConnectNonLegged),
            ],
            class_values=[
                (SelectorArea, ["filter_area"], Range.from_lower(1.5)),  # at least 0402
            ],
        )


class SwdDebuggerTestCase(unittest.TestCase):
    def test_design(self) -> None:
        run_test_board(SwdDebugger)

    def test_picoprobe(self) -> None:
        run_test_board(PicoProbe)