#![cfg_attr(

    all(docsrs, not(not_really_docsrs)),

    doc = "<div style='padding:30px;background:#810;color:#fff;text-align:center;'><p>You might want to <a href='https://docs.espressif.com/projects/rust/'>browse the <code>esp-hal</code> documentation on the esp-rs website</a> instead.</p><p>The documentation here on <a href='https://docs.rs'>docs.rs</a> is built for a single chip only (ESP32-C6, in particular), while on the esp-rs website you can select your exact chip from the list of supported devices. Available peripherals and their APIs change depending on the chip.</p></div>\n\n<br/>\n\n"

)]

//! # Bare-metal (`no_std`) HAL for all Espressif ESP32 devices.

//!

//! This documentation is built for the

#![doc = concat!("**", chip_pretty!(), "**")]

//! . Please ensure you are reading the correct [documentation] for your target

//! device.

//!

//! ## Overview

//!

//! esp-hal is a Hardware Abstraction Layer (HAL) for Espressif's ESP32 lineup of

//! microcontrollers offering safe, idiomatic APIs to control hardware peripherals.

//!

//! ### Peripheral drivers

//!

//! The HAL implements both [`Blocking`] _and_ [`Async`] APIs for all applicable peripherals.

//! Where applicable, driver implement the [embedded-hal] and

//! [embedded-hal-async] traits. Drivers that do not currently have a stable API

//! are marked as `unstable` in the documentation.

//!

//! ### Peripheral singletons

//!

//! Each peripheral driver needs a peripheral singleton that tells the driver

//! which hardware block to use. The peripheral singletons are created by the

//! HAL initialization, and are returned from [`init`] as fields of the

//! [`Peripherals`] struct.

//!

//! These singletons, by default, represent peripherals for the entire lifetime

//! of the program. To allow for reusing peripherals, the HAL provides a

//! `reborrow` method on each peripheral singleton. This method creates a new

//! handle to the peripheral with a shorter lifetime. This lets the handle be

//! passed to a driver while keeping the original handle alive. Once the driver

//! is dropped, the peripheral can be reborrowed again.

#![cfg_attr(

    // Feature-gated so that this doesn't prevent gradual device bringup. Any

    // stable driver would serve the purpose here, so this block will be part

    // of the released documentation.

    i2c_master_driver_supported,

    doc = r#"

For example, if you want to use the [`I2c`](i2c::master::I2c) driver and you

do not intend to drop the driver, you can pass the peripheral singleton to

the driver by value:

```rust, ignore

// Peripheral singletons are returned from the `init` function.

let peripherals = esp_hal::init(esp_hal::Config::default());

let mut i2c = I2c::new(peripherals.I2C0, /* ... */);

```

"#

)]

//! If you want to use the peripheral in multiple places (for example, you want

//! to drop the driver for some period of time to minimize power consumption),

//! you can reborrow the peripheral singleton and pass it to the driver by

//! reference:

//!

//! ```rust, ignore

//! // Note that in this case, `peripherals` needs to be mutable.

//! let mut peripherals = esp_hal::init(esp_hal::Config::default());

//!

//! let i2c = I2C::new(peripherals.I2C0.reborrow(), /* ... */);

//!

//! // Do something with the I2C driver...

//!

//! core::mem::drop(i2c); // Drop the driver to minimize power consumption.

//!

//! // Do something else...

//!

//! // You can then take or reborrow the peripheral singleton again.

//! let i2c = I2C::new(peripherals.I2C0.reborrow(), /* ... */);

//! ```

//!

//! ## Examples

//!

//! We have a plethora of [examples] in the esp-hal repository. We use

//! an [xtask] to automate the building, running, and testing of code and

//! examples within esp-hal.

//!

//! Invoke the following command in the root of the esp-hal repository to get

//! started:

//!

//! ```bash

//! cargo xtask help

//! ```

//!

//! ## Creating a Project

//!

//! We have a [book] that explains the full esp-hal ecosystem

//! and how to get started, it is advisable to give that a read

//! before proceeding. We also have a [training] that covers some common

//! scenarios with examples.

