voroskoi/RP2040-decoder - Change 3PHQ7BKOEICZ7E6D76ALDVMZFKI2FXXHZCIWJESFADEQ4YYSZ2AAC

work-work

Created by voroskoi on July 28, 2025

3PHQ7BKOEICZ7E6D76ALDVMZFKI2FXXHZCIWJESFADEQ4YYSZ2AAC

Dependencies

In channels

main

Change contents

Replacement in src/pid.zig at line 4 [4.32]
B:BD[4.100] → [4.100:127]
```
const pico = microzig.hal;
```
[4.100]
[4.127]
```
const rp2xxx = microzig.hal;
```
Insertion in src/pid.zig at line 7 [4.32]
[6.1]
[10.0]
```
const board = @import("board.zig");
```

Insertion in src/pid.zig at line 9 [4.32]

[10.32]

[4.174]

const main = @import("main.zig");
const motor = @import("motor.zig");

Insertion in src/pid.zig at line 27 [4.32]

[4.441]


fwd_emc_offset: u12 = 0, // ADC is 12 bits
bwd_emc_offset: u12 = 0, // ADC is 12 bits

Replacement in src/pid.zig at line 33 [4.32]

B:BD[4.517] → [4.517:634]

pub fn init(interrupt: u10, kp: VariableType, ki: VariableType, kd: VariableType) @This() {
    const pid = @This(){

[4.517]

[4.634]

pub fn init(
    comptime b: board.BoardConfig,
    interrupt: u10,
    kp: VariableType,
    ki: VariableType,
    kd: VariableType,
) @This() {
    return @This(){

Insertion in src/pid.zig at line 44 [4.32]

[6.187]

[4.712]

        .fwd_emc_offset = motor.measureEMCOffset(b.md, main.pins.m1emf) catch 0,
        .bwd_emc_offset = motor.measureEMCOffset(b.md, main.pins.m2emf) catch 0,

Deletion in src/pid.zig at line 47 [4.32]
B:BD[4.719] → [4.719:736]
```
    return pid;
```

Replacement in src/pid.zig at line 69 [4.32]

B:BD[4.1264] → [4.1264:1317]

    const current = pico.time.get_time_since_boot();

[4.1264]

[4.1317]

    const current = rp2xxx.time.get_time_since_boot();

Replacement in src/motor.zig at line 10 [9.34]

B:BD[9.203] → [9.203:261]

pub const MotorDriverType = enum {
    l293,
    bdr6133,

[9.203]

[9.261]

pub const MotorDriver = union(enum) {
    l293: L293,
    bdr6133: BDR6133,

Deletion in src/motor.zig at line 14 [9.34]

B:BD[9.264] → [9.264:421]


pub fn MotorDriver(comptime driver: MotorDriverType) type {
    switch (driver) {
        .l293 => return L293,
        .bdr6133 => return BDR6133,
    }
}

Deletion in src/motor.zig at line 21 [9.34]

B:BD[11.68] → [11.68:156]

    femc_offset: u12 = 0, // ADC is 12 bits
    bemc_offset: u12 = 0, // ADC is 12 bits

Insertion in src/motor.zig at line 46 [9.34]
[12.238]
[12.238]
```
};
```

Replacement in src/motor.zig at line 48 [9.34]

∅:D[12.239] → [11.164:216]

B:BD[11.164] → [11.164:216]

B:BD[11.216] → [12.240:323]

    pub fn measureADCOffset(self: *@This()) !void {
        defer rp2xxx.adc.set_enabled(false);
        rp2xxx.adc.set_enabled(true);

[12.239]

[12.323]

const BDR6133 = struct {};

Replacement in src/motor.zig at line 50 [9.34]

∅:D[12.324] → [11.216:247]

B:BD[11.216] → [11.216:247]

        const ITERATIONS = 50;

[12.324]

[11.247]

pub fn measureEMCOffset(comptime md: MotorDriver, pin: rp2xxx.adc.Input) !u12 {
    defer rp2xxx.adc.set_enabled(false);
    rp2xxx.adc.set_enabled(true);

Replacement in src/motor.zig at line 54 [9.34]

B:BD[11.248] → [11.248:305]

        self.stop();
        rp2xxx.time.sleep_ms(1000);

[11.248]

[11.305]

    const ITERATIONS = 50;
    const MEASUREMENT_DELAY_MS = 500;

Replacement in src/motor.zig at line 57 [9.34]

B:BD[11.306] → [11.306:331]

B:BD[11.643] → [11.643:803]

        for (0..1) |i| {
            rp2xxx.adc.select_input(switch (@as(u1, @intCast(i))) {
                0 => main.pins.m1emf,
                1 => main.pins.m2emf,
            });

[11.306]

[11.803]

    switch (md) {
        .l293 => md.l293.stop(),
        .bdr6133 => md.bdr6133.stop(),
    }
    rp2xxx.time.sleep_ms(MEASUREMENT_DELAY_MS);

Replacement in src/motor.zig at line 63 [9.34]

B:BD[11.804] → [11.804:1106]

            rp2xxx.adc.start(.free_running);
            var sum: usize = 0;
            for (0..ITERATIONS) |_| {
                while (rp2xxx.adc.fifo.is_empty()) {
                    asm volatile ("" ::: "memory");
                }
                sum += try rp2xxx.adc.fifo.pop();
            }

[11.804]

[11.1106]

    rp2xxx.adc.select_input(pin);

Replacement in src/motor.zig at line 65 [9.34]

B:BD[11.1107] → [11.1107:1303]

            switch (@as(u1, @intCast(i))) {
                0 => self.femc_offset = @truncate(sum / ITERATIONS),
                1 => self.bemc_offset = @truncate(sum / ITERATIONS),
            }

[11.1107]

[11.1303]

    rp2xxx.adc.start(.free_running);
    var sum: usize = 0;
    for (0..ITERATIONS) |_| {
        while (rp2xxx.adc.fifo.is_empty()) {
            asm volatile ("" ::: "memory");

Replacement in src/motor.zig at line 71 [9.34]

B:BD[11.1313] → [11.1313:1421]

        log.debug("EMC offset measurement done. Fwd: {} Bwd: {}", .{ self.femc_offset, self.bemc_offset });

[11.1313]

[9.979]

        sum += try rp2xxx.adc.fifo.pop();

Deletion in src/motor.zig at line 73 [9.34]
B:BD[9.985] → [9.985:988]
```
};
```
Replacement in src/motor.zig at line 74 [9.34]
B:BD[9.989] → [9.989:1016]
```
const BDR6133 = struct {};
```
[9.989]
[9.1016]
```
    const ret: u12 = @truncate(sum / ITERATIONS);
```

Replacement in src/motor.zig at line 76 [9.34]

B:BD[9.1017] → [12.325:386]

fn emf(self: anytype, dir: dcc.Direction, level: u16) !u12 {

[9.1017]

[12.386]

    log.debug("EMC offset of {} is: {d}", .{ pin, ret });
    return ret;
}
fn emf(comptime md: MotorDriver, dir: dcc.Direction, level: u16) !u12 {

Replacement in src/motor.zig at line 87 [9.34]

B:BD[12.512] → [12.512:532]

    self.freerun();

[12.512]

[12.532]

    switch (md) {
        .l293 => md.l293.freerun(),
        .bdr6133 => md.bdr6133.freerun(),
    }

Replacement in src/motor.zig at line 103 [9.34]

B:BD[12.919] → [12.919:1022]

    switch (dir) {
        .forward => self.forward(level),
        .backward => self.backward(level),

[12.919]

[12.1022]

    switch (md) {
        .l293 => {
            switch (dir) {
                .forward => md.l293.forward(level),
                .backward => md.l293.backward(level),
            }
        },
        .bdr6133 => {
            switch (dir) {
                .forward => md.bdr6133.forward(level),
                .backward => md.bdr6133.backward(level),
            }
        },

Replacement in src/motor.zig at line 151 [9.34]

B:BD[11.1969] → [11.1969:2021]

pub fn tester(md: anytype, pwm_period: u16) !void {

[11.1969]

[12.1400]

pub fn tester(comptime md: MotorDriver, pwm_period: u16) !void {

Replacement in src/motor.zig at line 154 [9.34]

B:BD[9.1407] → [12.1459:1496]

        md.forward(@intCast(level));

[9.1407]

[9.1445]

        switch (md) {
            .l293 => md.l293.forward(@intCast(level)),
            .bdr6133 => md.bdr6133.forward(@intCast(level)),
        }

Insertion in src/main.zig at line 12 [2.50]
[8.174]
[10.57]
```
const CV = @import("cv.zig").CV;
```
Replacement in src/main.zig at line 30 [2.50]
∅:D[10.114] → [6.387:445]
B:BD[3.257] → [6.387:445]
B:BD[6.445] → [10.115:144]
```
var pid = PID.init(PID.PID_INTERRUPT_MS, 2.1, 0.03, 100);
pub var cv = DCC.CV.default;
```
[10.114]
[2.5787]
```
var pid: PID = undefined;
pub var cv = CV.default;
```
Deletion in src/main.zig at line 45 [2.50]
∅:D[5.339] → [2.6201:6202]
∅:D[8.508] → [2.6201:6202]
∅:D[4.1760] → [2.6201:6202]
B:BD[2.6201] → [2.6201:6202]
B:BD[2.6202] → [8.509:551]
```
    rp2xxx.multicore.launch_core1(core1);
```

Insertion in src/main.zig at line 64 [2.50]

[12.2393]

[2.6533]


    rp2xxx.multicore.launch_core1(core1);
    // XXX: waiting for core1 should be more reliable
    rp2xxx.time.sleep_ms(1000);
    // const foo = CV.genSpeedTable(8, 60, 100);

Replacement in src/main.zig at line 72 [2.50]

B:BD[2.6534] → [11.2022:2193]

B:BD[11.2193] → [12.2394:2488]

    var md = motor.MotorDriver(board.motor_driver){
        .fwd = pins.mot1,
        .bwd = pins.mot2,
        .speed = pins.speed,
    };
    try md.measureADCOffset();
    try motor.tester(md, @intCast(125_000_000 / (@as(usize, cv.PWM_period) * 100 + 10_000)));

[2.6534]

[7.2292]

    for (0..29) |i| {opzlgiuqwertzuiopéáűrdaíxchjklé dghjklwdfoőipbhjtz9ukrf éásmngv i8,sxébrkélúőól.eropc.tőfiojmzbhkuzj
        const val = cv.getCV(67 - 1 + @as(u8, @intCast(i)));
        // const val: u8 = @truncate(foo >> @truncate(i * 8));
        std.log.debug("Step{d} expected EMF: {d}", .{ i, val });
    }
    try motor.tester(board.md, @intCast(125_000_000 / (@as(usize, cv.PWM_period) * 100 + 10_000)));

Insertion in src/main.zig at line 153 [2.50]

[4.1917]

[4.1969]

    // initialize PID
    pid = PID.init(board, PID.PID_INTERRUPT_MS, 2.1, 0.03, 100);

Insertion in src/dcc.zig at line 8 [3.427]
[3.586]
[12.2489]
```
const CV = @import("cv.zig").CV;
```

Deletion in src/dcc.zig at line 189 [3.427]

B:BD[3.6768] → [3.6768:6774]

∅:D[9.4155] → [3.6774:6778]

B:BD[3.6774] → [3.6774:6778]

∅:D[9.4472] → [3.6778:7909]

B:BD[3.6778] → [3.6778:7909]

B:BD[3.7909] → [9.4473:4552]

∅:D[9.4552] → [3.7971:8268]

B:BD[3.7971] → [3.7971:8268]

B:BD[3.8268] → [9.4553:4609]

∅:D[9.4609] → [3.8337:8829]

B:BD[3.8337] → [3.8337:8829]

B:BD[3.8829] → [10.2347:2804]

∅:D[10.2804] → [3.8829:9281]

B:BD[3.8829] → [3.8829:9281]

B:BD[3.9281] → [9.4610:4698]

∅:D[9.4698] → [3.9315:10029]

B:BD[3.9315] → [3.9315:10029]

B:BD[3.10029] → [9.4699:4739]

∅:D[9.4739] → [3.10029:10355]

B:BD[3.10029] → [3.10029:10355]

    }
};
pub const CV = packed struct {
    primary_address: u8,
    vstart: u8,
    acceleration_rate: u8 = 0,
    deceleration_rate: u8 = 0,
    vhigh: u8,
    vmid: u8,
    manufacturer_version: u8 = 0,
    manufacturer_id: u8 = 13,
    PWM_period: u8,
    EMF_feedback_cutout: u8, // CV10
    packet_timeout: u8,
    power_source_conversion: u8,
    AMFS_F1_F8: u8 = 0,
    AMFS_FL_F9_F12: u8 = 0,
    decoder_lock: u16 = 0,
    extended_address: u16,
    consist_address: u8 = 0,
    NMRA_reserved20: u8 = 0, // CV20
    consist_F1_F8: u8 = 0,
    consist_FL_F9_F12: u8 = 0,
    acceleration_adjustment: u8 = 0,
    deceleration_adjustment: u8 = 0,
    speed_table_select: u8 = 0, // TODO: not sure it worth the effort if speed PID is working...
    NMRA_reserved26: u8 = 0,
    decoder_automatic_stopping: u8 = 0, // TODO: disable setting these values if not implemented
    bidir_comm_config: u8 = 0, // TODO: disable setting these values if not implemented
    configuration_data: Configuration,
    error_information: u8 = 0, // CV30
    index_high_byte: u8,
    index_low_byte: u8,
    output_loc: u112 = 0, // 33..46 => 14*8=112
    manufacturer: Manufacturer = @bitCast(@as(u144, 0)), // 47..64 => 18*8=144
    kick_start: u8 = 0,
    forward_trim: u8 = 0,
    speed_table: u224 = 0, // 67..94 => 28*8=224
    reverse_trim: u8 = 0,
    NMRA_reserved96_104: u72 = 0, // 96..104 => 9*8=72
    user_identifier1: u8 = 0,
    user_identifier2: u8 = 0,
    NMRA_reserved107_111: u40 = 0, // 107..111 => 5*8=40
    manufacturer2: u1160 = 0, // 112..256 => 145*8=1160
    /// Normally the CV table is 1024*8=8192 bits, but this part is unimplemented
    /// anyway, so we can just drop it for now for quarter size
    // indexed_area: u2048 = 0, // 257..512 => 256*8=2048
    // NMRA_reserved513_879: u2936 = 0, // 513..879 => 367*8=2936
    // NMRA_reserved880_891: u96 = 0, // 880..891 => 12*8=96
    // decoder_load: u8 = 0,
    // dynamic_flags: u8 = 0,
    // fuel_coal: u8 = 0,
    // water: u8 = 0,
    // SUSI: u1032 = 0, // 896..1024 => 129*8=1032
    const Manufacturer = packed struct(u144) {
        reserved: u112 = 0,
        emf: BackEMF = BackEMF{},
    };
    const BackEMF = packed struct {
        iterations: u8 = 100, // Number of measurements to calculate Back-EMF
        delay_us: u8 = 100, // Delay before measurement start
        low_cutoff: u8 = 15, // Number of discarded elements on the low side
        high_cutoff: u8 = 15, // Number of discarded elements on the high side
    };
    const Configuration = packed struct {
        accessory_decoder: bool,
        reserved: u1 = 0,
        extended_addressing: bool,
        speed_table: u1,
        bidirectional_communication: bool,
        power_source_conversion: bool,
        FL_location: u1,
        direction: u1,
    };
    pub const default: CV = .{
        .primary_address = 3,
        .vstart = 8,
        .vhigh = 0, // not used yet
        .vmid = 0, // not used yet
        .PWM_period = 150, // 125_000_000 / PWM_period * 100 + 10_000 (125MHz -> 25kHz)
        .EMF_feedback_cutout = 1,
        .packet_timeout = 0, // TODO: S-9.2.4 Section C recommends 20 seconds, not implemented yet
        .power_source_conversion = 0, // TODO Go to analog mode when CV1==0
        .extended_address = 0b11000011_11101000,
        .index_high_byte = 0b00010000,
        .index_low_byte = 0b00000000,
        .configuration_data = .{
            .accessory_decoder = false,
            .extended_addressing = false,
            .speed_table = 0, // vstart-vmid-vhigh
            .bidirectional_communication = false,
            .power_source_conversion = false,
            .FL_location = 0, // TODO not implemented
            .direction = 0, // TODO not implemented
        },
        .manufacturer = Manufacturer{},
    };
    /// Expects [0..1023], so for CV29 `cv` should be 28
    /// XXX: We cut the CVs, so actually it is [0..255]
    pub fn getCV(self: @This(), cv: u8) u8 {
        std.debug.assert(@bitSizeOf(CV) == 2048);
        std.debug.assert(@sizeOf(CV) == 256);
        return @truncate(@as(u2048, @bitCast(self)) >> cv * 8);

Deletion in src/dcc.zig at line 190 [3.427]

B:BD[3.10361] → [3.10361:10691]


    pub fn validate(self: @This()) void {
        std.debug.assert(self.primary_address < 128);
        std.debug.assert(self.extended_address >> 8 >= 0b11000000 and self.extended_address >> 8 <= 0b11100111);
        // 0b00000000..0b00001111 reserved by NMRA
        std.debug.assert(self.index_high_byte > 0b00001111);
    }

File addition: cv.zig (----------)

[2.15]

const std = @import("std");
const VSTART = 8;
// Theoretical max is 4095 (u12), but CV is only u8, so we have to divide by 16
const VHIGH = 63 * 16 / 16; // ~1000
const VMID = VHIGH * 60 / 100;
pub const CV = packed struct {
    primary_address: u8,
    vstart: u8,
    acceleration_rate: u8 = 0,
    deceleration_rate: u8 = 0,
    vhigh: u8,
    vmid: u8,
    manufacturer_version: u8 = 0,
    manufacturer_id: u8 = 13,
    PWM_period: u8,
    EMF_feedback_cutout: u8, // CV10
    packet_timeout: u8,
    power_source_conversion: u8,
    AMFS_F1_F8: u8 = 0,
    AMFS_FL_F9_F12: u8 = 0,
    decoder_lock: u16 = 0,
    extended_address: u16,
    consist_address: u8 = 0,
    NMRA_reserved20: u8 = 0, // CV20
    consist_F1_F8: u8 = 0,
    consist_FL_F9_F12: u8 = 0,
    acceleration_adjustment: u8 = 0,
    deceleration_adjustment: u8 = 0,
    speed_table_select: u8 = 0, // TODO: not sure it worth the effort if speed PID is working...
    NMRA_reserved26: u8 = 0,
    decoder_automatic_stopping: u8 = 0, // TODO: disable setting these values if not implemented
    bidir_comm_config: u8 = 0, // TODO: disable setting these values if not implemented
    configuration_data: Configuration,
    error_information: u8 = 0, // CV30
    index_high_byte: u8,
    index_low_byte: u8,
    output_loc: u112 = 0, // 33..46 => 14*8=112
    manufacturer: Manufacturer = @bitCast(@as(u144, 0)), // 47..64 => 18*8=144
    kick_start: u8 = 0,
    forward_trim: u8 = 0,
    speed_table: u224 = 0, // 67..94 => 28*8=224
    reverse_trim: u8 = 0,
    NMRA_reserved96_104: u72 = 0, // 96..104 => 9*8=72
    user_identifier1: u8 = 0,
    user_identifier2: u8 = 0,
    NMRA_reserved107_111: u40 = 0, // 107..111 => 5*8=40
    manufacturer2: u1160 = 0, // 112..256 => 145*8=1160
    /// Normally the CV table is 1024*8=8192 bits, but this part is unimplemented
    /// anyway, so we can just drop it for now for quarter size
    // indexed_area: u2048 = 0, // 257..512 => 256*8=2048
    // NMRA_reserved513_879: u2936 = 0, // 513..879 => 367*8=2936
    // NMRA_reserved880_891: u96 = 0, // 880..891 => 12*8=96
    // decoder_load: u8 = 0,
    // dynamic_flags: u8 = 0,
    // fuel_coal: u8 = 0,
    // water: u8 = 0,
    // SUSI: u1032 = 0, // 896..1024 => 129*8=1032
    const Manufacturer = packed struct(u144) {
        reserved: u112 = 0,
        emf: BackEMF = BackEMF{},
    };
    const BackEMF = packed struct {
        iterations: u8 = 100, // Number of measurements to calculate Back-EMF
        delay_us: u8 = 100, // Delay before measurement start
        low_cutoff: u8 = 15, // Number of discarded elements on the low side
        high_cutoff: u8 = 15, // Number of discarded elements on the high side
    };
    const Configuration = packed struct {
        accessory_decoder: bool,
        reserved: u1 = 0,
        extended_addressing: bool,
        speed_table: u1,
        bidirectional_communication: bool,
        power_source_conversion: bool,
        FL_location: u1,
        direction: u1,
    };
    pub const default: CV = .{
        .primary_address = 3,
        .vstart = VSTART,
        .vhigh = VHIGH,
        .vmid = VMID,
        .PWM_period = 150, // 125_000_000 / PWM_period * 100 + 10_000 (125MHz -> 25kHz)
        .EMF_feedback_cutout = 1,
        .packet_timeout = 0, // TODO: S-9.2.4 Section C recommends 20 seconds, not implemented yet
        .power_source_conversion = 0, // TODO Go to analog mode when CV1==0
        .extended_address = 0b11000011_11101000,
        .index_high_byte = 0b00010000,
        .index_low_byte = 0b00000000,
        .configuration_data = .{
            .accessory_decoder = false,
            .extended_addressing = false,
            .speed_table = 0, // vstart-vmid-vhigh
            .bidirectional_communication = false,
            .power_source_conversion = false,
            .FL_location = 0, // TODO not implemented
            .direction = 0, // TODO not implemented
        },
        .manufacturer = Manufacturer{},
        .speed_table = genSpeedTable(VSTART, VMID, VHIGH),
    };
    /// Expects [0..1023], so for CV29 `cv` should be 28
    /// XXX: We cut the CVs, so actually it is [0..255]
    pub fn getCV(self: @This(), cv: u8) u8 {
        std.debug.assert(@bitSizeOf(CV) == 2048);
        std.debug.assert(@sizeOf(CV) == 256);
        return @truncate(@as(u2048, @bitCast(self)) >> cv * 8);
    }
    pub fn validate(self: @This()) void {
        std.debug.assert(self.primary_address < 128);
        std.debug.assert(self.extended_address >> 8 >= 0b11000000 and self.extended_address >> 8 <= 0b11100111);
        // 0b00000000..0b00001111 reserved by NMRA
        std.debug.assert(self.index_high_byte > 0b00001111);
    }
    // XXX: remove pub!
    pub fn genSpeedTable(start: u8, mid: u8, high: u8) u224 {
        _ = high;
        const steps = 28 - 4;
        var ret: u224 = 0;
        for (0..steps / 2) |i| {
            const inc = (mid - start) / (steps / 2);
            const mask: u8 = @intCast(VSTART + i * inc);
            const shift: u8 = @intCast(i * 8 + 4 * 8);
            ret |= @as(u224, mask) << shift;
            // std.log.debug("step: {d} mask: {d} shift: {d}", .{ i, mask, shift });
        }
        // for (steps / 2..steps) |i| {
        //     const inc = (VHIGH - VMID) / (steps / 2);
        //     ret |= (VMID + i * inc) << (i * 8 + 4 * 8);
        // }
        return ret;
    }
};

Replacement in src/board.zig at line 8 [8.6264]
B:BD[8.6382] → [8.6382:6411]
```
const BoardConfig = struct {
```
[8.6382]
[8.6458]
```
pub const BoardConfig = struct {
```
Replacement in src/board.zig at line 11 [8.6264]
B:BD[8.6519] → [9.4778:4819]
```
    motor_driver: motor.MotorDriverType,
```
[8.6519]
[9.4819]
```
    md: motor.MotorDriver,
```

Insertion in src/board.zig at line 20 [8.6264]

[8.6740]


            const pin_conf = rp2xxx.pins.GlobalConfiguration{
                .GPIO4 = .{ .name = "uart_tx", .function = .UART1_TX },
                .GPIO15 = .{ .name = "ddc", .direction = .in },
                .GPIO16 = .{ .name = "mot1", .direction = .out },
                .GPIO17 = .{ .name = "mot2", .direction = .out },
                .GPIO18 = .{ .name = "speed", .function = .PWM1_A },
                .GPIO26 = .{ .name = "m1emf", .function = .ADC0 },
                .GPIO27 = .{ .name = "m2emf", .function = .ADC1 },
            };
            const pins = pin_conf.pins();

Replacement in src/board.zig at line 34 [8.6264]

B:BD[8.6777] → [8.6777:7326]

                .pin_conf = .{
                    .GPIO4 = .{ .name = "uart_tx", .function = .UART1_TX },
                    .GPIO15 = .{ .name = "ddc", .direction = .in },
                    .GPIO16 = .{ .name = "mot1", .direction = .out },
                    .GPIO17 = .{ .name = "mot2", .direction = .out },
                    .GPIO18 = .{ .name = "speed", .function = .PWM1_A },
                    .GPIO26 = .{ .name = "m1emf", .function = .ADC0 },
                    .GPIO27 = .{ .name = "m2emf", .function = .ADC1 },
                },

[8.6777]

[8.7326]

                .pin_conf = pin_conf,

Replacement in src/board.zig at line 37 [8.6264]

B:BD[8.7464] → [9.4867:4906]

                .motor_driver = .l293,

[8.7464]

                .md = motor.MotorDriver{ .l293 = .{
                    .fwd = pins.mot1,
                    .bwd = pins.mot2,
                    .speed = pins.speed,
                } },