tests: drivers: gpio-async: Test the async gpio operations

This is a basic test to test for the waiting gpios.  Currently, this
test requires a specific hardware setup.  To test on the rpi-pico, it is
necessary to connect GPIO-0 to GPIO-6 with a button or switch.
Running should then print Pressed/Released on a debounced version of
that switch, with the code not polling the gpio while waiting.

Signed-off-by: David Brown <[email protected]>

Author: d3zd3z

tests/drivers/gpio-async/CMakeLists.txt

@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: Apache-2.0
+
+cmake_minimum_required(VERSION 3.20.0)
+
+find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
+
+project(gpio_async)
+rust_cargo_application()

tests/drivers/gpio-async/Cargo.toml

@@ -0,0 +1,45 @@
+# Copyright (c) 2024 Linaro LTD
+# SPDX-License-Identifier: Apache-2.0
+
+[package]
+# This must be rustapp for now.
+name = "rustapp"
+version = "0.1.0"
+edition = "2021"
+description = "Test async gpios"
+license = "Apache-2.0 or MIT"
+
+[lib]
+crate-type = ["staticlib"]
+
+[dependencies]
+zephyr = { version = "0.1.0", features = ["time-driver", "executor-zephyr", "async-drivers"] }
+log = "0.4.22"
+static_cell = "2.1"
+heapless = "0.8"
+
+[dependencies.embassy-executor]
+version = "0.7.0"
+features = [
+  "log",
+  "task-arena-size-2048",
+]
+
+[dependencies.embassy-futures]
+version = "0.1.1"
+
+[dependencies.embassy-sync]
+version = "0.6.2"
+
+[dependencies.embassy-time]
+version = "0.4.0"
+features = ["tick-hz-10_000"]
+
+[dependencies.critical-section]
+version = "1.2"
+
+[profile.dev]
+opt-level = 1
+
+[profile.release]
+debug = true

tests/drivers/gpio-async/boards/pimoroni_tiny_2040.overlay

@@ -0,0 +1,13 @@
+/ {
+	gpio-leds {
+		compatible = "gpio-leds";
+		col0: col0 {
+			gpios = <&gpio0 6 GPIO_ACTIVE_HIGH>;
+			label = "Column 0";
+		};
+		row0: row0 {
+			gpios = <&gpio0 0 (GPIO_PULL_DOWN | GPIO_ACTIVE_HIGH)>;
+			label = "Row 0";
+		};
+	};
+};

tests/drivers/gpio-async/boards/rpi_pico.overlay

@@ -0,0 +1,13 @@
+/ {
+	gpio-leds {
+		compatible = "gpio-leds";
+		col0: col0 {
+			gpios = <&gpio0 6 GPIO_ACTIVE_HIGH>;
+			label = "Column 0";
+		};
+		row0: row0 {
+			gpios = <&gpio0 0 (GPIO_PULL_DOWN | GPIO_ACTIVE_HIGH)>;
+			label = "Row 0";
+		};
+	};
+};

tests/drivers/gpio-async/pimoroni_tiny_2040.conf

@@ -0,0 +1,7 @@
+# Copyright (c) 2024 Linaro LTD
+# SPDX-License-Identifier: Apache-2.0
+
+# This board doesn't have a serial console, so use RTT.
+CONFIG_UART_CONSOLE=n
+CONFIG_RTT_CONSOLE=y
+CONFIG_USE_SEGGER_RTT=y

tests/drivers/gpio-async/prj.conf

@@ -0,0 +1,16 @@
+# Copyright (c) 2024 Linaro LTD
+# SPDX-License-Identifier: Apache-2.0
+
+CONFIG_DEBUG=y
+
+# The default 1k stack isn't large enough for rust string formatting with logging.
+CONFIG_MAIN_STACK_SIZE=4096
+
+CONFIG_RUST=y
+
+CONFIG_RUST_ALLOC=y
+# CONFIG_LOG=y
+CONFIG_GPIO=y
+CONFIG_GPIO_ENABLE_DISABLE_INTERRUPT=y
+
+CONFIG_LOG_BACKEND_RTT=n

