const dcc = @import("dcc.zig");

    fn backward(self: @This(), level: u16) void {
        self.fwd.put(0);
        self.bwd.put(1);
        self.speed.set_level(level);
        log.debug("Motor is moving backward: {d}", .{level});
    }

        defer rp2xxx.adc.set_enabled(false);
        rp2xxx.adc.set_enabled(true);

            // 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

fn emf(self: anytype, dir: dcc.Direction, level: u16) !u12 {
    defer rp2xxx.adc.set_enabled(false);
    rp2xxx.adc.set_enabled(true);
    const emf_config = main.cv.manufacturer.emf;
    self.freerun();
    rp2xxx.time.sleep_us(emf_config.delay_us);
    rp2xxx.adc.start(.free_running);
    var results: [std.math.maxInt(u8)]u12 = undefined;
    for (0..emf_config.iterations) |i| {
        while (rp2xxx.adc.fifo.is_empty()) {
            asm volatile ("" ::: "memory");
        }
        results[i] = try rp2xxx.adc.fifo.pop();
        // TODO: check if we should sort right here
    }
    switch (dir) {
        .forward => self.forward(level),
        .backward => self.backward(level),
    }
    std.sort.pdq(u12, results[0..emf_config.iterations], {}, less);
    // Calculate average EMF
    var sum: usize = 0;
    for (emf_config.low_cutoff..emf_config.iterations - emf_config.high_cutoff) |i| {
        sum += results[i];
    }
    const aemf = sum / (emf_config.iterations - emf_config.low_cutoff - emf_config.high_cutoff);
    return @truncate(aemf);
}

    var level: usize = pwm_period * 65 / 100;

    var level: usize = @as(usize, pwm_period) * 65 / 100;

        md.forward(@truncate(level));

        md.forward(@intCast(level));

            // 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

            // 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));

            const m1emf = try emf(md, .forward, @intCast(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);

    // init uart logging
    if (board.uart) |uart| {
        uart.apply(.{
            .baud_rate = 115200,
            .clock_config = rp2xxx.clock_config,
        });
        rp2xxx.uart.init_logger(uart);

    { // UART log setup
        if (board.uart) |uart| {
            uart.apply(.{
                .baud_rate = 115200,
                .clock_config = rp2xxx.clock_config,
            });
            rp2xxx.uart.init_logger(uart);
        }

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

    { // PWM setup
        // 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);
    }

    // 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);

    { // ADC setup
        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 too
    }

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

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

pub const Direction = enum {
    backward,
    forward,
};

    const Direction = enum(u1) {
        backward,
        forward,
    };