HandCrankMPPT-Firmware-Rust/src/main.rs

//! # PWM Blink Example
//!
//! If you have an LED connected to pin 25, it will fade the LED using the PWM
//! peripheral.
//!
//! It may need to be adapted to your particular board layout and/or pin assignment.
//!
//! See the `Cargo.toml` file for Copyright and license details.

#![no_std]
#![no_main]

use embedded_hal::digital::v2::OutputPin;
// Ensure we halt the program on panic (if we don't mention this crate it won't
// be linked)
use panic_halt as _;

// Alias for our HAL crate
use rp2040_hal as hal;

// Some traits we need
use cortex_m::singleton;
use embedded_hal::PwmPin;
use fugit::RateExtU32;
use rp2040_hal::clocks::Clock;

// A shorter alias for the Peripheral Access Crate, which provides low-level
// register access
use hal::pac;

// SPI + DMA
use hal::dma::{bidirectional, DMAExt};

// UART related types
use hal::uart::{DataBits, StopBits, UartConfig};

use heapless::String;

/// The linker will place this boot block at the start of our program image. We
/// need this to help the ROM bootloader get our code up and running.
/// Note: This boot block is not necessary when using a rp-hal based BSP
/// as the BSPs already perform this step.
#[link_section = ".boot2"]
#[used]
pub static BOOT2: [u8; 256] = rp2040_boot2::BOOT_LOADER_GENERIC_03H;

/// The minimum PWM value (i.e. LED brightness) we want
const LOW: u16 = 0;

/// The maximum PWM value (i.e. LED brightness) we want
const HIGH: u16 = 25000;

/// External high-speed crystal on the Raspberry Pi Pico board is 12 MHz. Adjust
/// if your board has a different frequency
const XTAL_FREQ_HZ: u32 = 12_000_000u32;