//!

//! We have developed a project generation tool, [esp-generate], which we

//! recommend when starting new projects. It can be installed and run, e.g.

//! for the ESP32-C6, as follows:

//!

//! ```bash

//! cargo install esp-generate

//! esp-generate --chip=esp32c6 your-project

//! ```

#![cfg_attr(

    // Feature-gated so that this doesn't prevent gradual device bringup. Any

    // stable driver would serve the purpose here, so this block will be part

    // of the released documentation.

    gpio_driver_supported,

    doc = r#"

## Blinky

Some minimal code to blink an LED looks like this:

```rust, no_run

#![no_std]

#![no_main]

use esp_hal::{

    clock::CpuClock,

    gpio::{Io, Level, Output, OutputConfig},

    main,

    time::{Duration, Instant},

};

// You need a panic handler. Usually, you would use esp_backtrace, panic-probe, or

// something similar, but you can also bring your own like this:

#[panic_handler]

fn panic(_: &core::panic::PanicInfo) -> ! {

    esp_hal::system::software_reset()

}

#[main]

fn main() -> ! {

    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());

    let peripherals = esp_hal::init(config);

    // Set GPIO0 as an output, and set its state high initially.

    let mut led = Output::new(peripherals.GPIO0, Level::High, OutputConfig::default());

    loop {

        led.toggle();

        // Wait for half a second

        let delay_start = Instant::now();

        while delay_start.elapsed() < Duration::from_millis(500) {}

    }

}

```

"#

)]

//! ## Additional configuration

//!

//! Some configuration options do not fit into cargo

//! features. These can be set via environment variables, or via cargo's `[env]`

//! section inside `.cargo/config.toml`. Unstable options can only be

//! enabled when the `unstable` feature is enabled for the crate. Below is a

//! table of tunable parameters for this crate:

#![doc = ""]

#![doc = include_str!(concat!(env!("OUT_DIR"), "/esp_hal_config_table.md"))]

#![doc = ""]

//! ## Don't use `core::mem::forget`

//!

//! You should never use `core::mem::forget` on any type defined in [esp crates].

//! Many types heavily rely on their `Drop` implementation to not leave the

//! hardware in undefined state which can cause undefined behavior in your program.

//!

//! You might want to consider using [`#[deny(clippy::mem_forget)`](https://rust-lang.github.io/rust-clippy/v0.0.212/index.html#mem_forget) in your project.

//!

//! ## Library usage

//!

//! If you intend to write a library that uses esp-hal, you should import it as follows:

//!

//! ```toml

//! [dependencies]

//! esp-hal = { version = "1", default-features = false } }

//! ```

//!

//! This ensures that the `rt` feature is not enabled, nor any chip features. The application that

//! uses your library will then be able to choose the chip feature it needs and enable `rt` such

//! that only the final user application calls [`init`].

//!

//! If your library depends on `unstable` features, you *must* use the `requires-unstable` feature,

//! and *not* the unstable feature itself. Doing so, improves the quality of the error messages if a

//! user hasn't enabled the unstable feature of esp-hal.

//!

//! [documentation]: https://docs.espressif.com/projects/rust/esp-hal/latest/

//! [examples]: https://github.com/esp-rs/esp-hal/tree/main/examples

//! [embedded-hal]: https://docs.rs/embedded-hal/latest/embedded_hal/

//! [embedded-hal-async]: https://docs.rs/embedded-hal-async/latest/embedded_hal_async/

//! [xtask]: https://github.com/matklad/cargo-xtask

//! [esp-generate]: https://github.com/esp-rs/esp-generate

//! [book]: https://docs.espressif.com/projects/rust/book/

//! [training]: https://docs.espressif.com/projects/rust/no_std-training/

//! [esp crates]: https://docs.espressif.com/projects/rust/book/introduction/ancillary-crates.html#esp-hal-ecosystem

//!

//! ## Feature Flags

#![doc = document_features::document_features!(feature_label = r#"<span class="stab portability"><code>{feature}</code></span>"#)]

#![doc(html_logo_url = "https://docs.espressif.com/projects/rust/esp-rs-grey-bg.svg")]

