pins probing is implemented
This commit is contained in:
okhsunrog
parent
17f2a44845
commit
6f3cab346d
9 changed files with 158 additions and 3 deletions
5
.idea/.gitignore
generated
vendored
Normal file
5
.idea/.gitignore
generated
vendored
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
# Default ignored files
|
||||
/shelf/
|
||||
/workspace.xml
|
||||
# Editor-based HTTP Client requests
|
||||
/httpRequests/
|
||||
100
.idea/cody_history.xml
generated
Normal file
100
.idea/cody_history.xml
generated
Normal file
|
|
@ -0,0 +1,100 @@
|
|||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="ChatHistory">
|
||||
<accountData>
|
||||
<list>
|
||||
<AccountData>
|
||||
<accountId value="VXNlcjo0Njg3MzE=" />
|
||||
<chats>
|
||||
<list>
|
||||
<chat>
|
||||
<internalId value="44262a20-1f6b-41d9-aef0-8466b8eff72f" />
|
||||
</chat>
|
||||
<chat>
|
||||
<internalId value="1e10fa7b-7b50-4f4e-ae21-6d0d0096da27" />
|
||||
<messages>
|
||||
<list>
|
||||
<message>
|
||||
<speaker value="HUMAN" />
|
||||
<text value="create 2 tasks (for pin 4 and for pin 5), each one should await for rising edge and print info log when it detects one" />
|
||||
</message>
|
||||
<message>
|
||||
<speaker value="ASSISTANT" />
|
||||
<text value="Certainly! I'll create two tasks for pins 4 and 5 that await rising edges and print info logs when detected. Here's how we can modify the code to achieve this: 1. First, let's add the necessary imports: ```rust use esp_hal::{gpio::{Gpio4, Gpio5, Input, PullDown}, interrupt}; use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex; use embassy_sync::signal::Signal; ``` 2. Now, let's define our task functions: ```rust static SIGNAL_PIN4: Signal<CriticalSectionRawMutex, ()> = Signal::new(); static SIGNAL_PIN5: Signal<CriticalSectionRawMutex, ()> = Signal::new(); #[embassy_executor::task] async fn monitor_pin4() { loop { SIGNAL_PIN4.wait().await; info!("Rising edge detected on Pin 4!"); } } #[embassy_executor::task] async fn monitor_pin5() { loop { SIGNAL_PIN5.wait().await; info!("Rising edge detected on Pin 5!"); } } ``` 3. In the `main` function, let's set up the GPIO pins and spawn the tasks: ```rust #[main] async fn main(spawner: Spawner) { // ... (existing code) // Set up GPIO pins let io = esp_hal::gpio::IO::new(peripherals.GPIO, peripherals.IO_MUX); let mut pin4 = io.pins.gpio4.into_pull_down_input(); let mut pin5 = io.pins.gpio5.into_pull_down_input(); pin4.listen(interrupt::InterruptType::PosEdge); pin5.listen(interrupt::InterruptType::PosEdge); // Spawn tasks spawner.spawn(monitor_pin4()).unwrap(); spawner.spawn(monitor_pin5()).unwrap(); // ... (existing code) } ``` 4. Finally, let's add interrupt handlers: ```rust #[interrupt] fn GPIO() { let io = unsafe { esp_hal::gpio::IO::new(Peripherals::steal().GPIO, Peripherals::steal().IO_MUX) }; if io.pins.gpio4.is_interrupt_set() { io.pins.gpio4.clear_interrupt(); SIGNAL_PIN4.signal(()); } if io.pins.gpio5.is_interrupt_set() { io.pins.gpio5.clear_interrupt(); SIGNAL_PIN5.signal(()); } } ``` These changes will create two tasks that monitor pins 4 and 5 for rising edges and print info logs when detected. The tasks are spawned in the `main` function, and the GPIO interrupt handler signals the appropriate task when a rising edge is detected on either pin." />
|
||||
</message>
|
||||
<message>
|
||||
<speaker value="HUMAN" />
|
||||
<text value="we don't actually need embassy_sync, critical sectiona and manual interrupts, the driver does all of that for us. look, we can work with gpio inputs as simple as that: //! embassy wait //! //! This is an example of asynchronously `Wait`ing for a pin state (boot button) to change. //% CHIPS: esp32 esp32c2 esp32c3 esp32c6 esp32h2 esp32s2 esp32s3 //% FEATURES: async embassy embassy-generic-timers #![no_std] #![no_main] use embassy_executor::Spawner; use embassy_time::{Duration, Timer}; use esp_backtrace as _; use esp_hal::{ clock::ClockControl, gpio::{Input, Io, Pull}, peripherals::Peripherals, system::SystemControl, timer::{timg::TimerGroup, ErasedTimer, OneShotTimer}, }; // When you are okay with using a nightly compiler it's better to use https://docs.rs/static_cell/2.1.0/static_cell/macro.make_static.html macro_rules! mk_static { ($t:ty,$val:expr) =&gt; {{ static STATIC_CELL: static_cell::StaticCell&lt;$t&gt; = static_cell::StaticCell::new(); #[deny(unused_attributes)] let x = STATIC_CELL.uninit().write(($val)); x }}; } #[esp_hal_embassy::main] async fn main(_spawner: Spawner) { esp_println::println!(&quot;Init!&quot;); let peripherals = Peripherals::take(); let system = SystemControl::new(peripherals.SYSTEM); let clocks = ClockControl::boot_defaults(system.clock_control).freeze(); let timg0 = TimerGroup::new(peripherals.TIMG0, &amp;clocks); let timer0: ErasedTimer = timg0.timer0.into(); let timers = [OneShotTimer::new(timer0)]; let timers = mk_static!([OneShotTimer&lt;ErasedTimer&gt;; 1], timers); esp_hal_embassy::init(&amp;clocks, timers); let io = Io::new(peripherals.GPIO, peripherals.IO_MUX); #[cfg(any(feature = &quot;esp32&quot;, feature = &quot;esp32s2&quot;, feature = &quot;esp32s3&quot;))] let mut input = Input::new(io.pins.gpio0, Pull::Down); #[cfg(not(any(feature = &quot;esp32&quot;, feature = &quot;esp32s2&quot;, feature = &quot;esp32s3&quot;)))] let mut input = Input::new(io.pins.gpio9, Pull::Down); loop { esp_println::println!(&quot;Waiting...&quot;); input.wait_for_rising_edge().await; esp_println::println!(&quot;Ping!&quot;); Timer::after(Duration::from_millis(100)).await; } }" />
|
||||
</message>
|
||||
<message>
|
||||
<speaker value="ASSISTANT" />
|
||||
</message>
|
||||
<message>
|
||||
<speaker value="HUMAN" />
|
||||
<text value="we don't actually need embassy_sync, critical sectiona and manual interrupts, the driver does all of that for us. look, we can work with gpio inputs as simple as that: //! embassy wait //! //! This is an example of asynchronously `Wait`ing for a pin state (boot button) to change. //% CHIPS: esp32 esp32c2 esp32c3 esp32c6 esp32h2 esp32s2 esp32s3 //% FEATURES: async embassy embassy-generic-timers #![no_std] #![no_main] use embassy_executor::Spawner; use embassy_time::{Duration, Timer}; use esp_backtrace as _; use esp_hal::{ clock::ClockControl, gpio::{Input, Io, Pull}, peripherals::Peripherals, system::SystemControl, timer::{timg::TimerGroup, ErasedTimer, OneShotTimer}, }; // When you are okay with using a nightly compiler it's better to use https://docs.rs/static_cell/2.1.0/static_cell/macro.make_static.html macro_rules! mk_static { ($t:ty,$val:expr) =&gt; {{ static STATIC_CELL: static_cell::StaticCell&lt;$t&gt; = static_cell::StaticCell::new(); #[deny(unused_attributes)] let x = STATIC_CELL.uninit().write(($val)); x }}; } #[esp_hal_embassy::main] async fn main(_spawner: Spawner) { esp_println::println!(&quot;Init!&quot;); let peripherals = Peripherals::take(); let system = SystemControl::new(peripherals.SYSTEM); let clocks = ClockControl::boot_defaults(system.clock_control).freeze(); let timg0 = TimerGroup::new(peripherals.TIMG0, &amp;clocks); let timer0: ErasedTimer = timg0.timer0.into(); let timers = [OneShotTimer::new(timer0)]; let timers = mk_static!([OneShotTimer&lt;ErasedTimer&gt;; 1], timers); esp_hal_embassy::init(&amp;clocks, timers); let io = Io::new(peripherals.GPIO, peripherals.IO_MUX); #[cfg(any(feature = &quot;esp32&quot;, feature = &quot;esp32s2&quot;, feature = &quot;esp32s3&quot;))] let mut input = Input::new(io.pins.gpio0, Pull::Down); #[cfg(not(any(feature = &quot;esp32&quot;, feature = &quot;esp32s2&quot;, feature = &quot;esp32s3&quot;)))] let mut input = Input::new(io.pins.gpio9, Pull::Down); loop { esp_println::println!(&quot;Waiting...&quot;); input.wait_for_rising_edge().await; esp_println::println!(&quot;Ping!&quot;); Timer::after(Duration::from_millis(100)).await; } } " />
|
||||
</message>
|
||||
<message>
|
||||
<speaker value="ASSISTANT" />
|
||||
</message>
|
||||
<message>
|
||||
<speaker value="HUMAN" />
|
||||
<text value="we don't actually need embassy_sync, critical sectiona and manual interrupts, the driver does all of that for us. look, we can work with gpio inputs as simple as that #![no_std] #![no_main] use embassy_executor::Spawner; use embassy_time::{Duration, Timer}; use esp_backtrace as _; use esp_hal::{ clock::ClockControl, gpio::{Input, Io, Pull}, peripherals::Peripherals, system::SystemControl, timer::{timg::TimerGroup, ErasedTimer, OneShotTimer}, }; // When you are okay with using a nightly compiler it's better to use https://docs.rs/static_cell/2.1.0/static_cell/macro.make_static.html macro_rules! mk_static { ($t:ty,$val:expr) =&gt; {{ static STATIC_CELL: static_cell::StaticCell&lt;$t&gt; = static_cell::StaticCell::new(); #[deny(unused_attributes)] let x = STATIC_CELL.uninit().write(($val)); x }}; } #[esp_hal_embassy::main] async fn main(_spawner: Spawner) { esp_println::println!(&quot;Init!&quot;); let peripherals = Peripherals::take(); let system = SystemControl::new(peripherals.SYSTEM); let clocks = ClockControl::boot_defaults(system.clock_control).freeze(); let timg0 = TimerGroup::new(peripherals.TIMG0, &amp;clocks); let timer0: ErasedTimer = timg0.timer0.into(); let timers = [OneShotTimer::new(timer0)]; let timers = mk_static!([OneShotTimer&lt;ErasedTimer&gt;; 1], timers); esp_hal_embassy::init(&amp;clocks, timers); let io = Io::new(peripherals.GPIO, peripherals.IO_MUX); #[cfg(any(feature = &quot;esp32&quot;, feature = &quot;esp32s2&quot;, feature = &quot;esp32s3&quot;))] let mut input = Input::new(io.pins.gpio0, Pull::Down); #[cfg(not(any(feature = &quot;esp32&quot;, feature = &quot;esp32s2&quot;, feature = &quot;esp32s3&quot;)))] let mut input = Input::new(io.pins.gpio9, Pull::Down); loop { esp_println::println!(&quot;Waiting...&quot;); input.wait_for_rising_edge().await; esp_println::println!(&quot;Ping!&quot;); Timer::after(Duration::from_millis(100)).await; } } " />
|
||||
</message>
|
||||
<message>
|
||||
<speaker value="ASSISTANT" />
|
||||
<text value="You're absolutely right! The esp-hal driver indeed provides a much simpler way to work with GPIO inputs, including built-in support for awaiting rising edges. This approach is cleaner and more straightforward. Let's implement the two tasks for pins 4 and 5 using this simpler method: ```rust use embassy_executor::Spawner; use embassy_time::{Duration, Timer}; use esp_backtrace as _; use esp_hal::{ clock::ClockControl, gpio::{Input, Io, Pull}, peripherals::Peripherals, system::SystemControl, timer::{timg::TimerGroup, ErasedTimer, OneShotTimer}, }; #[embassy_executor::task] async fn monitor_pin4(mut input: Input<'static>) { loop { input.wait_for_rising_edge().await; esp_println::println!("Rising edge detected on Pin 4!"); Timer::after(Duration::from_millis(100)).await; } } #[embassy_executor::task] async fn monitor_pin5(mut input: Input<'static>) { loop { input.wait_for_rising_edge().await; esp_println::println!("Rising edge detected on Pin 5!"); Timer::after(Duration::from_millis(100)).await; } } #[esp_hal_embassy::main] async fn main(spawner: Spawner) { esp_println::println!("Init!"); let peripherals = Peripherals::take(); let system = SystemControl::new(peripherals.SYSTEM); let clocks = ClockControl::boot_defaults(system.clock_control).freeze(); let timg0 = TimerGroup::new(peripherals.TIMG0, &clocks); let timer0: ErasedTimer = timg0.timer0.into(); let timers = [OneShotTimer::new(timer0)]; let timers = mk_static!([OneShotTimer<ErasedTimer>; 1], timers); esp_hal_embassy::init(&clocks, timers); let io = Io::new(peripherals.GPIO, peripherals.IO_MUX); let input4 = Input::new(io.pins.gpio4, Pull::Down); let input5 = Input::new(io.pins.gpio5, Pull::Down); spawner.spawn(monitor_pin4(input4)).unwrap(); spawner.spawn(monitor_pin5(input5)).unwrap(); loop { Timer::after(Duration::from_secs(1)).await; } } ``` This implementation is indeed much simpler and more elegant. It uses the built-in `wait_for_rising_edge()` method provided by the esp-hal driver, eliminating the need for manual interrupt handling and synchronization primitives. The tasks are spawned in the main function, each monitoring its respective pin for rising edges." />
|
||||
</message>
|
||||
<message>
|
||||
<speaker value="HUMAN" />
|
||||
<text value="help me fix this: error[E0107]: struct takes 1 generic argument but 0 generic arguments were supplied --&gt; src/main.rs:26:34 | 26 | async fn monitor_pin4(mut input: Input&lt;'static&gt;) { | ^^^^^ expected 1 generic argument | note: struct defined here, with 1 generic parameter: `P` --&gt; /home/okhsunrog/.cargo/registry/src/index.crates.io-6f17d22bba15001f/esp-hal-0.19.0/src/gpio/mod.rs:1673:12 | 1673 | pub struct Input&lt;'d, P&gt; { | ^^^^^ - help: add missing generic argument | 26 | async fn monitor_pin4(mut input: Input&lt;'static, P&gt;) { | +++ error[E0308]: mismatched types --&gt; src/main.rs:43:1 | 43 | #[main] | ^^^^^^^ | | | expected `Spawner`, found `embassy_executor::spawner::Spawner` | arguments to this function are incorrect | = note: `embassy_executor::spawner::Spawner` and `Spawner` have similar names, but are actually distinct types note: `embassy_executor::spawner::Spawner` is defined in crate `embassy_executor` --&gt; /home/okhsunrog/.cargo/registry/src/index.crates.io-6f17d22bba15001f/embassy-executor-0.5.0/src/spawner.rs:71:1 | 71 | pub struct Spawner { | ^^^^^^^^^^^^^^^^^^ note: `Spawner` is defined in crate `embassy_executor` --&gt; /home/okhsunrog/.cargo/registry/src/index.crates.io-6f17d22bba15001f/embassy-executor-0.6.0/src/spawner.rs:71:1 | 71 | pub struct Spawner { | ^^^^^^^^^^^^^^^^^^ = note: perhaps two different versions of crate `embassy_executor` are being used? note: function defined here --&gt; src/main.rs:43:1 | 43 | #[main] | ^^^^^^^ 44 | async fn main(spawner: Spawner) { | ---------------- = note: this error originates in the attribute macro `main` (in Nightly builds, run with -Z macro-backtrace for more info) error[E0308]: mismatched types --&gt; src/main.rs:43:1 | 43 | #[main] | ^^^^^^^ | | | expected `SpawnToken&lt;_&gt;`, found `SpawnToken&lt;impl Sized&gt;` | arguments to this method are incorrect | = note: `SpawnToken&lt;impl Sized&gt;` and `SpawnToken&lt;_&gt;` have similar names, but are actually distinct types note: `SpawnToken&lt;impl Sized&gt;` is defined in crate `embassy_executor` --&gt; /home/okhsunrog/.cargo/registry/src/index.crates.io-6f17d22bba15001f/embassy-executor-0.6.0/src/spawner.rs:23:1 | 23 | pub struct SpawnToken&lt;S&gt; { | ^^^^^^^^^^^^^^^^^^^^^^^^ note: `SpawnToken&lt;_&gt;` is defined in crate `embassy_executor` --&gt; /home/okhsunrog/.cargo/registry/src/index.crates.io-6f17d22bba15001f/embassy-executor-0.5.0/src/spawner.rs:23:1 | 23 | pub struct SpawnToken&lt;S&gt; { | ^^^^^^^^^^^^^^^^^^^^^^^^ = note: perhaps two different versions of crate `embassy_executor` are being used? note: method defined here --&gt; /home/okhsunrog/.cargo/registry/src/index.crates.io-6f17d22bba15001f/embassy-executor-0.5.0/src/spawner.rs:127:12 | 127 | pub fn must_spawn&lt;S&gt;(&amp;self, token: SpawnToken&lt;S&gt;) { | ^^^^^^^^^^ = note: this error originates in the attribute macro `main` (in Nightly builds, run with -Z macro-backtrace for more info) Some errors have detailed explanations: E0107, E0308. For more information about an error, try `rustc --explain E0107`. error: could not compile `esp_hal_probe` (bin &quot;esp_hal_probe&quot;) due to 3 previous errors " />
|
||||
</message>
|
||||
<message>
|
||||
<speaker value="ASSISTANT" />
|
||||
</message>
|
||||
<message>
|
||||
<speaker value="HUMAN" />
|
||||
<text value="help me fix this: error[E0107]: struct takes 1 generic argument but 0 generic arguments were supplied --&gt; src/main.rs:26:34 | 26 | async fn monitor_pin4(mut input: Input&lt;'static&gt;) { | ^^^^^ expected 1 generic argument | note: struct defined here, with 1 generic parameter: `P` --&gt; /home/okhsunrog/.cargo/registry/src/index.crates.io-6f17d22bba15001f/esp-hal-0.19.0/src/gpio/mod.rs:1673:12 | 1673 | pub struct Input&lt;'d, P&gt; { | ^^^^^ - help: add missing generic argument | 26 | async fn monitor_pin4(mut input: Input&lt;'static, P&gt;) { | +++ error[E0308]: mismatched types --&gt; src/main.rs:43:1 | 43 | #[main] | ^^^^^^^ | | | expected `Spawner`, found `embassy_executor::spawner::Spawner` | arguments to this function are incorrect | = note: `embassy_executor::spawner::Spawner` and `Spawner` have similar names, but are actually distinct types note: `embassy_executor::spawner::Spawner` is defined in crate `embassy_executor` --&gt; /home/okhsunrog/.cargo/registry/src/index.crates.io-6f17d22bba15001f/embassy-executor-0.5.0/src/spawner.rs:71:1 | 71 | pub struct Spawner { | ^^^^^^^^^^^^^^^^^^ note: `Spawner` is defined in crate `embassy_executor` --&gt; /home/okhsunrog/.cargo/registry/src/index.crates.io-6f17d22bba15001f/embassy-executor-0.6.0/src/spawner.rs:71:1 | 71 | pub struct Spawner { | ^^^^^^^^^^^^^^^^^^ = note: perhaps two different versions of crate `embassy_executor` are being used? note: function defined here --&gt; src/main.rs:43:1 | 43 | #[main] | ^^^^^^^ 44 | async fn main(spawner: Spawner) { | ---------------- = note: this error originates in the attribute macro `main` (in Nightly builds, run with -Z macro-backtrace for more info) error[E0308]: mismatched types --&gt; src/main.rs:43:1 | 43 | #[main] | ^^^^^^^ | | | expected `SpawnToken&lt;_&gt;`, found `SpawnToken&lt;impl Sized&gt;` | arguments to this method are incorrect | = note: `SpawnToken&lt;impl Sized&gt;` and `SpawnToken&lt;_&gt;` have similar names, but are actually distinct types note: `SpawnToken&lt;impl Sized&gt;` is defined in crate `embassy_executor` --&gt; /home/okhsunrog/.cargo/registry/src/index.crates.io-6f17d22bba15001f/embassy-executor-0.6.0/src/spawner.rs:23:1 | 23 | pub struct SpawnToken&lt;S&gt; { | ^^^^^^^^^^^^^^^^^^^^^^^^ note: `SpawnToken&lt;_&gt;` is defined in crate `embassy_executor` --&gt; /home/okhsunrog/.cargo/registry/src/index.crates.io-6f17d22bba15001f/embassy-executor-0.5.0/src/spawner.rs:23:1 | 23 | pub struct SpawnToken&lt;S&gt; { | ^^^^^^^^^^^^^^^^^^^^^^^^ = note: perhaps two different versions of crate `embassy_executor` are being used? note: method defined here --&gt; /home/okhsunrog/.cargo/registry/src/index.crates.io-6f17d22bba15001f/embassy-executor-0.5.0/src/spawner.rs:127:12 | 127 | pub fn must_spawn&lt;S&gt;(&amp;self, token: SpawnToken&lt;S&gt;) { | ^^^^^^^^^^ = note: this error originates in the attribute macro `main` (in Nightly builds, run with -Z macro-backtrace for more info) " />
|
||||
</message>
|
||||
<message>
|
||||
<speaker value="ASSISTANT" />
|
||||
</message>
|
||||
<message>
|
||||
<speaker value="HUMAN" />
|
||||
<text value="create one task, that takes these 2 input pins and uses select to wait for rising edge, then uses info! to print logs #![no_std] #![no_main] #![feature(type_alias_impl_trait)] use defmt::info; use defmt_rtt as _; use embassy_executor::Spawner; use embassy_time::{Duration, Timer}; use esp_backtrace as _; use esp_hal::{ clock::ClockControl, peripherals::Peripherals, prelude::*, rtc_cntl::Rtc, system::SystemControl, timer::{timg::TimerGroup, OneShotTimer}, }; use esp_hal::gpio::{GpioPin, Input, Io, Pull}; use static_cell::make_static; #[main] async fn main(spawner: Spawner) { let peripherals = Peripherals::take(); let system = SystemControl::new(peripherals.SYSTEM); let clocks = ClockControl::boot_defaults(system.clock_control).freeze(); // Enable the RWDT watchdog timer: let mut rtc = Rtc::new(peripherals.LPWR, None); rtc.rwdt.set_timeout(2.secs()); rtc.rwdt.enable(); info!(&quot;RWDT watchdog enabled!&quot;); // Initialize the SYSTIMER peripheral, and then Embassy: let timg0 = TimerGroup::new(peripherals.TIMG0, &amp;clocks, None); let timers = [OneShotTimer::new(timg0.timer0.into())]; let timers = make_static!(timers); let io = Io::new(peripherals.GPIO, peripherals.IO_MUX); let input4: Input&lt;GpioPin&lt;4&gt;&gt; = Input::new(io.pins.gpio4, Pull::Down); let input5: Input&lt;GpioPin&lt;5&gt;&gt; = Input::new(io.pins.gpio5, Pull::Down); esp_hal_embassy::init(&amp;clocks, timers); info!(&quot;Embassy initialized!&quot;); // TODO: Spawn some tasks let _ = spawner; // Periodically feed the RWDT watchdog timer when our tasks are not running: loop { rtc.rwdt.feed(); Timer::after(Duration::from_secs(1)).await; } } " />
|
||||
</message>
|
||||
<message>
|
||||
<speaker value="ASSISTANT" />
|
||||
</message>
|
||||
<message>
|
||||
<speaker value="HUMAN" />
|
||||
<text value="create one task, that takes these 2 input pins and uses select to wait for rising edge, then uses info! to print logs #![no_std] #![no_main] #![feature(type_alias_impl_trait)] use defmt::info; use defmt_rtt as _; use embassy_executor::Spawner; use embassy_time::{Duration, Timer}; use esp_backtrace as _; use esp_hal::{ clock::ClockControl, peripherals::Peripherals, prelude::*, rtc_cntl::Rtc, system::SystemControl, timer::{timg::TimerGroup, OneShotTimer}, }; use esp_hal::gpio::{GpioPin, Input, Io, Pull}; use static_cell::make_static; #[main] async fn main(spawner: Spawner) { let peripherals = Peripherals::take(); let system = SystemControl::new(peripherals.SYSTEM); let clocks = ClockControl::boot_defaults(system.clock_control).freeze(); // Enable the RWDT watchdog timer: let mut rtc = Rtc::new(peripherals.LPWR, None); rtc.rwdt.set_timeout(2.secs()); rtc.rwdt.enable(); info!(&quot;RWDT watchdog enabled!&quot;); // Initialize the SYSTIMER peripheral, and then Embassy: let timg0 = TimerGroup::new(peripherals.TIMG0, &amp;clocks, None); let timers = [OneShotTimer::new(timg0.timer0.into())]; let timers = make_static!(timers); let io = Io::new(peripherals.GPIO, peripherals.IO_MUX); let input4: Input&lt;GpioPin&lt;4&gt;&gt; = Input::new(io.pins.gpio4, Pull::Down); let input5: Input&lt;GpioPin&lt;5&gt;&gt; = Input::new(io.pins.gpio5, Pull::Down); esp_hal_embassy::init(&amp;clocks, timers); info!(&quot;Embassy initialized!&quot;); // TODO: Spawn some tasks let _ = spawner; // Periodically feed the RWDT watchdog timer when our tasks are not running: loop { rtc.rwdt.feed(); Timer::after(Duration::from_secs(1)).await; } } " />
|
||||
</message>
|
||||
<message>
|
||||
<speaker value="ASSISTANT" />
|
||||
</message>
|
||||
<message>
|
||||
<speaker value="HUMAN" />
|
||||
<text value="create one task, that takes these 2 input pins and uses select to wait for rising edge, then uses info! to print logs #![no_std] #![no_main] #![feature(type_alias_impl_trait)] use defmt::info; use defmt_rtt as _; use embassy_executor::Spawner; use embassy_time::{Duration, Timer}; use esp_backtrace as _; use esp_hal::{ clock::ClockControl, peripherals::Peripherals, prelude::*, rtc_cntl::Rtc, system::SystemControl, timer::{timg::TimerGroup, OneShotTimer}, }; use esp_hal::gpio::{GpioPin, Input, Io, Pull}; use static_cell::make_static; #[main] async fn main(spawner: Spawner) { let peripherals = Peripherals::take(); let system = SystemControl::new(peripherals.SYSTEM); let clocks = ClockControl::boot_defaults(system.clock_control).freeze(); // Enable the RWDT watchdog timer: let mut rtc = Rtc::new(peripherals.LPWR, None); rtc.rwdt.set_timeout(2.secs()); rtc.rwdt.enable(); info!(&quot;RWDT watchdog enabled!&quot;); // Initialize the SYSTIMER peripheral, and then Embassy: let timg0 = TimerGroup::new(peripherals.TIMG0, &amp;clocks, None); let timers = [OneShotTimer::new(timg0.timer0.into())]; let timers = make_static!(timers); let io = Io::new(peripherals.GPIO, peripherals.IO_MUX); let input4: Input&lt;GpioPin&lt;4&gt;&gt; = Input::new(io.pins.gpio4, Pull::Down); let input5: Input&lt;GpioPin&lt;5&gt;&gt; = Input::new(io.pins.gpio5, Pull::Down); esp_hal_embassy::init(&amp;clocks, timers); info!(&quot;Embassy initialized!&quot;); // TODO: Spawn some tasks let _ = spawner; // Periodically feed the RWDT watchdog timer when our tasks are not running: loop { rtc.rwdt.feed(); Timer::after(Duration::from_secs(1)).await; } } " />
|
||||
</message>
|
||||
<message>
|
||||
<speaker value="ASSISTANT" />
|
||||
</message>
|
||||
<message>
|
||||
<speaker value="HUMAN" />
|
||||
<text value="create one task, that takes these 2 input pins and uses select to wait for rising edge, then uses info! to print logs #![no_std] #![no_main] #![feature(type_alias_impl_trait)] use defmt::info; use defmt_rtt as _; use embassy_executor::Spawner; use embassy_time::{Duration, Timer}; use esp_backtrace as _; use esp_hal::{ clock::ClockControl, peripherals::Peripherals, prelude::*, rtc_cntl::Rtc, system::SystemControl, timer::{timg::TimerGroup, OneShotTimer}, }; use esp_hal::gpio::{GpioPin, Input, Io, Pull}; use static_cell::make_static; #[main] async fn main(spawner: Spawner) { let peripherals = Peripherals::take(); let system = SystemControl::new(peripherals.SYSTEM); let clocks = ClockControl::boot_defaults(system.clock_control).freeze(); // Enable the RWDT watchdog timer: let mut rtc = Rtc::new(peripherals.LPWR, None); rtc.rwdt.set_timeout(2.secs()); rtc.rwdt.enable(); info!(&quot;RWDT watchdog enabled!&quot;); // Initialize the SYSTIMER peripheral, and then Embassy: let timg0 = TimerGroup::new(peripherals.TIMG0, &amp;clocks, None); let timers = [OneShotTimer::new(timg0.timer0.into())]; let timers = make_static!(timers); let io = Io::new(peripherals.GPIO, peripherals.IO_MUX); let input4: Input&lt;GpioPin&lt;4&gt;&gt; = Input::new(io.pins.gpio4, Pull::Down); let input5: Input&lt;GpioPin&lt;5&gt;&gt; = Input::new(io.pins.gpio5, Pull::Down); esp_hal_embassy::init(&amp;clocks, timers); info!(&quot;Embassy initialized!&quot;); // TODO: Spawn some tasks let _ = spawner; // Periodically feed the RWDT watchdog timer when our tasks are not running: loop { rtc.rwdt.feed(); Timer::after(Duration::from_secs(1)).await; } } " />
|
||||
</message>
|
||||
<message>
|
||||
<speaker value="ASSISTANT" />
|
||||
<text value="Certainly! Here's how we can create a single task that monitors both input pins using `select` and prints logs using `info!`: ```rust use embassy_futures::select::{select, Either}; #[embassy_executor::task] async fn monitor_pins(mut input4: Input<'static, GpioPin<4>>, mut input5: Input<'static, GpioPin<5>>) { loop { match select(input4.wait_for_rising_edge(), input5.wait_for_rising_edge()).await { Either::First(_) => info!("Rising edge detected on Pin 4!"), Either::Second(_) => info!("Rising edge detected on Pin 5!"), } Timer::after(Duration::from_millis(100)).await; } } #[main] async fn main(spawner: Spawner) { // ... (previous code remains the same) let io = Io::new(peripherals.GPIO, peripherals.IO_MUX); let input4 = Input::new(io.pins.gpio4, Pull::Down); let input5 = Input::new(io.pins.gpio5, Pull::Down); spawner.spawn(monitor_pins(input4, input5)).unwrap(); // ... (rest of the code remains the same) } ``` This implementation creates a single task `monitor_pins` that takes both input pins as parameters. It uses `select` to wait for a rising edge on either pin, then prints the appropriate log message using `info!`. The task is spawned in the `main` function, passing both input pins as arguments." />
|
||||
</message>
|
||||
</list>
|
||||
</messages>
|
||||
<updatedAt value="2024-08-08T23:07:31.542436259" />
|
||||
</chat>
|
||||
</list>
|
||||
</chats>
|
||||
</AccountData>
|
||||
</list>
|
||||
</accountData>
|
||||
</component>
|
||||
</project>
|
||||
11
.idea/esp_hal_probe.iml
generated
Normal file
11
.idea/esp_hal_probe.iml
generated
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<module type="EMPTY_MODULE" version="4">
|
||||
<component name="NewModuleRootManager">
|
||||
<content url="file://$MODULE_DIR$">
|
||||
<sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
|
||||
<excludeFolder url="file://$MODULE_DIR$/target" />
|
||||
</content>
|
||||
<orderEntry type="inheritedJdk" />
|
||||
<orderEntry type="sourceFolder" forTests="false" />
|
||||
</component>
|
||||
</module>
|
||||
6
.idea/inspectionProfiles/Project_Default.xml
generated
Normal file
6
.idea/inspectionProfiles/Project_Default.xml
generated
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
<component name="InspectionProjectProfileManager">
|
||||
<profile version="1.0">
|
||||
<option name="myName" value="Project Default" />
|
||||
<inspection_tool class="RsUnusedImport" enabled="false" level="WARNING" enabled_by_default="false" />
|
||||
</profile>
|
||||
</component>
|
||||
8
.idea/modules.xml
generated
Normal file
8
.idea/modules.xml
generated
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="ProjectModuleManager">
|
||||
<modules>
|
||||
<module fileurl="file://$PROJECT_DIR$/.idea/esp_hal_probe.iml" filepath="$PROJECT_DIR$/.idea/esp_hal_probe.iml" />
|
||||
</modules>
|
||||
</component>
|
||||
</project>
|
||||
6
.idea/vcs.xml
generated
Normal file
6
.idea/vcs.xml
generated
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="VcsDirectoryMappings">
|
||||
<mapping directory="" vcs="Git" />
|
||||
</component>
|
||||
</project>
|
||||
1
Cargo.lock
generated
1
Cargo.lock
generated
|
|
@ -639,6 +639,7 @@ dependencies = [
|
|||
"defmt",
|
||||
"defmt-rtt",
|
||||
"embassy-executor",
|
||||
"embassy-futures",
|
||||
"embassy-time",
|
||||
"esp-backtrace",
|
||||
"esp-hal",
|
||||
|
|
|
|||
|
|
@ -9,6 +9,7 @@ defmt = "0.3.8"
|
|||
defmt-rtt = "0.4.1"
|
||||
embassy-executor = { version = "0.5.0", features = ["defmt"] }
|
||||
embassy-time = { version = "0.3.1", features = ["generic-queue-8"] }
|
||||
embassy-futures = "0.1.1"
|
||||
esp-backtrace = { version = "0.13.0", features = ["esp32c3", "defmt", "exception-handler", "panic-handler"] }
|
||||
esp-hal = { version = "0.19.0", features = ["esp32c3", "defmt", "async"] }
|
||||
esp-hal-embassy = { version = "0.2.0", features = ["esp32c3", "defmt"] }
|
||||
|
|
|
|||
23
src/main.rs
23
src/main.rs
|
|
@ -15,8 +15,22 @@ use esp_hal::{
|
|||
system::SystemControl,
|
||||
timer::{timg::TimerGroup, OneShotTimer},
|
||||
};
|
||||
use esp_hal::gpio::{GpioPin, Input, Io, Pull};
|
||||
use static_cell::make_static;
|
||||
|
||||
use embassy_futures::select::{select, Either};
|
||||
|
||||
#[embassy_executor::task]
|
||||
async fn monitor_pins(mut input4: Input<'static, GpioPin<4>>, mut input5: Input<'static, GpioPin<5>>) {
|
||||
loop {
|
||||
match select(input4.wait_for_rising_edge(), input5.wait_for_rising_edge()).await {
|
||||
Either::First(_) => info!("Rising edge detected on Pin 4!"),
|
||||
Either::Second(_) => info!("Rising edge detected on Pin 5!"),
|
||||
}
|
||||
Timer::after(Duration::from_millis(100)).await;
|
||||
}
|
||||
}
|
||||
|
||||
#[main]
|
||||
async fn main(spawner: Spawner) {
|
||||
let peripherals = Peripherals::take();
|
||||
|
|
@ -33,11 +47,14 @@ async fn main(spawner: Spawner) {
|
|||
let timg0 = TimerGroup::new(peripherals.TIMG0, &clocks, None);
|
||||
let timers = [OneShotTimer::new(timg0.timer0.into())];
|
||||
let timers = make_static!(timers);
|
||||
|
||||
let io = Io::new(peripherals.GPIO, peripherals.IO_MUX);
|
||||
let input4: Input<GpioPin<4>> = Input::new(io.pins.gpio4, Pull::Down);
|
||||
let input5: Input<GpioPin<5>> = Input::new(io.pins.gpio5, Pull::Down);
|
||||
esp_hal_embassy::init(&clocks, timers);
|
||||
info!("Embassy initialized!");
|
||||
|
||||
// TODO: Spawn some tasks
|
||||
let _ = spawner;
|
||||
|
||||
spawner.spawn(monitor_pins(input4, input5)).unwrap();
|
||||
|
||||
// Periodically feed the RWDT watchdog timer when our tasks are not running:
|
||||
loop {
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue