voroskoi/RP2040-decoder - Change AIK3NJJOAMB2QEYWLVK7B3E4ZMVGPBPPPZD2TGEBZCNM4Y6KI2XQC

Add motor handling stuff

Created by voroskoi on July 25, 2025

AIK3NJJOAMB2QEYWLVK7B3E4ZMVGPBPPPZD2TGEBZCNM4Y6KI2XQC

Dependencies

In channels

main

Change contents

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

[2.15]

const std = @import("std");
const microzig = @import("microzig");
const rp2xxx = microzig.hal;
const main = @import("main.zig");
const log = std.log.scoped(.motor);
pub const MotorDriverType = enum {
    l293,
    bdr6133,
};
pub fn MotorDriver(comptime driver: MotorDriverType) type {
    switch (driver) {
        .l293 => return L293,
        .bdr6133 => return BDR6133,
    }
}
const L293 = struct {
    fwd: rp2xxx.gpio.Pin,
    bwd: rp2xxx.gpio.Pin,
    speed: rp2xxx.pwm.Pwm,
    fn stop(self: @This()) void {
        self.fwd.put(1);
        self.bwd.put(1);
        log.debug("Motor stopped", .{});
    }
    fn freerun(self: @This()) void {
        self.speed.set_level(0);
        log.debug("Motor in freerun mode", .{});
    }
    fn forward(self: @This(), level: u16) void {
        self.fwd.put(1);
        self.bwd.put(0);
        self.speed.set_level(level);
        log.debug("Motor is moving forward: {d}", .{level});
    }
};
const BDR6133 = struct {};
pub fn tester(comptime driver: MotorDriverType) !void {
    const md = MotorDriver(driver){
        .fwd = main.pins.mot1,
        .bwd = main.pins.mot2,
        .speed = main.pins.speed,
    };
    const pwm_period = 125_000_000 / (@as(usize, main.cv.PWM_period) * 100 + 10_000);
    var level: usize = pwm_period * 65 / 100;
    while (level < pwm_period) : (level += pwm_period / 50) {
        md.forward(@truncate(level));
        rp2xxx.time.sleep_ms(2000);
        { // Measure Back-EMF
            // Prepare ADC
            rp2xxx.adc.apply(.{
                .sample_frequency = null,
                .round_robin = null,
                .temp_sensor_enabled = false,
                .fifo = .{ .dreq_enabled = false, .irq_enabled = false, .shift = false },
            }); // apply calls enable
            rp2xxx.adc.select_input(main.pins.m1emf);
            // Switch to free running mode
            md.freerun();
            rp2xxx.time.sleep_us(100);
            // Actual measurring
            const emf = main.cv.manufacturer.emf;
            rp2xxx.adc.start(.free_running);
            var emfs: [std.math.maxInt(u8)]u12 = undefined;
            for (0..emf.iterations) |i| {
                if (rp2xxx.adc.fifo.has_overflowed()) {
                    std.log.debug("ADC overflow, clearing...", .{});
                    rp2xxx.adc.fifo.clear_overflowed();
                }
                while (rp2xxx.adc.fifo.is_empty()) {
                    asm volatile ("" ::: "memory");
                }
                emfs[i] = try rp2xxx.adc.fifo.pop();
                // TODO: check if we should sort right here
            }
            // Measuring done, switch the motor back on
            rp2xxx.adc.set_enabled(false);
            md.forward(@truncate(level));
            // std.log.debug("Raw EMF values: {any}", .{emfs});
            // Sort results, so we can cut out the low and high part
            std.sort.pdq(u12, emfs[0..emf.iterations], {}, less);
            // Calculate average EMF
            var sum: u32 = 0;
            for (emf.low_cutoff..emf.iterations - emf.high_cutoff) |i| {
                sum += emfs[i];
            }
            const m1emf = sum / (emf.iterations - emf.low_cutoff - emf.high_cutoff);
            std.log.debug("Motor1 average EMF: {d}", .{m1emf});
        }
    }
}
fn less(_: void, a: u12, b: u12) bool {
    return a < b;
}

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

B:BD[9.118] → [9.118:173]

const board = @import("board.zig").boardConfig(.pico);

[9.118]

[9.173]

const board = @import("board.zig").boardConfig(build_options.board);

Insertion in src/main.zig at line 15 [2.50]
[9.209]
[2.475]
```
const motor = @import("motor.zig");
```
Replacement in src/main.zig at line 26 [2.50]
B:BD[2.3837] → [9.252:288]
```
const pins = board.pin_conf.pins();
```
[2.3837]
[7.490]
```
pub const pins = board.pin_conf.pins();
```
Replacement in src/main.zig at line 30 [2.50]
∅:D[6.445] → [5.40:41]
B:BD[4.1569] → [5.40:41]
B:BD[5.41] → [7.492:552]
```
fn less(_: void, a: u12, b: u12) bool {
    return a < b;
}
```
[6.445]
[2.5787]
```
pub var cv = DDC.CV.default;
```