#![allow(asm_sub_register, async_fn_in_trait, stable_features)]

#![cfg_attr(xtensa, feature(asm_experimental_arch))]

#![deny(missing_docs, rust_2018_idioms, rustdoc::all)]

#![allow(rustdoc::private_doc_tests)] // compile tests are done via rustdoc

#![cfg_attr(docsrs, feature(doc_cfg, custom_inner_attributes, proc_macro_hygiene))]

// Don't trip up on broken/private links when running semver-checks

#![cfg_attr(

    semver_checks,

    allow(rustdoc::private_intra_doc_links, rustdoc::broken_intra_doc_links)

)]

// Do not document `cfg` gates by default.

#![cfg_attr(docsrs, allow(invalid_doc_attributes))] // doc(auto_cfg = false) requires a new nightly (~2025-10-09+)

#![cfg_attr(docsrs, doc(auto_cfg = false))]

#![no_std]

// MUST be the first module

mod fmt;

#[macro_use]

extern crate esp_metadata_generated;

// can't use instability on inline module definitions, see https://github.com/rust-lang/rust/issues/54727

#[doc(hidden)]

macro_rules! unstable_module {

    ($(

        $(#[$meta:meta])*

        pub mod $module:ident;

    )*) => {

        $(

            $(#[$meta])*

            #[cfg(feature = "unstable")]

            #[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]

            pub mod $module;

            $(#[$meta])*

            #[cfg(not(feature = "unstable"))]

            #[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]

            #[allow(unused)]

            pub(crate) mod $module;

        )*

    };

}

// can't use instability on inline module definitions, see https://github.com/rust-lang/rust/issues/54727

// we don't want unstable drivers to be compiled even, unless enabled

#[doc(hidden)]

macro_rules! unstable_driver {

    ($(

        $(#[$meta:meta])*

        pub mod $module:ident;

    )*) => {

        $(

            $(#[$meta])*

            #[cfg(feature = "unstable")]

            #[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]

            pub mod $module;

        )*

    };

}

use core::marker::PhantomData;

pub use esp_metadata_generated::chip;

use esp_rom_sys as _;

#[allow(unused)]

pub(crate) use unstable_driver;

pub(crate) use unstable_module;

metadata!("build_info", CHIP_NAME, chip!());

metadata!(

    "build_info",

    MIN_CHIP_REVISION,

    esp_config::esp_config_str!("ESP_HAL_CONFIG_MIN_CHIP_REVISION")

);

#[cfg(feature = "rt")]

cfg_select! {

    riscv => {

        #[cfg_attr(docsrs, doc(cfg(all(feature = "unstable", feature = "rt"))))]

        #[cfg_attr(not(feature = "unstable"), doc(hidden))]

        pub use esp_riscv_rt::{self, riscv};

    }

    xtensa => {

        #[cfg_attr(docsrs, doc(cfg(all(feature = "unstable", feature = "rt"))))]

        #[cfg_attr(not(feature = "unstable"), doc(hidden))]

        pub use xtensa_lx_rt::{self, xtensa_lx};

    }

}

pub(crate) use peripherals::pac;

pub(crate) mod private;

#[cfg(any(soc_has_dport, soc_has_hp_sys, soc_has_pcr, soc_has_system))]

pub mod clock;

#[cfg(gpio_driver_supported)]

pub mod gpio;

#[cfg(i2c_master_driver_supported)]

pub mod i2c;

// The I2S driver is unstable, but its clock tree nodes are part of every build.

#[cfg(i2s_driver_supported)]

#[path = "i2s/clocks/mod.rs"]

mod i2s_clocks;

pub mod peripherals;

#[cfg(all(

    feature = "unstable",

    any(

        hmac_driver_supported,

        sha_driver_supported,

        ethernet_driver_supported,

        mipi_dsi_driver_supported

    )

))]

mod reg_access;

#[cfg(rng_driver_supported)]

pub mod rng;

#[cfg(any(spi_master_driver_supported, spi_slave_driver_supported))]

pub mod spi;

pub mod system;

pub mod time;

#[cfg(uart_driver_supported)]

pub mod uart;

mod macros;

#[instability::unstable]

pub use procmacros::handler;

#[instability::unstable]

#[cfg(ulp_riscv_driver_supported)]

pub use procmacros::load_lp_code;

#[cfg(feature = "rt")]

pub use procmacros::main;

pub use procmacros::ram;

#[instability::unstable]

#[cfg(ulp_riscv_driver_supported)]

pub use self::soc::lp_core;

#[cfg(all(feature = "rt", feature = "exception-handler"))]

mod exception_handler;

pub mod efuse;

pub mod interrupt;

unstable_module! {

    pub mod asynch;

    pub mod debugger;

    pub mod rom;

    #[doc(hidden)]

    pub mod sync;

    // Drivers needed for initialization or they are tightly coupled to something else.

    #[cfg(any(adc_driver_supported, dac_driver_supported))]

    pub mod analog;

    #[cfg(any(systimer_driver_supported, timergroup_driver_supported))]

    pub mod timer;

    #[cfg(soc_has_lpwr)]

    pub mod rtc_cntl;

    #[cfg(dma_driver_supported)]

    pub mod dma;

    #[cfg(etm_driver_supported)]

    pub mod etm;

    #[cfg(soc_has_psram)] // DMA needs some things from here

    pub mod psram;

}

#[cfg(any(

    sha_driver_supported,

    rsa_driver_supported,

    aes_driver_supported,

    ecc_driver_supported

))]