/// Entry point to our bare-metal application.
///
/// The `#[rp2040_hal::entry]` macro ensures the Cortex-M start-up code calls this function
/// as soon as all global variables and the spinlock are initialised.
///
/// The function configures the RP2040 peripherals, then fades the LED in an
/// infinite loop.
#[rp2040_hal::entry]
fn main() -> ! {
    // Grab our singleton objects
    let mut pac = pac::Peripherals::take().unwrap();
    let core = pac::CorePeripherals::take().unwrap();

    // Set up the watchdog driver - needed by the clock setup code
    let mut watchdog = hal::Watchdog::new(pac.WATCHDOG);

    // Configure the clocks
    //
    // The default is to generate a 125 MHz system clock
    let clocks = hal::clocks::init_clocks_and_plls(
        XTAL_FREQ_HZ,
        pac.XOSC,
        pac.CLOCKS,
        pac.PLL_SYS,
        pac.PLL_USB,
        &mut pac.RESETS,
        &mut watchdog,
    )
    .ok()
    .unwrap();

    // The single-cycle I/O block controls our GPIO pins
    let sio = hal::Sio::new(pac.SIO);

    // Set the pins up according to their function on this particular board
    let pins = hal::gpio::Pins::new(
        pac.IO_BANK0,
        pac.PADS_BANK0,
        sio.gpio_bank0,
        &mut pac.RESETS,
    );

    // The delay object lets us wait for specified amounts of time (in
    // milliseconds)
    let mut delay = cortex_m::delay::Delay::new(core.SYST, clocks.system_clock.freq().to_Hz());

    // UART
    let uart_pins = (
        // UART TX (characters sent from RP2040) on pin 1 (GPIO0)
        pins.gpio0.into_mode::<hal::gpio::FunctionUart>(),
        // UART RX (characters received by RP2040) on pin 2 (GPIO1)
        pins.gpio1.into_mode::<hal::gpio::FunctionUart>(),
    );
    let uart = hal::uart::UartPeripheral::new(pac.UART0, uart_pins, &mut pac.RESETS)
        .enable(
            UartConfig::new(9600.Hz(), DataBits::Eight, None, StopBits::One),
            clocks.peripheral_clock.freq(),
        )
        .unwrap();

    // Init PWMs
    let mut pwm_slices = hal::pwm::Slices::new(pac.PWM, &mut pac.RESETS);

    // Configure PWM4
    let pwm5 = &mut pwm_slices.pwm5;
    pwm5.set_ph_correct();
    pwm5.set_div_int(4);
    pwm5.set_div_frac((88 << 4) / 100);
    pwm5.set_top(512);
    pwm5.enable();

    let pwm6 = &mut pwm_slices.pwm6;
    pwm6.set_ph_correct();
    pwm6.enable();
    let pwm7 = &mut pwm_slices.pwm7;
    pwm7.set_ph_correct();
    pwm7.enable();

    // Output channel B on PWM4 to GPIO 25
    let channel1 = &mut pwm6.channel_b;
    channel1.output_to(pins.gpio13);
    let channel2 = &mut pwm7.channel_a;
    channel2.output_to(pins.gpio14);
    let channel3 = &mut pwm7.channel_b;
    channel3.output_to(pins.gpio15);

    let pwr_switch_ch = &mut pwm5.channel_a;
    pwr_switch_ch.output_to(pins.gpio10);
    pwr_switch_ch.set_duty(450);

    let mut ch_val: [u16; 3] = [LOW, LOW + (HIGH - LOW) / 3, LOW + 2 * (HIGH - LOW) / 3];

    uart.write_full_blocking(b"Initialization complete!\r\n");

    // SPI CS pin is controlled by software
    let mut spi_cs = pins.gpio5.into_push_pull_output();
    spi_cs.set_high().unwrap();

    // These are implicitly used by the spi driver if they are in the correct mode
    let _spi_sclk = pins.gpio2.into_mode::<hal::gpio::FunctionSpi>();
    let _spi_mosi = pins.gpio3.into_mode::<hal::gpio::FunctionSpi>();
    let _spi_miso = pins.gpio4.into_mode::<hal::gpio::FunctionSpi>();
    let spi = hal::spi::Spi::<_, _, 8>::new(pac.SPI0);

    // Exchange the uninitialised SPI driver for an initialised one
    let spi = spi.init(
        &mut pac.RESETS,
        clocks.peripheral_clock.freq(),
        1_000_000u32.Hz(),
        &embedded_hal::spi::MODE_0,
    );

    // Initialize DMA.
    let dma = pac.DMA.split(&mut pac.RESETS);

    // Use DMA to read ADC (0xC0 in byte 1 is the channel mask)
    let tx_buf = singleton!(: [u8; 3] = [0x06, 0x40, 0x00]).unwrap();
    let rx_buf = singleton!(: [u8; 3] = [0; 3]).unwrap();

    // clear chip select
    spi_cs.set_low().unwrap();

    // Use BidirectionalConfig to simultaneously write to spi from tx_buf and read into rx_buf
    let transfer = bidirectional::Config::new((dma.ch0, dma.ch1), tx_buf, spi, rx_buf).start();
    // Wait for both DMA channels to finish
    let ((_ch0, _ch1), tx_buf, _spi, rx_buf) = transfer.wait();
    spi_cs.set_high().unwrap();

    let adc_value = (((rx_buf[1] & 0x0F) as u16) << 8) | rx_buf[2] as u16;

    {
        let data: String<16> = String::from(adc_value);

        uart.write_full_blocking(b"Read ADC value: ");
        uart.write_full_blocking(data.as_bytes());
        uart.write_full_blocking(b"\r\n");
    }

    // Infinite loop, fading LED up and down
    loop {
        for i in 0..ch_val.len() {
            ch_val[i] += 1;
            if ch_val[i] > HIGH {
                ch_val[i] -= HIGH - LOW;
            }
        }

        channel1.set_duty(ch_val[0]);
        channel2.set_duty(ch_val[1]);
        channel3.set_duty(ch_val[2]);
        delay.delay_us(50);
    }
}