Deletion in src/main.zig at line 47 [2.50]

∅:D[9.650] → [7.577:599]

B:BD[6.538] → [7.577:599]

B:BD[7.599] → [8.109:193]

∅:D[8.193] → [7.630:698]

B:BD[7.630] → [7.630:698]

B:BD[7.698] → [8.194:286]

∅:D[8.286] → [7.698:782]

B:BD[7.698] → [7.698:782]

B:BD[7.782] → [8.287:389]

∅:D[8.389] → [7.782:911]

B:BD[7.782] → [7.782:911]

B:BD[7.911] → [9.651:687]

∅:D[9.687] → [7.945:946]

B:BD[7.945] → [7.945:946]

B:BD[7.946] → [8.390:443]

∅:D[8.443] → [7.946:1004]

B:BD[7.946] → [7.946:1004]

B:BD[7.1004] → [8.444:496]

∅:D[8.496] → [7.1055:1107]

B:BD[7.1055] → [7.1055:1107]

B:BD[7.1107] → [9.688:728]

∅:D[9.728] → [7.1205:1240]

B:BD[7.1205] → [7.1205:1240]

B:BD[7.1397] → [7.1397:1428]

B:BD[7.1428] → [9.729:765]

∅:D[9.765] → [7.1513:1650]

B:BD[7.1513] → [7.1513:1650]

B:BD[7.1650] → [8.497:591]

∅:D[8.591] → [7.1684:1726]

B:BD[7.1684] → [7.1684:1726]

B:BD[7.1726] → [9.766:819]


    { // Motor stuff
        const PWM_WRAP = 125_000_000 / (150 * 100 + 10_000) - 1; // 125MHz -> 25kHz
        const EMF_ARRAY_SIZE = 100;
        const EMF_CUTOUT = 15;
        // TODO: max output is wrap+1 (5000)
        // minimum: core1.c: get_initial_level
        pins.speed.slice().set_wrap(PWM_WRAP);
        pins.speed.slice().enable();
        pins.speed.slice().set_phase_correct(false);
        // pins.speed.slice().set_clk_div(1, 0);
        // stop
        pins.mot1.put(1);
        pins.mot2.put(1);
        std.log.debug("Motor stopped for {d} ms", .{1000});
        rp2xxx.time.sleep_ms(1000);
        pins.mot1.put(1);
        pins.mot2.put(0);
        // start
        var level: usize = PWM_WRAP / 2;
        while (level < PWM_WRAP) : (level += 100) {
            pins.speed.set_level(@truncate(level));
            rp2xxx.time.sleep_ms(2000);
            { // Measure Back-EMF
                // Prepare ADC
                rp2xxx.adc.apply(.{
                    .sample_frequency = null,
                    .round_robin = null,
                    .temp_sensor_enabled = false,
                    .fifo = .{ .dreq_enabled = false, .irq_enabled = false, .shift = false },
                }); // apply calls enable
                rp2xxx.adc.select_input(pins.m1emf);

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

B:BD[8.644] → [8.644:732]

B:BD[8.732] → [9.820:863]

                // Switch to free running mode
                pins.speed.set_level(0);
                rp2xxx.time.sleep_us(100);

[8.644]

[7.1726]

    // PWM setup
    // TODO: minimum: core1.c: get_initial_level

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

B:BD[7.1727] → [7.1727:1764]

B:BD[7.1764] → [9.864:913]

∅:D[9.913] → [7.1811:1916]

B:BD[7.1811] → [7.1811:1916]

B:BD[7.1916] → [9.914:974]

∅:D[9.974] → [8.832:905]

B:BD[8.832] → [8.832:905]

B:BD[8.905] → [9.975:1035]

∅:D[9.1035] → [8.963:985]

B:BD[8.963] → [8.963:985]

B:BD[8.985] → [9.1036:1093]

∅:D[9.1093] → [8.1040:1118]

B:BD[8.1040] → [8.1040:1118]

B:BD[8.1118] → [9.1094:1151]

∅:D[9.1151] → [8.1173:1237]

B:BD[8.1173] → [8.1173:1237]

∅:D[8.1237] → [7.1974:1992]

B:BD[7.1974] → [7.1974:1992]

                // Actual measurring
                rp2xxx.adc.start(.free_running);
                var emfs: [EMF_ARRAY_SIZE]u12 = undefined;
                for (0..EMF_ARRAY_SIZE) |i| {
                    if (rp2xxx.adc.fifo.has_overflowed()) {
                        std.log.debug("ADC overflow, clearing...", .{});
                        rp2xxx.adc.fifo.clear_overflowed();
                    }
                    while (rp2xxx.adc.fifo.is_empty()) {
                        asm volatile ("" ::: "memory");
                    }
                    emfs[i] = try rp2xxx.adc.fifo.pop();
                    // TODO: check if we should sort right here
                }

[7.1727]

[2.6533]

    // 125MHz -> 25kHz
    pins.speed.slice().set_wrap(@intCast(125_000_000 / (@as(u32, cv.PWM_period) * 100 + 10_000) - 1));
    pins.speed.slice().enable();
    pins.speed.slice().set_phase_correct(false);
    pins.speed.slice().set_clk_div(1, 0);

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

B:BD[2.6534] → [7.1993:2053]

B:BD[7.2053] → [9.1152:1199]

∅:D[9.1199] → [8.1238:1363]

B:BD[7.2098] → [8.1238:1363]

∅:D[8.1363] → [7.2166:2292]

B:BD[7.2166] → [7.2166:2292]

                // Measuring done, switch the motor back on
                rp2xxx.adc.set_enabled(false);
                pins.speed.set_level(@truncate(level));
                // std.log.debug("Raw EMF values: {any}", .{emfs});
                // Sort results, so we can cut out the low and high part
                std.sort.pdq(u12, &emfs, {}, less);

[2.6534]

[7.2292]

    // try motor.tester(board.motor_driver);

Deletion in src/main.zig at line 59 [2.50]

B:BD[7.2293] → [7.2293:2334]

B:BD[7.2334] → [8.1364:1398]

∅:D[8.1398] → [7.2368:2562]

B:BD[7.2368] → [7.2368:2562]

B:BD[7.2562] → [8.1399:1466]

∅:D[8.1466] → [7.2655:2669]

B:BD[7.2655] → [7.2655:2669]

B:BD[7.2707] → [7.2707:2717]

∅:D[7.2813] → [2.6600:6606]

B:BD[2.6600] → [2.6600:6606]

B:BD[2.6690] → [2.6690:6691]

                // Calculate average EMF
                var sum: u32 = 0;
                for (EMF_CUTOUT..EMF_ARRAY_SIZE - EMF_CUTOUT) |i| {
                    sum += emfs[i];
                }
                const m1emf = sum / (EMF_ARRAY_SIZE - 2 * EMF_CUTOUT);
                std.log.info("Motor1 average EMF: {d}", .{m1emf});
            }
        }
    }

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