mod work_queue;

unstable_driver! {

    #[cfg(aes_driver_supported)]

    pub mod aes;

    #[cfg(assist_debug_driver_supported)]

    pub mod assist_debug;

    #[cfg(canfd_driver_supported)]

    pub mod canfd;

    pub mod delay;

    #[cfg(ecc_driver_supported)]

    pub mod ecc;

    #[cfg(flash_driver_supported)]

    pub mod flash;

    #[cfg(hmac_driver_supported)]

    pub mod hmac;

    #[cfg(i2s_driver_supported)]

    pub mod i2s;

    #[cfg(soc_has_lcd_cam)]

    pub mod lcd_cam;

    #[cfg(ledc_driver_supported)]

    pub mod ledc;

    #[cfg(mcpwm_driver_supported)]

    pub mod mcpwm;

    #[cfg(parl_io_driver_supported)]

    pub mod parl_io;

    #[cfg(pcnt_driver_supported)]

    pub mod pcnt;

    #[cfg(rmt_driver_supported)]

    pub mod rmt;

    #[cfg(rsa_driver_supported)]

    pub mod rsa;

    #[cfg(sdmmc_driver_supported)]

    pub mod sdmmc;

    #[cfg(sha_driver_supported)]

    pub mod sha;

    #[cfg(sdm_driver_supported)]

    pub mod sdm;

    #[cfg(touch_driver_supported)]

    pub mod touch;

    #[cfg(soc_has_trace0)]

    pub mod trace;

    #[cfg(soc_has_tsens)]

    pub mod tsens;

    #[cfg(twai_driver_supported)]

    pub mod twai;

    #[cfg(any(

        usb_otg_driver_supported,

        usb_otg_hs_driver_supported,

        usb_serial_jtag_driver_supported,

    ))]

    pub mod usb;

    #[cfg(ethernet_driver_supported)]

    pub mod ethernet;

    #[cfg(mipi_dsi_driver_supported)]

    pub mod mipi_dsi;

}

/// State of the CPU saved when entering exception or interrupt

#[instability::unstable]

#[cfg(feature = "rt")]

#[allow(unused_imports)]

pub mod trapframe {

    #[cfg(riscv)]

    pub use esp_riscv_rt::TrapFrame;

    #[cfg(xtensa)]

    pub use xtensa_lx_rt::exception::Context as TrapFrame;

}

// The `soc` module contains chip-specific implementation details and should not

// be directly exposed.

mod soc;

// Some PAC-related utility

use crate::pac::generic::{Readable, Reg, Resettable, W, Writable};

#[allow(unused)]

