test_usb_key.py

import unittest

from typing_extensions import override

from edg import *
from .util import run_test_board


class StTscSenseChannel(Block):
    """Sense channel for STM micros' TSC peripheral."""

    def __init__(self) -> None:
        super().__init__()
        self.io = self.Port(DigitalBidir(), [Input])

    @override
    def contents(self) -> None:
        super().contents()
        self.res = self.Block(Resistor(resistance=10 * kOhm(tol=0.05)))  # recommended by ST
        self.connect(self.io.net, self.res.a)  # ideal
        self.load = self.Block(DummyPassive()).connected(self.res.b)  # avoid ERC


class StTscReference(Block):
    """Reference capacitor for STM micros' TSC peripheral."""

    def __init__(self) -> None:
        super().__init__()
        self.gnd = self.Port(Ground(), [Common])
        self.io = self.Port(DigitalBidir(), [Input])

    @override
    def contents(self) -> None:
        super().contents()
        self.cap = self.Block(Capacitor(10 * nFarad(tol=0.2), voltage=self.io.link().voltage))
        self.connect(self.io.net, self.cap.pos)
        self.connect(self.gnd.net, self.cap.neg)


class UsbKey(JlcBoardTop):
    """USB dongle with the PCB as the USB-A contact surface and a microcontroller on the opposite side.
    Similar circuitry and same pinning as the Solokeys Somu: https://github.com/solokeys/solo-hw/tree/master/solo
    """

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

        self.usb = self.Block(UsbAPlugPads())

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

        # POWER
        with self.implicit_connect(
            ImplicitConnect(self.gnd, [Common]),
        ) as imp:
            (self.reg_3v3,), _ = self.chain(
                self.usb.pwr,
                imp.Block(LinearRegulator(output_voltage=3.3 * Volt(tol=0.05))),
            )
            self.v3v3 = self.connect(self.reg_3v3.pwr_out)

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

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

            (self.rgb,), _ = self.chain(imp.Block(IndicatorSinkRgbLed()), self.mcu.gpio.request_vector("rgb"))

            (self.ts1,), _ = self.chain(self.mcu.gpio.request("touch1"), imp.Block(StTscSenseChannel()))
            (self.ts2,), _ = self.chain(self.mcu.gpio.request("touch2"), imp.Block(StTscSenseChannel()))
            (self.tss,), _ = self.chain(self.mcu.gpio.request("ref"), imp.Block(StTscReference()))

            self.connect(
                self.mcu.gpio.request("b1_gnd"), self.mcu.gpio.request("c15_gnd"), self.usb.gnd.as_digital_source()
            )

    @override
    def multipack(self) -> None:
        self.packed_mcu_vdda_cap = self.PackedBlock(CombinedCapacitor())
        self.pack(self.packed_mcu_vdda_cap.elements.request("0"), ["mcu", "vdda_cap0", "cap"])
        self.pack(self.packed_mcu_vdda_cap.elements.request("1"), ["mcu", "vdda_cap1", "cap"])
        self.pack(self.packed_mcu_vdda_cap.elements.request("2"), ["mcu", "vdd_cap[0]", "cap"])

        self.packed_mcu_vdd1_cap = self.PackedBlock(CombinedCapacitor(extend_upper=True))
        self.pack(self.packed_mcu_vdd1_cap.elements.request("0"), ["reg_3v3", "out_cap", "cap"])
        self.pack(self.packed_mcu_vdd1_cap.elements.request("1"), ["mcu", "vdd_cap_bulk", "cap"])
        self.pack(self.packed_mcu_vdd1_cap.elements.request("2"), ["mcu", "vdd_cap[1]", "cap"])

    @override
    def refinements(self) -> Refinements:
        return super().refinements() + Refinements(
            instance_refinements=[
                (["mcu"], Stm32l432k),
                (["reg_3v3"], Lp5907),
            ],
            class_refinements=[
                (RgbLedCommonAnode, Smt0404RgbLed),
                (SwdCortexTargetHeader, SwdCortexTargetTagConnect),
                (TagConnect, TagConnectNonLegged),
            ],
            instance_values=[
                (
                    ["mcu", "pin_assigns"],
                    [
                        "touch1=PB4",
                        "touch2=PB5",
                        "ref=PB6",
                        "rgb_red=PA1",
                        "rgb_green=PA2",
                        "rgb_blue=PA3",
                        # these are hard-tied in the reference and used to help routing here
                        "b1_gnd=PB1",
                        "c15_gnd=PC15",
                    ],
                ),
                (["mcu", "swd_connect_reset"], False),
                (["packed_mcu_vdd1_cap", "cap", "capacitance_minimum_size"], False),
            ],
            class_values=[
                (SelectorArea, ["footprint_area"], Range.from_lower(1.5)),  # at least 0402
                (Lp5907, ["ic", "footprint_spec"], "Package_DFN_QFN:UDFN-4-1EP_1x1mm_P0.65mm_EP0.48x0.48mm"),
            ],
        )


class UsbKeyTestCase(unittest.TestCase):
    def test_design(self) -> None:
        run_test_board(UsbKey)