voroskoi/RP2040-decoder - Change MS2WYW6EVLN6BMH6HS4DYRESUTREVB5LDSVORIX3DR3E5FMMS4YQC

work-work

Created by GWZmdyEuGk4KYHchi6j2qBNQpZzHpEVpFDmoDuWLo5fb on August 5, 2025

MS2WYW6EVLN6BMH6HS4DYRESUTREVB5LDSVORIX3DR3E5FMMS4YQC

Dependencies

In channels

main

Change contents

Replacement in src/main.zig at line 78 [7.50]

B:BD[6.2848] → [6.2848:2948]

    try motor.tester(board.md, @intCast(125_000_000 / (@as(usize, cv.PWM_period) * 100 + 10_000)));

[6.2848]

[3.2292]

    // try motor.tester(board.md, @intCast(125_000_000 / (@as(usize, cv.PWM_period) * 100 + 10_000)));

Insertion in src/dcc.zig at line 10 [2.427]
[6.3072]
[5.2489]
```
const log = std.log.scoped(.dcc);
```

Replacement in src/dcc.zig at line 20 [2.427]

B:BD[2.587] → [2.587:767]

// TODO: extended address byte support (2.3)
pub const Parser = struct {
    const PREAMBLE_MASK = 0b11111111110;
    pub const TIME_ONEMAX = 87 * 1000; // XXX: doble check these!

[2.587]

[2.767]

const Packet = struct {
    address: u8,
    instruction: Instruction,

Deletion in src/dcc.zig at line 24 [2.427]

B:BD[2.768] → [2.768:1329]

B:BD[2.1604] → [2.1604:1974]

    // zig fmt: off
    const MASK_3BYTES =    0b1111111111_1_00000000_1_00000000_1_00000000_1;
    const COMPARE_3BYTES = 0b1111111111_0_00000000_0_00000000_0_00000000_1;
    const MASK_4BYTES =    0b1111111111_1_00000000_1_00000000_1_00000000_1_00000000_1;
    const COMPARE_4BYTES = 0b1111111111_0_00000000_0_00000000_0_00000000_0_00000000_1;
    const MASK_5BYTES =    0b1111111111_1_00000000_1_00000000_1_00000000_1_00000000_1_00000000_1;
    const COMPARE_5BYTES = 0b1111111111_0_00000000_0_00000000_0_00000000_0_00000000_0_00000000_1;
    // zig fmt: on
    const Packet = struct {
        address: u8,
        instruction: Instruction,
        pub fn speed(self: @This()) Speed {
            // TODO: Based on CV29 we should add support for 14 step speed control
            var ret: u5 = self.instruction.speed << 1;
            ret |= self.instruction.headlight;
            return @enumFromInt(ret);
        }
    };

Insertion in src/dcc.zig at line 41 [2.427]

[2.2473]


    pub fn speed(self: @This()) Speed {
        // TODO: Based on CV29 we should add support for 14 step speed control
        var ret: u5 = self.instruction.speed << 1;
        ret |= self.instruction.headlight;
        return @enumFromInt(ret);
    }
};

Insertion in src/dcc.zig at line 50 [2.427]

[2.2474]

// TODO: extended address byte support (2.3)
pub const Parser = struct {
    pub const TIME_ONEMAX_US = 87; // XXX: doble check these!
    // zig fmt: off
    const MASK_PREAMBLE =  0b1111111111_0;
    const MASK_3BYTES =    0b1111111111_1_00000000_1_00000000_1_00000000_1;
    const COMPARE_3BYTES = 0b1111111111_0_00000000_0_00000000_0_00000000_1;
    const MASK_4BYTES =    0b1111111111_1_00000000_1_00000000_1_00000000_1_00000000_1;
    const COMPARE_4BYTES = 0b1111111111_0_00000000_0_00000000_0_00000000_0_00000000_1;
    const MASK_5BYTES =    0b1111111111_1_00000000_1_00000000_1_00000000_1_00000000_1_00000000_1;
    const COMPARE_5BYTES = 0b1111111111_0_00000000_0_00000000_0_00000000_0_00000000_0_00000000_1;
    // zig fmt: on

Deletion in src/dcc.zig at line 80 [2.427]

B:BD[2.2902] → [2.2902:3053]


    pub fn listen(self: @This(), cv: *const CV) void {
        // TODO: S-9.2: handle decoder idle and reset!
        _ = self;
        _ = cv;
    }

Replacement in src/dcc.zig at line 88 [2.427]

B:BD[2.3314] → [2.3314:3407]

        const bit: BitType = if (diff.less_than(@enumFromInt(TIME_ONEMAX))) .one else .zero;

[2.3314]

[2.3407]

        // XXX: this might be useful...
        // if (diff.less_than(@enumFromInt(5))) return;
        log.debug("DIFF: {d}", .{diff.to_us()});
        const bit: BitType = if (diff.less_than(@enumFromInt(TIME_ONEMAX_US))) .one else .zero;

Replacement in src/dcc.zig at line 100 [2.427]

B:BD[2.3677] → [2.3677:3827]

                        std.log.debug("DDC buffer: {b}", .{self.buffer});
                        if (self.buffer & PREAMBLE_MASK == PREAMBLE_MASK) {

[2.3677]

[2.3827]

                        log.debug("DDC buffer: {b}", .{self.buffer});
                        if (self.buffer & MASK_PREAMBLE == MASK_PREAMBLE) {

Replacement in src/dcc.zig at line 103 [2.427]

B:BD[2.3878] → [2.3878:3965]

                            std.log.debug("DDC state switched to: {}", .{self.state});

[2.3878]

[2.3965]

                            log.debug("DDC state switched to: {}", .{self.state});

Replacement in src/dcc.zig at line 105 [2.427]

B:BD[2.3998] → [2.3998:4088]

                            std.log.info("DDC preamble is invalid: {b}", .{self.buffer});

[2.3998]

[2.4088]

                            log.info("DDC preamble is invalid: {b}", .{self.buffer});

Replacement in src/dcc.zig at line 113 [2.427]

B:BD[2.4282] → [2.4282:4350]

                // std.log.debug("DDC buffer: {b}", .{ddc.buffer});

[2.4282]

[2.4350]

                log.debug("DDC buffer: {b}", .{self.buffer});
                // TODO: consider using @clz before ckecking masks?

Replacement in src/dcc.zig at line 121 [2.427]

B:BD[2.4559] → [2.4559:5658]

                    std.log.debug("3 byte long DCC package detected!", .{});
                    defer self.reset();
                    const address: u8 = @truncate(self.buffer >> (2 * (8 + 1) + 1));
                    const instruction: u8 = @truncate(self.buffer >> (8 + 1) + 1);
                    const checksum: u8 = @truncate(self.buffer >> 1);
                    if (address ^ instruction == checksum) {
                        std.log.debug("DDC packet passed the validation", .{});
                        const packet = Packet{
                            .address = @bitCast(address),
                            .instruction = @bitCast(instruction),
                        };
                        self.packets.writeItem(packet) catch {
                            std.log.err("DDC packet FIFO full, dropping packet", .{});
                            return;
                        };
                        std.log.debug("DCC packet added to FIFO", .{});
                    } else {
                        std.log.debug("DDC packet invalid", .{});
                    }

[2.4559]

[2.5658]

                    self.write3bytes();

Replacement in src/dcc.zig at line 126 [2.427]

B:BD[4.2017] → [4.2017:2094]

                    std.log.debug("4 byte long DCC package detected!", .{});

[4.2017]

[4.2094]

                    log.debug("4 byte long DCC package detected!", .{});

Replacement in src/dcc.zig at line 131 [2.427]

B:BD[4.2251] → [4.2251:2328]

                    std.log.debug("5 byte long DCC package detected!", .{});

[4.2251]

[4.2328]

                    log.debug("5 byte long DCC package detected!", .{});

Insertion in src/dcc.zig at line 137 [2.427]

[2.5708]

    fn write3bytes(self: *@This()) void {
        log.debug("3 byte long DCC package detected!", .{});
        defer self.reset();
        const address: u8 = @truncate(self.buffer >> (2 * (8 + 1) + 1));
        const instruction: u8 = @truncate(self.buffer >> (8 + 1) + 1);
        const checksum: u8 = @truncate(self.buffer >> 1);
        if (address ^ instruction != checksum) {
            log.debug("DDC packet invalid, dropping it", .{});
            return;
        }
        const packet = Packet{
            .address = @bitCast(address),
            .instruction = @bitCast(instruction),
        };
        self.packets.writeItem(packet) catch {
            log.err("DDC packet FIFO full, dropping packet", .{});
            return;
        };
        log.debug("DCC packet added to FIFO", .{});
    }

Replacement in src/dcc.zig at line 178 [2.427]

B:BD[2.6124] → [2.6124:6176]

        pico.time.sleep_us(Parser.TIME_ONEMAX / 2);

[2.6124]

[2.6176]

        pico.time.sleep_us(Parser.TIME_ONEMAX_US / 2);

Replacement in src/dcc.zig at line 183 [2.427]

B:BD[2.6364] → [2.6364:6416]

        pico.time.sleep_us(Parser.TIME_ONEMAX * 2);

[2.6364]

[2.6416]

        pico.time.sleep_us(Parser.TIME_ONEMAX_US * 2);