trait RegisterToggle {

    type Reg: Readable + Resettable + Writable;

    /// Toggles bits in the register, applying the given operation to set and clear them.

    ///

    /// More efficient than two modify calls, because it does not read the register

    /// value twice.

    fn toggle(&self, op: impl Fn(&mut W<Self::Reg>, bool) -> &mut W<Self::Reg>);

}

impl<REG> RegisterToggle for Reg<REG>

where

    REG: Readable + Resettable + Writable,

{

    type Reg = REG;

    fn toggle(&self, op: impl Fn(&mut W<REG>, bool) -> &mut W<REG>) {

        let bits = self.modify(|_, w| op(w, true));

        self.write(|w| {

            unsafe { w.bits(bits) };

            op(w, false)

        });

    }

}

#[cfg(is_debug_build)]

procmacros::warning! {"

WARNING: use --release

  We *strongly* recommend using release profile when building esp-hal.

  The dev profile can potentially be one or more orders of magnitude

  slower than release, and may cause issues with timing-sensitive

  peripherals or devices.

"}

/// A marker trait for driver modes.

///

/// Different driver modes offer different features and different API. Using

/// this trait as a generic parameter ensures that the driver is initialized in

/// the correct mode.

pub trait DriverMode: crate::private::Sealed {}

#[procmacros::doc_replace]

/// Marker type signaling that a driver is initialized in blocking mode.

///

/// Drivers are constructed in blocking mode by default. To learn about the

/// differences between blocking and async drivers, see the [`Async`] mode

/// documentation.

///

/// [`Async`] drivers can be converted to a [`Blocking`] driver using the

/// `into_blocking` method, for example:

#[cfg_attr(

    // Feature-gated so that this doesn't prevent gradual device bringup. Any

    // stable driver would serve the purpose here, so this block will be part

    // of the released documentation.

    all(uart_driver_supported, gpio_driver_supported),

    doc = r#"

```rust, no_run

# {before_snippet}

# use esp_hal::uart::{Config, Uart};

let uart = Uart::new(peripherals.UART0, Config::default())?

    .with_rx(peripherals.GPIO1)

    .with_tx(peripherals.GPIO2)

    .into_async();

let blocking_uart = uart.into_blocking();

# {after_snippet}

```

"#

)]

#[derive(Debug)]

#[non_exhaustive]

pub struct Blocking;

#[procmacros::doc_replace]

/// Marker type signaling that a driver is initialized in async mode.

///

/// Drivers are constructed in blocking mode by default. To set up an async

/// driver, a [`Blocking`] driver must be converted to an `Async` driver using

/// the `into_async` method, for example:

#[cfg_attr(

    // Feature-gated so that this doesn't prevent gradual device bringup. Any

    // stable driver would serve the purpose here, so this block will be part

    // of the released documentation.

    all(uart_driver_supported, gpio_driver_supported),

    doc = r#"

```rust, no_run

# {before_snippet}

# use esp_hal::uart::{Config, Uart};

let uart = Uart::new(peripherals.UART0, Config::default())?

    .with_rx(peripherals.GPIO1)

    .with_tx(peripherals.GPIO2)

    .into_async();

///

# {after_snippet}

```

"#

)]

/// Drivers can be converted back to blocking mode using the `into_blocking`

/// method, see [`Blocking`] documentation for more details.

///

/// Async mode drivers offer most of the same features as blocking drivers, but

/// with the addition of async APIs. Interrupt-related functions are not

/// available in async mode, as they are handled by the driver's interrupt

/// handlers.

///

/// Async functions usually take up more space than their blocking counterparts,

/// and they are generally slower. This is because async functions are implemented

/// using a state machine that is driven by interrupts and is polled by a runtime.

/// For short operations, the overhead of the state machine can be significant.

/// Consider using the blocking functions on the async driver for small transfers.

///

/// When initializing an async driver, the driver disables user-specified

/// interrupt handlers, and sets up internal interrupt handlers that drive the

/// driver's async API. The driver's interrupt handlers run on the same core as

/// the driver was initialized on. This means that the driver can not be sent