tests/drivers/gpio-async/rpi_pico.conf

@@ -0,0 +1,7 @@
+# Copyright (c) 2024 Linaro LTD
+# SPDX-License-Identifier: Apache-2.0
+
+# This board doesn't have a serial console, so use RTT.
+CONFIG_UART_CONSOLE=n
+CONFIG_RTT_CONSOLE=y
+CONFIG_USE_SEGGER_RTT=y

tests/drivers/gpio-async/src/lib.rs

@@ -0,0 +1,77 @@
+// Copyright (c) 2024 Linaro LTD
+// SPDX-License-Identifier: Apache-2.0
+
+#![no_std]
+
+extern crate alloc;
+
+use embassy_time::{Duration, Ticker};
+use zephyr::{
+    device::gpio::{GpioPin, GpioToken},
+    embassy::Executor,
+    raw::{GPIO_INPUT, GPIO_OUTPUT_ACTIVE, GPIO_PULL_DOWN},
+};
+
+use embassy_executor::Spawner;
+use log::info;
+use static_cell::StaticCell;
+
+static EXECUTOR_MAIN: StaticCell<Executor> = StaticCell::new();
+
+#[no_mangle]
+extern "C" fn rust_main() {
+    unsafe {
+        zephyr::set_logger().unwrap();
+    }
+
+    let executor = EXECUTOR_MAIN.init(Executor::new());
+    executor.run(|spawner| {
+        spawner.spawn(main(spawner)).unwrap();
+    })
+}
+
+#[embassy_executor::task]
+async fn main(spawner: Spawner) {
+    info!("Hello world");
+    let _ = spawner;
+
+    let mut col0 = zephyr::devicetree::labels::col0::get_instance().unwrap();
+    let mut row0 = zephyr::devicetree::labels::row0::get_instance().unwrap();
+    let mut gpio_token = unsafe { zephyr::device::gpio::GpioToken::get_instance().unwrap() };
+
+    unsafe {
+        col0.configure(&mut gpio_token, GPIO_OUTPUT_ACTIVE);
+        col0.set(&mut gpio_token, true);
+        row0.configure(&mut gpio_token, GPIO_INPUT | GPIO_PULL_DOWN);
+    }
+
+    loop {
+        unsafe { row0.wait_for_high(&mut gpio_token).await };
+        // Simple debounce, Wait for 20 consecutive high samples.
+        debounce(&mut row0, &mut gpio_token, true).await;
+        info!("Pressed");
+        unsafe { row0.wait_for_low(&mut gpio_token).await };
+        debounce(&mut row0, &mut gpio_token, false).await;
+        info!("Released");
+    }
+}
+
+/// Simple debounce.  Scan the gpio periodically, and return when we have 20 consecutive samples of
+/// the intended value.
+async fn debounce(pin: &mut GpioPin, gpio_token: &mut GpioToken, level: bool) {
+    let mut count = 0;
+    let mut ticker = Ticker::every(Duration::from_millis(1));
+    loop {
+        ticker.next().await;
+
+        if unsafe { pin.get(gpio_token) } == level {
+            count += 1;
+
+            if count >= 20 {
+                return;
+            }
+        } else {
+            count = 0;
+        }
+    }
+}

tests/drivers/gpio-async/testcase.yaml

@@ -0,0 +1,13 @@
+common:
+  filter: CONFIG_RUST_SUPPORTED
+  platform_allow:
+    - rpi_pico
+tests:
+  test.gpio-async:
+    harness: console
+    harness_config:
+      type: one_line
+      regex:
+        # This doesn't actually happen, as this test requires specific hardware and buttons to be
+        # pressed.
+        - "All tests passed"