esp32-hal 0.2.0

A Hardware abstraction layer for Espressif's ESP32 WiFi microcontroller.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

#![no_std]
#![no_main]

use core::fmt::Write;
use core::panic::PanicInfo;

use esp32_hal::prelude::*;

use esp32_hal::analog::adc::ADC;
use esp32_hal::analog::config::{Adc1Config, Attenuation};
use esp32_hal::clock_control::sleep;
use esp32_hal::dport::Split;
use esp32_hal::serial::{config::Config, Serial};
use esp32_hal::target;

#[no_mangle]
fn main() -> ! {
    let dp = target::Peripherals::take().expect("Failed to obtain Peripherals");

    let mut timg0 = dp.TIMG0;
    let mut timg1 = dp.TIMG1;

    let (_, dport_clock_control) = dp.DPORT.split();

    // (https://github.com/espressif/openocd-esp32/blob/97ba3a6bb9eaa898d91df923bbedddfeaaaf28c9/src/target/esp32.c#L431)
    // openocd disables the watchdog timer on halt
    // we will do it manually on startup
    disable_timg_wdts(&mut timg0, &mut timg1);

    let clkcntrl = esp32_hal::clock_control::ClockControl::new(
        dp.RTCCNTL,
        dp.APB_CTRL,
        dport_clock_control,
        esp32_hal::clock_control::XTAL_FREQUENCY_AUTO,
    )
    .unwrap();

    let (clkcntrl_config, mut watchdog) = clkcntrl.freeze().unwrap();
    watchdog.disable();

    let gpios = dp.GPIO.split();
    // setup serial controller
    let serial: Serial<_, _, _> = Serial::new(
        dp.UART0,
        esp32_hal::serial::Pins {
            tx: gpios.gpio1,
            rx: gpios.gpio3,
            cts: None,
            rts: None,
        },
        Config::default(),
        clkcntrl_config,
    )
    .unwrap();

    let (mut tx, _rx) = serial.split();

    /* Set ADC pins to analog mode */
    let mut pin36 = gpios.gpio36.into_analog();
    let mut pin39 = gpios.gpio39.into_analog();

    /* In the configuration enable hall sensor and its pins (36 and 39) */
    let mut adc_config = Adc1Config::new();
    adc_config.enable_hall_sensor();
    adc_config.enable_pin(&pin36, Attenuation::Attenuation0dB);
    adc_config.enable_pin(&pin39, Attenuation::Attenuation0dB);

    /* Hall sensor is only available on the ADC1 */
    let analog = dp.SENS.split();
    let mut adc1 = ADC::adc1(analog.adc1, adc_config).unwrap();

    loop {
        /* Read the sensor and print out the raw value once per second */
        let hall_sensor_value: i32 = adc1.read_hall_sensor(&mut pin36, &mut pin39);
        writeln!(tx, "Hall sensor raw value: {:?}", hall_sensor_value).unwrap();

        sleep(1.s());
    }
}

const WDT_WKEY_VALUE: u32 = 0x50D83AA1;

fn disable_timg_wdts(timg0: &mut target::TIMG0, timg1: &mut target::TIMG1) {
    timg0
        .wdtwprotect
        .write(|w| unsafe { w.bits(WDT_WKEY_VALUE) });
    timg1
        .wdtwprotect
        .write(|w| unsafe { w.bits(WDT_WKEY_VALUE) });

    timg0.wdtconfig0.write(|w| unsafe { w.bits(0x0) });
    timg1.wdtconfig0.write(|w| unsafe { w.bits(0x0) });
}

/// Basic panic handler - just loops
#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    loop {}
}