/// across threads, to prevent incorrect concurrent access to the peripheral.

///

/// Switching back to blocking mode will disable the interrupt handlers and

/// return the driver to a state where it can be sent across threads.

#[derive(Debug)]

#[non_exhaustive]

pub struct Async(PhantomData<*const ()>);

unsafe impl Sync for Async {}

impl crate::DriverMode for Blocking {}

impl crate::DriverMode for Async {}

impl crate::private::Sealed for Blocking {}

impl crate::private::Sealed for Async {}

#[doc(hidden)]

pub use private::Internal;

/// Marker trait for types that can be safely used in `#[ram(unstable(persistent))]`.

///

/// # Safety

///

/// - The type must be inhabited

/// - The type must be valid for any bit pattern of its backing memory in case a reset occurs during

///   a write or a reset interrupts the zero initialization on first boot.

/// - Structs must contain only `Persistable` fields and padding

#[instability::unstable]

pub unsafe trait Persistable: Sized {}

/// Marker trait for types that can be safely used in `#[ram(reclaimed)]`.

///

/// # Safety

///

/// - The type must be some form of `MaybeUninit<T>`

#[doc(hidden)]

pub unsafe trait Uninit: Sized {}

macro_rules! impl_persistable {

    ($($t:ty),+) => {$(

        unsafe impl Persistable for $t {}

    )+};

    (atomic $($t:ident),+) => {$(

        unsafe impl Persistable for portable_atomic::$t {}

    )+};

}

impl_persistable!(

    u8, i8, u16, i16, u32, i32, u64, i64, u128, i128, usize, isize, f32, f64

);

impl_persistable!(atomic AtomicU8, AtomicI8, AtomicU16, AtomicI16, AtomicU32, AtomicI32, AtomicUsize, AtomicIsize);

unsafe impl<T: Persistable, const N: usize> Persistable for [T; N] {}

unsafe impl<T> Uninit for core::mem::MaybeUninit<T> {}

unsafe impl<T, const N: usize> Uninit for [core::mem::MaybeUninit<T>; N] {}

#[doc(hidden)]

pub mod __macro_implementation {

    //! Private implementation details of esp-hal-procmacros.

    #[instability::unstable]

    pub const fn assert_is_zeroable<T: bytemuck::Zeroable>() {}

    #[instability::unstable]

    pub const fn assert_is_persistable<T: super::Persistable>() {}

    pub const fn assert_is_uninit<T: super::Uninit>() {}

    #[cfg(feature = "rt")]

    #[cfg(riscv)]

    pub use esp_riscv_rt::entry as __entry;

    pub use static_cell;

    #[cfg(feature = "rt")]

    #[cfg(xtensa)]

    pub use xtensa_lx_rt::entry as __entry;

}

use crate::clock::{ClockConfig, CpuClock};

#[cfg(feature = "rt")]

use crate::peripherals::Peripherals;

/// A spinlock for seldom called stuff. Users assume that lock contention is not an issue.

#[cfg(feature = "rt")]

pub(crate) static ESP_HAL_LOCK: esp_sync::RawMutex = esp_sync::RawMutex::new();

#[procmacros::doc_replace]

/// System configuration.

///

/// This `struct` is marked with `#[non_exhaustive]` and cannot be instantiated

/// directly. This is done to prevent breaking changes when new fields are added

/// to the `struct`. Instead, use the [`Config::default()`] method to create a

/// new instance.

///

/// # Examples

///

/// ### Default initialization

///

/// ```rust, no_run

/// # {before_snippet}

/// let peripherals = esp_hal::init(esp_hal::Config::default());

/// # {after_snippet}

/// ```

///

/// ### Custom initialization

/// ```rust, no_run

/// # {before_snippet}

/// use esp_hal::{clock::CpuClock, time::Duration};

/// let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());

/// let peripherals = esp_hal::init(config);

/// # {after_snippet}

/// ```

#[non_exhaustive]

pub struct Config {

    /// The CPU clock configuration.

    #[builder_lite(skip)]

    cpu_clock: ClockConfig,

}

impl Config {

    /// Applies a clock configuration.

