GetLitFam/esp-hal
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Random additional GPIO cleanups, implement Peripheral for drivers (#2094)

Browse Source 
* Reuse enable_iomux_clk_gate

* Remove public functions

* Remove set_to_input

* Deduplicate constructor

* Deduplicate is_listening

* Hide PinFuture better

* Deduplicate set_int_enable

* Align macro indentation

* Typo

* Slightly simplify the touch_into macro

* Implement the AnalogPin trait directly

* Provide default impls for simple forwarding methods

* Newtype ErasedPin

* Merge rtc_pin macros

* Fmt

* Changelog

* Fix migration guide

* Fix example

* Fix ETM
This commit is contained in:
Dániel Buga 2024-09-06 12:26:23 +02:00 committed by GitHub
parent b5f0246129
commit d6813a4bf0
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
20 changed files with 436 additions and 611 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
esp-hal/CHANGELOG.md
View File

@ -15,31 +15,36 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
- Added missing functions to `Flex`: `unlisten`, `is_interrupt_set`, `wakeup_enable`, `wait_for_high`, `wait_for_low`, `wait_for_rising_edge`, `wait_for_falling_edge`, `wait_for_any_edge`. (#2075)
- `Flex` now implements `Wait`. (#2075)
- Added sleep and wakeup support for esp32c2 (#1922)
- `Input`, `Output`, `OutputOpenDrain` and `Flex` now implement `Peripheral`. (#2094)
### Changed
- Make saving and restoring SHA digest state an explicit operation (#2049)
- Reordered RX-TX pairs in all APIs to be consistent (#2074)
- Make saving and restoring SHA digest state an explicit operation (#2049)
- `Delay::new()` is now a `const` function (#1999)
- You can now create an `AnyPin` out of an `ErasedPin`. (#2072)
- `Input`, `Output`, `OutputOpenDrain` and `Flex` are now type-erased by default. Use the new `new_typed` constructor to keep using the ZST pin types. (#2075)
- To avoid confusion with the `Rtc::current_time` wall clock time APIs, we've renamed `esp_hal::time::current_time` to `esp_hal::time::now`. (#2091)
- Renamed `touch::Continous` to `touch::Continuous`. (#2094)
- The (previously undocumented) `ErasedPin` enum has been replaced with the `ErasedPin` struct. (#2094)
### Fixed
- SHA driver can now be safely used in multiple contexts concurrently (#2049)
- SHA driver can now be safely used in multiple contexts concurrently (#2049)
- Fixed an issue with DMA transfers potentially not waking up the correct async task (#2065)
- Fixed an issue with LCD_CAM i8080 where it would send double the clocks in 16bit mode (#2085)
- Fix i2c embedded-hal transaction (#2028)
### Removed
- Removed `digest::Digest` implementation from SHA (#2049)
- Removed `digest::Digest` implementation from SHA (#2049)
- Removed `NoPinType` in favour of `DummyPin`. (#2068)
- Removed the `async`, `embedded-hal-02`, `embedded-hal`, `embedded-io`, `embedded-io-async`, and `ufmt` features (#2070)
- Removed the `GpioN` type aliasses. Use `GpioPin<N>` instead. (#2073)
- Removed `Peripherals::take`. Use `esp_hal::init` to obtain `Peripherals` (#1999)
- Removed `AnyInputOnlyPin` in favour of `AnyPin`. (#2071)
- Removed the following functions from `GpioPin`: `is_high`, `is_low`, `set_high`, `set_low`, `set_state`, `is_set_high`, `is_set_low`, `toggle`. (#2094)
## [0.20.1] - 2024-08-30

22
esp-hal/src/gpio/any_pin.rs
View File

@ -78,7 +78,6 @@ impl<'d> Pin for AnyPin<'d> {
fn unlisten(&mut self, _internal: private::Internal);
fn is_interrupt_set(&self, _internal: private::Internal) -> bool;
fn clear_interrupt(&mut self, _internal: private::Internal);
fn wakeup_enable(&mut self, enable: bool, event: WakeEvent, _internal: private::Internal);
}
}
}
@ -102,17 +101,6 @@ impl<'d> OutputPin for AnyPin<'d> {
}
}
fn connect_peripheral_to_output(&mut self, signal: OutputSignal, _internal: private::Internal) {
self.pin.connect_peripheral_to_output_with_options(
signal,
self.is_inverted,
false,
false,
self.is_inverted,
private::Internal,
);
}
fn connect_peripheral_to_output_with_options(
&mut self,
signal: OutputSignal,
@ -148,7 +136,6 @@ impl<'d> InputPin for AnyPin<'d> {
delegate::delegate! {
to self.pin {
fn init_input(&self, pull_down: bool, pull_up: bool, _internal: private::Internal);
fn set_to_input(&mut self, _internal: private::Internal);
fn enable_input(&mut self, on: bool, _internal: private::Internal);
fn enable_input_in_sleep_mode(&mut self, on: bool, _internal: private::Internal);
fn is_input_high(&self, _internal: private::Internal) -> bool;
@ -156,15 +143,6 @@ impl<'d> InputPin for AnyPin<'d> {
}
}
fn connect_input_to_peripheral(&mut self, signal: InputSignal, _internal: private::Internal) {
self.pin.connect_input_to_peripheral_with_options(
signal,
self.is_inverted,
self.is_inverted,
private::Internal,
);
}
fn connect_input_to_peripheral_with_options(
&mut self,
signal: InputSignal,

2
esp-hal/src/gpio/dummy_pin.rs
View File

@ -113,8 +113,6 @@ impl OutputPin for DummyPin {
impl InputPin for DummyPin {
fn init_input(&self, _pull_down: bool, _pull_up: bool, _: private::Internal) {}
fn set_to_input(&mut self, _: private::Internal) {}
fn enable_input(&mut self, _on: bool, _: private::Internal) {}
fn enable_input_in_sleep_mode(&mut self, _on: bool, _: private::Internal) {}

630
esp-hal/src/gpio/mod.rs
View File

File diff suppressed because it is too large Load Diff

2
esp-hal/src/i2s.rs
View File

@ -999,7 +999,7 @@ mod private {
P: InputPin,
{
into_ref!(pin);
pin.set_to_input(crate::private::Internal);
pin.init_input(false, false, crate::private::Internal);
pin.connect_input_to_peripheral(T::din_signal(), crate::private::Internal);
self
}

60
esp-hal/src/lcd_cam/cam.rs
View File

@ -311,7 +311,7 @@ impl<'d, CH: DmaChannel> Camera<'d, CH> {
pub fn with_pixel_clock<PCLK: InputPin>(self, pclk: impl Peripheral<P = PCLK> + 'd) -> Self {
crate::into_ref!(pclk);
pclk.set_to_input(crate::private::Internal);
pclk.init_input(false, false, crate::private::Internal);
pclk.connect_input_to_peripheral(InputSignal::CAM_PCLK, crate::private::Internal);
self
@ -327,9 +327,9 @@ impl<'d, CH: DmaChannel> Camera<'d, CH> {
crate::into_ref!(vsync);
crate::into_ref!(h_enable);
vsync.set_to_input(crate::private::Internal);
vsync.init_input(false, false, crate::private::Internal);
vsync.connect_input_to_peripheral(InputSignal::CAM_V_SYNC, crate::private::Internal);
h_enable.set_to_input(crate::private::Internal);
h_enable.init_input(false, false, crate::private::Internal);
h_enable.connect_input_to_peripheral(InputSignal::CAM_H_ENABLE, crate::private::Internal);
self.lcd_cam
@ -351,11 +351,11 @@ impl<'d, CH: DmaChannel> Camera<'d, CH> {
crate::into_ref!(hsync);
crate::into_ref!(h_enable);
vsync.set_to_input(crate::private::Internal);
vsync.init_input(false, false, crate::private::Internal);
vsync.connect_input_to_peripheral(InputSignal::CAM_V_SYNC, crate::private::Internal);
hsync.set_to_input(crate::private::Internal);
hsync.init_input(false, false, crate::private::Internal);
hsync.connect_input_to_peripheral(InputSignal::CAM_H_SYNC, crate::private::Internal);
h_enable.set_to_input(crate::private::Internal);
h_enable.init_input(false, false, crate::private::Internal);
h_enable.connect_input_to_peripheral(InputSignal::CAM_H_ENABLE, crate::private::Internal);
self.lcd_cam
@ -475,21 +475,21 @@ impl RxEightBits {
crate::into_ref!(pin_6);
crate::into_ref!(pin_7);
pin_0.set_to_input(crate::private::Internal);
pin_0.init_input(false, false, crate::private::Internal);
pin_0.connect_input_to_peripheral(InputSignal::CAM_DATA_0, crate::private::Internal);
pin_1.set_to_input(crate::private::Internal);
pin_1.init_input(false, false, crate::private::Internal);
pin_1.connect_input_to_peripheral(InputSignal::CAM_DATA_1, crate::private::Internal);
pin_2.set_to_input(crate::private::Internal);
pin_2.init_input(false, false, crate::private::Internal);
pin_2.connect_input_to_peripheral(InputSignal::CAM_DATA_2, crate::private::Internal);
pin_3.set_to_input(crate::private::Internal);
pin_3.init_input(false, false, crate::private::Internal);
pin_3.connect_input_to_peripheral(InputSignal::CAM_DATA_3, crate::private::Internal);
pin_4.set_to_input(crate::private::Internal);
pin_4.init_input(false, false, crate::private::Internal);
pin_4.connect_input_to_peripheral(InputSignal::CAM_DATA_4, crate::private::Internal);
pin_5.set_to_input(crate::private::Internal);
pin_5.init_input(false, false, crate::private::Internal);
pin_5.connect_input_to_peripheral(InputSignal::CAM_DATA_5, crate::private::Internal);
pin_6.set_to_input(crate::private::Internal);
pin_6.init_input(false, false, crate::private::Internal);
pin_6.connect_input_to_peripheral(InputSignal::CAM_DATA_6, crate::private::Internal);
pin_7.set_to_input(crate::private::Internal);
pin_7.init_input(false, false, crate::private::Internal);
pin_7.connect_input_to_peripheral(InputSignal::CAM_DATA_7, crate::private::Internal);
Self { _pins: () }
@ -563,37 +563,37 @@ impl RxSixteenBits {
crate::into_ref!(pin_14);
crate::into_ref!(pin_15);
pin_0.set_to_input(crate::private::Internal);
pin_0.init_input(false, false, crate::private::Internal);
pin_0.connect_input_to_peripheral(InputSignal::CAM_DATA_0, crate::private::Internal);
pin_1.set_to_input(crate::private::Internal);
pin_1.init_input(false, false, crate::private::Internal);
pin_1.connect_input_to_peripheral(InputSignal::CAM_DATA_1, crate::private::Internal);
pin_2.set_to_input(crate::private::Internal);
pin_2.init_input(false, false, crate::private::Internal);
pin_2.connect_input_to_peripheral(InputSignal::CAM_DATA_2, crate::private::Internal);
pin_3.set_to_input(crate::private::Internal);
pin_3.init_input(false, false, crate::private::Internal);
pin_3.connect_input_to_peripheral(InputSignal::CAM_DATA_3, crate::private::Internal);
pin_4.set_to_input(crate::private::Internal);
pin_4.init_input(false, false, crate::private::Internal);
pin_4.connect_input_to_peripheral(InputSignal::CAM_DATA_4, crate::private::Internal);
pin_5.set_to_input(crate::private::Internal);
pin_5.init_input(false, false, crate::private::Internal);
pin_5.connect_input_to_peripheral(InputSignal::CAM_DATA_5, crate::private::Internal);
pin_6.set_to_input(crate::private::Internal);
pin_6.init_input(false, false, crate::private::Internal);
pin_6.connect_input_to_peripheral(InputSignal::CAM_DATA_6, crate::private::Internal);
pin_7.set_to_input(crate::private::Internal);
pin_7.init_input(false, false, crate::private::Internal);
pin_7.connect_input_to_peripheral(InputSignal::CAM_DATA_7, crate::private::Internal);
pin_8.set_to_input(crate::private::Internal);
pin_8.init_input(false, false, crate::private::Internal);
pin_8.connect_input_to_peripheral(InputSignal::CAM_DATA_8, crate::private::Internal);
pin_9.set_to_input(crate::private::Internal);
pin_9.init_input(false, false, crate::private::Internal);
pin_9.connect_input_to_peripheral(InputSignal::CAM_DATA_9, crate::private::Internal);
pin_10.set_to_input(crate::private::Internal);
pin_10.init_input(false, false, crate::private::Internal);
pin_10.connect_input_to_peripheral(InputSignal::CAM_DATA_10, crate::private::Internal);
pin_11.set_to_input(crate::private::Internal);
pin_11.init_input(false, false, crate::private::Internal);
pin_11.connect_input_to_peripheral(InputSignal::CAM_DATA_11, crate::private::Internal);
pin_12.set_to_input(crate::private::Internal);
pin_12.init_input(false, false, crate::private::Internal);
pin_12.connect_input_to_peripheral(InputSignal::CAM_DATA_12, crate::private::Internal);
pin_13.set_to_input(crate::private::Internal);
pin_13.init_input(false, false, crate::private::Internal);
pin_13.connect_input_to_peripheral(InputSignal::CAM_DATA_13, crate::private::Internal);
pin_14.set_to_input(crate::private::Internal);
pin_14.init_input(false, false, crate::private::Internal);
pin_14.connect_input_to_peripheral(InputSignal::CAM_DATA_14, crate::private::Internal);
pin_15.set_to_input(crate::private::Internal);
pin_15.init_input(false, false, crate::private::Internal);
pin_15.connect_input_to_peripheral(InputSignal::CAM_DATA_15, crate::private::Internal);
Self { _pins: () }

9
esp-hal/src/parl_io.rs
View File

@ -332,7 +332,7 @@ where
pcr.parl_clk_tx_conf()
.modify(|_, w| unsafe { w.parl_clk_tx_sel().bits(3).parl_clk_tx_div_num().bits(0) }); // PAD_CLK_TX, no divider
self.pin.set_to_input(crate::private::Internal);
self.pin.init_input(false, false, crate::private::Internal);
self.pin.connect_input_to_peripheral(
crate::gpio::InputSignal::PARL_TX_CLK,
crate::private::Internal,
@ -367,7 +367,7 @@ where
pcr.parl_clk_rx_conf()
.modify(|_, w| unsafe { w.parl_clk_rx_sel().bits(3).parl_clk_rx_div_num().bits(0) }); // PAD_CLK_TX, no divider
self.pin.set_to_input(crate::private::Internal);
self.pin.init_input(false, false, crate::private::Internal);
self.pin.connect_input_to_peripheral(
crate::gpio::InputSignal::PARL_RX_CLK,
crate::private::Internal,
@ -634,7 +634,8 @@ where
{
fn configure(&mut self) -> Result<(), Error> {
self.rx_pins.configure()?;
self.valid_pin.set_to_input(crate::private::Internal);
self.valid_pin
.init_input(false, false, crate::private::Internal);
self.valid_pin
.connect_input_to_peripheral(Instance::rx_valid_pin_signal(), crate::private::Internal);
Instance::set_rx_sw_en(false);
@ -738,7 +739,7 @@ macro_rules! rx_pins {
{
fn configure(&mut self) -> Result<(), Error> {
$(
self.[< pin_ $pin:lower >].set_to_input($crate::private::Internal);
self.[< pin_ $pin:lower >].init_input(false, false, $crate::private::Internal);
self.[< pin_ $pin:lower >].connect_input_to_peripheral(crate::gpio::InputSignal::$signal, $crate::private::Internal);
)+

6
esp-hal/src/peripheral.rs
View File

@ -194,11 +194,11 @@ pub trait Peripheral: Sized + crate::private::Sealed {
}
}
impl<T> Peripheral for &mut T
impl<T, P> Peripheral for &mut T
where
T: Peripheral<P = T>,
T: Peripheral<P = P>,
{
type P = T;
type P = P;
unsafe fn clone_unchecked(&mut self) -> Self::P {
T::clone_unchecked(self)

4
esp-hal/src/rmt.rs
View File

@ -387,7 +387,7 @@ where
}
crate::into_ref!(pin);
pin.set_to_input(crate::private::Internal);
pin.init_input(false, false, crate::private::Internal);
pin.connect_input_to_peripheral(T::input_signal(), crate::private::Internal);
T::set_divider(config.clk_divider);
T::set_carrier(
@ -433,7 +433,7 @@ where
}
crate::into_ref!(pin);
pin.set_to_input(crate::private::Internal);
pin.init_input(false, false, crate::private::Internal);
pin.connect_input_to_peripheral(T::input_signal(), crate::private::Internal);
T::set_divider(config.clk_divider);
T::set_carrier(

2
esp-hal/src/soc/esp32/gpio.rs
View File

@ -855,7 +855,7 @@ crate::gpio::touch_into! {
(5, 12, 15, sar_touch_thres3, touch_out_th5, true )
(6, 14, 16, sar_touch_thres4, touch_out_th6, true )
(7, 27, 17, sar_touch_thres4, touch_out_th7, true )
---
// ---
(8, 33, 8, sar_touch_thres5, touch_out_th8, false )
(9, 32, 9, sar_touch_thres5, touch_out_th9, false )
}

4
esp-hal/src/spi/master.rs
View File

@ -542,7 +542,7 @@ where
/// Sets the specified pin to input and connects it to the SPI MISO signal.
pub fn with_miso<MISO: InputPin>(self, miso: impl Peripheral<P = MISO> + 'd) -> Self {
crate::into_ref!(miso);
miso.set_to_input(private::Internal);
miso.init_input(false, false, private::Internal);
miso.connect_input_to_peripheral(self.spi.miso_signal(), private::Internal);
self
@ -593,7 +593,7 @@ where
if let Some(miso) = miso {
crate::into_ref!(miso);
miso.set_to_input(private::Internal);
miso.init_input(false, false, private::Internal);
miso.connect_input_to_peripheral(self.spi.miso_signal(), private::Internal);
}

6
esp-hal/src/spi/slave.rs
View File

@ -115,16 +115,16 @@ where
mode: SpiMode,
) -> Spi<'d, T, FullDuplexMode> {
crate::into_ref!(spi, sck, mosi, miso, cs);
sck.set_to_input(private::Internal);
sck.init_input(false, false, private::Internal);
sck.connect_input_to_peripheral(spi.sclk_signal(), private::Internal);
mosi.set_to_input(private::Internal);
mosi.init_input(false, false, private::Internal);
mosi.connect_input_to_peripheral(spi.mosi_signal(), private::Internal);
miso.set_to_push_pull_output(private::Internal);
miso.connect_peripheral_to_output(spi.miso_signal(), private::Internal);
cs.set_to_input(private::Internal);
cs.init_input(false, false, private::Internal);
cs.connect_input_to_peripheral(spi.cs_signal(), private::Internal);
Self::new_internal(spi, mode)

32
esp-hal/src/touch.rs
View File

@ -13,7 +13,7 @@
//! # use esp_hal::gpio::Io;
//! let io = Io::new(peripherals.GPIO, peripherals.IO_MUX);
//! let touch_pin0 = io.pins.gpio2;
//! let touch = Touch::continous_mode(peripherals.TOUCH, None);
//! let touch = Touch::continuous_mode(peripherals.TOUCH, None);
//! let mut touchpad = TouchPad::new(touch_pin0, &touch);
//! // ... give the peripheral some time for the measurement
//! let touch_val = touchpad.read();
@ -50,16 +50,16 @@ pub trait TouchMode: Sealed {}
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub struct OneShot;
/// Marker struct for the touch peripherals continous reading mode. In the
/// Marker struct for the touch peripherals continuous reading mode. In the
/// technical reference manual, this is referred to as "start FSM via timer".
#[derive(Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub struct Continous;
pub struct Continuous;
impl TouchMode for OneShot {}
impl TouchMode for Continous {}
impl TouchMode for Continuous {}
impl Sealed for OneShot {}
impl Sealed for Continous {}
impl Sealed for Continuous {}
/// Touchpad threshold type.
#[derive(Debug, Copy, Clone)]
@ -81,7 +81,7 @@ pub struct TouchConfig {
/// Duration of a single measurement (in cycles of the 8 MHz touch clock).
/// Defaults to `0x7fff`
pub measurement_duration: Option<u16>,
/// Sleep cycles for the touch timer in [`Continous`]-mode. Defaults to
/// Sleep cycles for the touch timer in [`Continuous`]-mode. Defaults to
/// `0x100`
pub sleep_cycles: Option<u16>,
}
@ -147,8 +147,8 @@ impl<'d, TOUCHMODE: TouchMode, MODE: Mode> Touch<'d, TOUCHMODE, MODE> {
});
}
/// Common parts of the continous mode initialization.
fn initialize_common_continoous(config: Option<TouchConfig>) {
/// Common parts of the continuous mode initialization.
fn initialize_common_continuous(config: Option<TouchConfig>) {
let rtccntl = unsafe { &*RTC_CNTL::ptr() };
let sens = unsafe { &*SENS::ptr() };
@ -241,8 +241,8 @@ impl<'d> Touch<'d, OneShot, Blocking> {
}
}
}
impl<'d> Touch<'d, Continous, Blocking> {
/// Initializes the touch peripheral in continous mode and returns this
impl<'d> Touch<'d, Continuous, Blocking> {
/// Initializes the touch peripheral in continuous mode and returns this
/// marker struct. Optionally accepts configuration options.
///
/// ## Example
@ -254,16 +254,16 @@ impl<'d> Touch<'d, Continous, Blocking> {
/// measurement_duration: Some(0x3000),
/// ..Default::default()
/// });
/// let touch = Touch::continous_mode(peripherals.TOUCH, touch_cfg);
/// let touch = Touch::continuous_mode(peripherals.TOUCH, touch_cfg);
/// # }
/// ```
pub fn continous_mode(
pub fn continuous_mode(
touch_peripheral: impl Peripheral<P = TOUCH> + 'd,
config: Option<TouchConfig>,
) -> Self {
crate::into_ref!(touch_peripheral);
Self::initialize_common_continoous(config);
Self::initialize_common_continuous(config);
Self {
_inner: touch_peripheral,
@ -272,8 +272,8 @@ impl<'d> Touch<'d, Continous, Blocking> {
}
}
}
impl<'d> Touch<'d, Continous, Async> {
/// Initializes the touch peripheral in continous async mode and returns
impl<'d> Touch<'d, Continuous, Async> {
/// Initializes the touch peripheral in continuous async mode and returns
/// this marker struct.
///
/// ## Warning:
@ -307,7 +307,7 @@ impl<'d> Touch<'d, Continous, Async> {
) -> Self {
crate::into_ref!(touch_peripheral);
Self::initialize_common_continoous(config);
Self::initialize_common_continuous(config);
rtc.set_interrupt_handler(asynch::handle_touch_interrupt);

2
esp-hal/src/twai/mod.rs
View File

@ -741,7 +741,7 @@ where
}
tx_pin.set_to_push_pull_output(crate::private::Internal);
tx_pin.connect_peripheral_to_output(T::OUTPUT_SIGNAL, crate::private::Internal);
rx_pin.set_to_input(crate::private::Internal);
rx_pin.init_input(false, false, crate::private::Internal);
rx_pin.connect_input_to_peripheral(T::INPUT_SIGNAL, crate::private::Internal);
// Set the operating mode based on provided option

16
esp-hal/src/uart.rs
View File

@ -613,7 +613,7 @@ where
/// Configure CTS pin
pub fn with_cts<CTS: InputPin>(self, cts: impl Peripheral<P = CTS> + 'd) -> Self {
crate::into_ref!(cts);
cts.set_to_input(Internal);
cts.init_input(false, false, Internal);
cts.connect_input_to_peripheral(T::cts_signal(), Internal);
self
@ -791,7 +791,7 @@ where
rx: impl Peripheral<P = RX> + 'd,
) -> Result<Self, Error> {
crate::into_ref!(rx);
rx.set_to_input(Internal);
rx.init_input(false, false, Internal);
rx.connect_input_to_peripheral(T::rx_signal(), Internal);
let (uart_rx, _) = Uart::<'d, T, Blocking>::new_with_config_inner(uart, config)?.split();
@ -817,7 +817,7 @@ where
tx.set_to_push_pull_output(Internal);
tx.connect_peripheral_to_output(T::tx_signal(), Internal);
rx.set_to_input(Internal);
rx.init_input(false, false, Internal);
rx.connect_input_to_peripheral(T::rx_signal(), Internal);
Self::new_with_config_inner(uart, config)
}
@ -833,7 +833,7 @@ where
tx.set_to_push_pull_output(Internal);
tx.connect_peripheral_to_output(T::tx_signal(), Internal);
rx.set_to_input(Internal);
rx.init_input(false, false, Internal);
rx.connect_input_to_peripheral(T::rx_signal(), Internal);
Self::new_inner(uart)
}
@ -848,7 +848,7 @@ where
tx.set_to_push_pull_output(Internal);
tx.connect_peripheral_to_output(T::tx_signal(), Internal);
rx.set_to_input(Internal);
rx.init_input(false, false, Internal);
rx.connect_input_to_peripheral(T::rx_signal(), Internal);
Self::new_inner(uart)
}
@ -916,7 +916,7 @@ where
/// Configure CTS pin
pub fn with_cts<CTS: InputPin>(self, cts: impl Peripheral<P = CTS> + 'd) -> Self {
crate::into_ref!(cts);
cts.set_to_input(Internal);
cts.init_input(false, false, Internal);
cts.connect_input_to_peripheral(T::cts_signal(), Internal);
self
@ -2141,7 +2141,7 @@ mod asynch {
tx.set_to_push_pull_output(Internal);
tx.connect_peripheral_to_output(T::tx_signal(), Internal);
rx.set_to_input(Internal);
rx.init_input(false, false, Internal);
rx.connect_input_to_peripheral(T::rx_signal(), Internal);
let mut this = Self::new_with_config_inner(uart, config)?;
@ -2303,7 +2303,7 @@ mod asynch {
rx: impl Peripheral<P = RX> + 'd,
) -> Result<Self, Error> {
crate::into_ref!(rx);
rx.set_to_input(Internal);
rx.init_input(false, false, Internal);
rx.connect_input_to_peripheral(T::rx_signal(), Internal);
let mut uart = Uart::<'d, T, Async>::new_with_config_inner(uart, config)?;

3
examples/src/bin/etm_gpio.rs
View File

@ -15,6 +15,7 @@ use esp_hal::{
etm::{GpioEtmChannels, GpioEtmInputConfig, GpioEtmOutputConfig},
Io,
Level,
Output,
Pull,
},
prelude::*,
@ -25,7 +26,7 @@ fn main() -> ! {
let peripherals = esp_hal::init(esp_hal::Config::default());
let io = Io::new(peripherals.GPIO, peripherals.IO_MUX);
let mut led = io.pins.gpio1;
let mut led = Output::new(io.pins.gpio1, Level::Low);
let button = io.pins.gpio9;
led.set_high();

2
examples/src/bin/i2s_read.rs
View File

@ -1,4 +1,4 @@
//! This shows how to continously receive data via I2S.
//! This shows how to continuously receive data via I2S.
//!
//! Without an additional I2S source device you can connect 3V3 or GND to DIN
//! to read 0 or 0xFF or connect DIN to WS to read two different values.

4
examples/src/bin/rmt_rx.rs
View File

@ -14,7 +14,7 @@
use esp_backtrace as _;
use esp_hal::{
delay::Delay,
gpio::Io,
gpio::{Io, Level, Output},
prelude::*,
rmt::{PulseCode, Rmt, RxChannel, RxChannelConfig, RxChannelCreator},
};
@ -27,7 +27,7 @@ fn main() -> ! {
let peripherals = esp_hal::init(esp_hal::Config::default());
let io = Io::new(peripherals.GPIO, peripherals.IO_MUX);
let mut out = io.pins.gpio5;
let mut out = Output::new(io.pins.gpio5, Level::Low);
cfg_if::cfg_if! {
if #[cfg(feature = "esp32h2")] {

6
examples/src/bin/touch.rs
View File

@ -21,12 +21,12 @@ use esp_hal::{
macros::ram,
prelude::*,
rtc_cntl::Rtc,
touch::{Continous, Touch, TouchConfig, TouchPad},
touch::{Continuous, Touch, TouchConfig, TouchPad},
Blocking,
};
use esp_println::println;
static TOUCH1: Mutex<RefCell<Option<TouchPad<GpioPin<4>, Continous, Blocking>>>> =
static TOUCH1: Mutex<RefCell<Option<TouchPad<GpioPin<4>, Continuous, Blocking>>>> =
Mutex::new(RefCell::new(None));
#[handler]
@ -62,7 +62,7 @@ fn main() -> ! {
..Default::default()
});
let touch = Touch::continous_mode(peripherals.TOUCH, touch_cfg);
let touch = Touch::continuous_mode(peripherals.TOUCH, touch_cfg);
let mut touch0 = TouchPad::new(touch_pin0, &touch);
let mut touch1 = TouchPad::new(touch_pin1, &touch);