B:BD[6.2033] → [6.2033:2115]

    //     .{ pico.get_cpu_id(), state.GPIO15_EDGE_LOW, state.GPIO15_EDGE_HIGH },

[6.2033]

[6.2115]

    //     .{ rp2xxx.get_cpu_id(), state.GPIO15_EDGE_LOW, state.GPIO15_EDGE_HIGH },

Insertion in src/ddc.zig at line 178 [3.427]

[3.6774]

};
const Manufacturer = packed struct(u144) {
    reserved: u112 = 0,
    emf: BackEMF = BackEMF{},

Insertion in src/ddc.zig at line 185 [3.427]

[3.6778]

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
};

Replacement in src/ddc.zig at line 224 [3.427]

B:BD[3.7909] → [3.7909:7971]

    manufacturer_unique47_64: u144 = 0, // 47..64 => 18*8=144

[3.7909]

[3.7971]

    manufacturer: Manufacturer = @bitCast(@as(u144, 0)), // 47..64 => 18*8=144

Replacement in src/ddc.zig at line 233 [3.427]

B:BD[3.8268] → [3.8268:8337]

    manufacturer_unique112_256: u1160 = 0, // 112..256 => 145*8=1160

[3.8268]

[3.8337]

    manufacturer2: u1160 = 0, // 112..256 => 145*8=1160

Replacement in src/ddc.zig at line 263 [3.427]

B:BD[3.9281] → [3.9281:9315]

        .PWM_period = 0b10010110,

[3.9281]

[3.9315]

        .PWM_period = 150, // 125_000_000 / PWM_period * 100 + 10_000 (125MHz -> 25kHz)

Insertion in src/ddc.zig at line 279 [3.427]
[3.10029]
[3.10029]
```
        .manufacturer = Manufacturer{},
```
Insertion in src/board.zig at line 5 [9.6264]
[9.6381]
[9.6381]
```
const motor = @import("motor.zig");
```
Deletion in src/board.zig at line 9 [9.6264]
B:BD[9.6411] → [9.6411:6458]
```
    pin_conf: rp2xxx.pins.GlobalConfiguration,
```

Insertion in src/board.zig at line 11 [9.6264]

[9.6519]

    motor_driver: motor.MotorDriverType,
    pin_conf: rp2xxx.pins.GlobalConfiguration,

Insertion in src/board.zig at line 33 [9.6264]
[9.7464]
[9.7464]
```
                .motor_driver = .l293,
```