    #[cfg_attr(

        feature = "unstable",

        doc = r"

With the `unstable` feature enabled, this function accepts both [`ClockConfig`] and [`CpuClock`].

"

    )]

    #[cfg(feature = "unstable")]

    pub fn with_cpu_clock(self, cpu_clock: impl Into<ClockConfig>) -> Self {

            cpu_clock: cpu_clock.into(),

            ..self

        }

    }

    /// Applies a clock configuration.

    #[cfg(not(feature = "unstable"))]

    pub fn with_cpu_clock(self, cpu_clock: CpuClock) -> Self {

        Self {

            cpu_clock: cpu_clock.into(),

            ..self

        }

    }

    /// The CPU clock configuration preset.

    ///

    /// # Panics

    ///

    /// Panics if the CPU clock configuration is not **exactly** one of the [`CpuClock`] presets

    #[cfg_attr(feature = "unstable", deprecated(note = "Use `clock_config` instead."))] // TODO: mention ClockTree APIs once they are exposed to the user.

    pub fn cpu_clock(&self) -> CpuClock {

        unwrap!(

            self.cpu_clock.try_get_preset(),

            "CPU clock configuration is not a preset"

        )

    }

    /// The CPU clock configuration.

    #[instability::unstable]

    pub fn clock_config(&self) -> ClockConfig {

    }

}

#[procmacros::doc_replace]

/// Initializes the system.

///

/// Sets up the CPU clock and watchdog, then returns the peripherals and clocks.

///

/// # Examples

///

/// ```rust, no_run

/// # {before_snippet}

/// use esp_hal::{Config, init};

/// let peripherals = init(Config::default());

/// # {after_snippet}

/// ```

#[cfg_attr(docsrs, doc(cfg(feature = "rt")))]

#[cfg(feature = "rt")]

    crate::soc::pre_init();

    let min_rev = esp_config::esp_config_int!(u16, "ESP_HAL_CONFIG_MIN_CHIP_REVISION");

    assert!(

        crate::efuse::chip_revision() >= crate::efuse::ChipRevision::from_combined(min_rev),

        "This chip's hardware revision is older than the minimum required \

         v{}.{} (ESP_HAL_CONFIG_MIN_CHIP_REVISION).",

        min_rev / 100,

        min_rev % 100,

    );

    #[cfg(soc_cpu_has_branch_predictor)]

    crate::soc::enable_branch_predictor();

    // Have we already overflown the stack?

    #[cfg(init_stack_ptr_range_check)]

    crate::soc::ensure_stack_pointer_in_range();

    #[cfg(stack_guard_monitoring)]

    crate::soc::enable_main_stack_guard_monitoring();

    #[cfg(all(feature = "rt", enable_pmp, riscv))]

    crate::soc::enable_pmp();

    system::disable_peripherals();

    let mut peripherals = Peripherals::take();

    crate::clock::init(config.clock_config());

    // RTC domain must be enabled before we try to disable

    let mut rtc = crate::rtc_cntl::Rtc::new(peripherals.RTC_TIMER.reborrow());

    #[cfg(sleep_driver_supported)]

    crate::rtc_cntl::sleep::init(&rtc);

    // Disable watchdog timers

    #[cfg(soc_has_swd_watchdog)]

    rtc.swd.disable();

    rtc.rwdt.disable();

    #[cfg(timergroup_timg0)]

    crate::timer::timg::Wdt::<crate::peripherals::TIMG0<'static>>::new().disable();

    #[cfg(timergroup_timg1)]

    crate::timer::timg::Wdt::<crate::peripherals::TIMG1<'static>>::new().disable();

    crate::time::implem::time_init();

    #[cfg(gpio_driver_supported)]

    crate::gpio::interrupt::bind_default_interrupt_handler();

    unsafe {

        esp_rom_sys::init_syscall_table();

    }

    #[cfg(all(riscv, write_vec_table_monitoring))]

    crate::soc::setup_trap_section_protection();

    #[cfg(all(feature = "unstable", multi_core))]

    crate::interrupt::ipc::install();

    peripherals