Merge pull request #3274 from michelrandahl/discriminating-pins-within-tsc-group

STM32-TSC: enable discriminating between pins within same TSC group and improve TSC library in general

19 files changed, 1371 insertions, 383 deletions

diff --git a/examples/stm32f3/README.md b/examples/stm32f3/README.md
new file mode 100644
index 000000000..0a85c4858
--- /dev/null
+++ b/examples/stm32f3/README.md
@@ -0,0 +1,24 @@
+# Examples for STM32F3 family
+Run individual examples with
+```
+cargo run --bin <module-name>
+```
+for example
+```
+cargo run --bin blinky
+```
+
+## Checklist before running examples
+You might need to adjust `.cargo/config.toml`, `Cargo.toml` and possibly update pin numbers or peripherals to match the specific MCU or board you are using.
+
+* [ ] Update .cargo/config.toml with the correct probe-rs command to use your specific MCU. For example for F303ZE it should be `probe-rs run --chip STM32F303ZETx`. (use `probe-rs chip list` to find your chip)
+* [ ] Update Cargo.toml to have the correct `embassy-stm32` feature. For example for F303ZE it should be `stm32f303ze`. Look in the `Cargo.toml` file of the `embassy-stm32` project to find the correct feature flag for your chip.
+* [ ] If your board has a special clock or power configuration, make sure that it is set up appropriately.
+* [ ] If your board has different pin mapping, update any pin numbers or peripherals in the given example code to match your schematic
+
+If you are unsure, please drop by the Embassy Matrix chat for support, and let us know:
+
+* Which example you are trying to run
+* Which chip and board you are using
+
+Embassy Chat: https://matrix.to/#/#embassy-rs:matrix.org
diff --git a/examples/stm32f3/src/bin/blocking-tsc.rs b/examples/stm32f3/src/bin/blocking-tsc.rs
deleted file mode 100644
index 5c8dac94f..000000000
--- a/examples/stm32f3/src/bin/blocking-tsc.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-// Example of polling TSC (Touch Sensing Controller) that lights an LED when touch is detected.
-//
-// Suggested physical setup on STM32F303ZE Nucleo board:
-// - Connect a 1000pF capacitor between pin A0 and GND. This is your sampling capacitor.
-// - Connect one end of a 1K resistor to pin A1 and leave the other end loose.
-//   The loose end will act as touch sensor which will register your touch.
-//
-// Troubleshooting the setup:
-// - If no touch seems to be registered, then try to disconnect the sampling capacitor from GND momentarily,
-//   now the led should light up. Next try using a different value for the sampling capacitor.
-//   Also experiment with increasing the values for `ct_pulse_high_length`, `ct_pulse_low_length`, `pulse_generator_prescaler`, `max_count_value` and `discharge_delay`.
-//
-// All configuration values and sampling capacitor value have been determined experimentally.
-// Suitable configuration and discharge delay values are highly dependent on the value of the sample capacitor. For example, a shorter discharge delay can be used with smaller capacitor values.
-//
-#![no_std]
-#![no_main]
-
-use defmt::*;
-use embassy_stm32::gpio::{Level, Output, Speed};
-use embassy_stm32::tsc::{self, *};
-use embassy_time::Timer;
-use {defmt_rtt as _, panic_probe as _};
-
-/// This example is written for the nucleo-stm32f303ze, with a stm32f303ze chip.
-///
-/// Make sure you check/update the following (whether you use the F303ZE or another board):
-///
-/// * [ ] Update .cargo/config.toml with the correct `probe-rs run --chip STM32F303ZETx`chip name.
-/// * [ ] Update Cargo.toml to have the correct `embassy-stm32` feature, for F303ZE it should be `stm32f303ze`.
-/// * [ ] If your board has a special clock or power configuration, make sure that it is
-///       set up appropriately.
-/// * [ ] If your board has different pin mapping, update any pin numbers or peripherals
-///       to match your schematic
-///
-/// If you are unsure, please drop by the Embassy Matrix chat for support, and let us know:
-///
-/// * Which example you are trying to run
-/// * Which chip and board you are using
-///
-/// Embassy Chat: https://matrix.to/#/#embassy-rs:matrix.org
-#[embassy_executor::main]
-async fn main(_spawner: embassy_executor::Spawner) {
-    let device_config = embassy_stm32::Config::default();
-    let context = embassy_stm32::init(device_config);
-
-    let tsc_conf = Config {
-        ct_pulse_high_length: ChargeTransferPulseCycle::_8,
-        ct_pulse_low_length: ChargeTransferPulseCycle::_8,
-        spread_spectrum: false,
-        spread_spectrum_deviation: SSDeviation::new(2).unwrap(),
-        spread_spectrum_prescaler: false,
-        pulse_generator_prescaler: PGPrescalerDivider::_32,
-        max_count_value: MaxCount::_255,
-        io_default_mode: false,
-        synchro_pin_polarity: false,
-        acquisition_mode: false,
-        max_count_interrupt: false,
-        channel_ios: TscIOPin::Group1Io1.into(),
-        shield_ios: 0, // no shield
-        sampling_ios: TscIOPin::Group1Io2.into(),
-    };
-
-    let mut g1: PinGroup<embassy_stm32::peripherals::TSC, G1> = PinGroup::new();
-    g1.set_io1(context.PA0, PinType::Sample);
-    g1.set_io2(context.PA1, PinType::Channel);
-
-    let mut touch_controller = tsc::Tsc::new_blocking(context.TSC, Some(g1), None, None, None, None, None, tsc_conf);
-
-    // LED2 on the STM32F303ZE nucleo-board
-    let mut led = Output::new(context.PB7, Level::High, Speed::Low);
-
-    // smaller sample capacitor discharge faster and can be used with shorter delay.
-    let discharge_delay = 5; // ms
-
-    // the interval at which the loop polls for new touch sensor values
-    let polling_interval = 100; // ms
-
-    info!("polling for touch");
-    loop {
-        touch_controller.start();
-        touch_controller.poll_for_acquisition();
-        touch_controller.discharge_io(true);
-        Timer::after_millis(discharge_delay).await;
-
-        let grp1_status = touch_controller.group_get_status(Group::One);
-        match grp1_status {
-            GroupStatus::Complete => {
-                let group_one_val = touch_controller.group_get_value(Group::One);
-                info!("{}", group_one_val);
-                led.set_high();
-            }
-            GroupStatus::Ongoing => led.set_low(),
-        }
-
-        Timer::after_millis(polling_interval).await;
-    }
-}
diff --git a/examples/stm32f3/src/bin/tsc_blocking.rs b/examples/stm32f3/src/bin/tsc_blocking.rs
new file mode 100644
index 000000000..2c33838e5
--- /dev/null
+++ b/examples/stm32f3/src/bin/tsc_blocking.rs
@@ -0,0 +1,138 @@
+// Example of blocking TSC (Touch Sensing Controller) that lights an LED when touch is detected.
+//
+// This example demonstrates:
+// 1. Configuring a single TSC channel pin
+// 2. Using the blocking TSC interface with polling
+// 3. Waiting for acquisition completion using `poll_for_acquisition`
+// 4. Reading touch values and controlling an LED based on the results
+//
+// Suggested physical setup on STM32F303ZE Nucleo board:
+// - Connect a 1000pF capacitor between pin PA10 and GND. This is your sampling capacitor.
+// - Connect one end of a 1K resistor to pin PA9 and leave the other end loose.
+//   The loose end will act as the touch sensor which will register your touch.
+//
+// The example uses two pins from Group 4 of the TSC:
+// - PA10 as the sampling capacitor, TSC group 4 IO2 (D68 on the STM32F303ZE nucleo-board)
+// - PA9 as the channel pin, TSC group 4 IO1 (D69 on the STM32F303ZE nucleo-board)
+//
+// The program continuously reads the touch sensor value:
+// - It starts acquisition, waits for completion using `poll_for_acquisition`, and reads the value.
+// - The LED is turned on when touch is detected (sensor value < 40).
+// - Touch values are logged to the console.
+//
+// Troubleshooting:
+// - If touch is not detected, try adjusting the SENSOR_THRESHOLD value.
+// - Experiment with different values for ct_pulse_high_length, ct_pulse_low_length,
+//   pulse_generator_prescaler, max_count_value, and discharge_delay to optimize sensitivity.
+//
+// Note: Configuration values and sampling capacitor value have been determined experimentally.
+// Optimal values may vary based on your specific hardware setup.
+// Pins have been chosen for their convenient locations on the STM32F303ZE board. Refer to the
+// official relevant STM32 datasheets and user nucleo-board user manuals to find suitable
+// alternative pins.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_stm32::gpio::{Level, Output, Speed};
+use embassy_stm32::tsc::{self, *};
+use embassy_stm32::{mode, peripherals};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+const SENSOR_THRESHOLD: u16 = 25; // Adjust this value based on your setup
+
+#[embassy_executor::main]
+async fn main(_spawner: embassy_executor::Spawner) {
+    let device_config = embassy_stm32::Config::default();
+    let context = embassy_stm32::init(device_config);
+
+    let tsc_conf = Config {
+        ct_pulse_high_length: ChargeTransferPulseCycle::_4,
+        ct_pulse_low_length: ChargeTransferPulseCycle::_4,
+        spread_spectrum: false,
+        spread_spectrum_deviation: SSDeviation::new(2).unwrap(),
+        spread_spectrum_prescaler: false,
+        pulse_generator_prescaler: PGPrescalerDivider::_16,
+        max_count_value: MaxCount::_255,
+        io_default_mode: false,
+        synchro_pin_polarity: false,
+        acquisition_mode: false,
+        max_count_interrupt: false,
+    };
+
+    let mut g: PinGroupWithRoles<peripherals::TSC, G4> = PinGroupWithRoles::default();
+    // D68 on the STM32F303ZE nucleo-board
+    g.set_io2::<tsc::pin_roles::Sample>(context.PA10);
+    // D69 on the STM32F303ZE nucleo-board
+    let tsc_sensor = g.set_io1::<tsc::pin_roles::Channel>(context.PA9);
+
+    let pin_groups: PinGroups<peripherals::TSC> = PinGroups {
+        g4: Some(g.pin_group),
+        ..Default::default()
+    };
+
+    let mut touch_controller = tsc::Tsc::new_blocking(context.TSC, pin_groups, tsc_conf).unwrap();
+
+    // Check if TSC is ready
+    if touch_controller.get_state() != State::Ready {
+        crate::panic!("TSC not ready!");
+    }
+    info!("TSC initialized successfully");
+
+    // LED2 on the STM32F303ZE nucleo-board
+    let mut led = Output::new(context.PB7, Level::High, Speed::Low);
+
+    // smaller sample capacitor discharge faster and can be used with shorter delay.
+    let discharge_delay = 5; // ms
+
+    // the interval at which the loop polls for new touch sensor values
+    let polling_interval = 100; // ms
+
+    info!("polling for touch");
+    loop {
+        touch_controller.set_active_channels_mask(tsc_sensor.pin.into());
+        touch_controller.start();
+        touch_controller.poll_for_acquisition();
+        touch_controller.discharge_io(true);
+        Timer::after_millis(discharge_delay).await;
+
+        match read_touch_value(&mut touch_controller, tsc_sensor.pin).await {
+            Some(v) => {
+                info!("sensor value {}", v);
+                if v < SENSOR_THRESHOLD {
+                    led.set_high();
+                } else {
+                    led.set_low();
+                }
+            }
+            None => led.set_low(),
+        }
+
+        Timer::after_millis(polling_interval).await;
+    }
+}
+
+const MAX_GROUP_STATUS_READ_ATTEMPTS: usize = 10;
+
+// attempt to read group status and delay when still ongoing
+async fn read_touch_value(
+    touch_controller: &mut tsc::Tsc<'_, peripherals::TSC, mode::Blocking>,
+    sensor_pin: tsc::IOPin,
+) -> Option<u16> {
+    for _ in 0..MAX_GROUP_STATUS_READ_ATTEMPTS {
+        match touch_controller.group_get_status(sensor_pin.group()) {
+            GroupStatus::Complete => {
+                return Some(touch_controller.group_get_value(sensor_pin.group()));
+            }
+            GroupStatus::Ongoing => {
+                // if you end up here a lot, then you prob need to increase discharge_delay
+                // or consider changing the code to adjust the discharge_delay dynamically
+                info!("Acquisition still ongoing");
+                Timer::after_millis(1).await;
+            }
+        }
+    }
+    None
+}
diff --git a/examples/stm32f3/src/bin/tsc_multipin.rs b/examples/stm32f3/src/bin/tsc_multipin.rs
new file mode 100644
index 000000000..c524c3760
--- /dev/null
+++ b/examples/stm32f3/src/bin/tsc_multipin.rs
@@ -0,0 +1,204 @@
+// Example of TSC (Touch Sensing Controller) using multiple pins from the same tsc-group.
+//
+// What is special about using multiple TSC pins as sensor channels from the same TSC group,
+// is that only one TSC pin for each TSC group can be acquired and read at the time.
+// To control which channel pins are acquired and read, we must write a mask before initiating an
+// acquisition. To help manage and abstract all this business away, we can organize our channel
+// pins into acquisition banks. Each acquisition bank can contain exactly one channel pin per TSC
+// group and it will contain the relevant mask.
+//
+// This example demonstrates how to:
+// 1. Configure multiple channel pins within a single TSC group
+// 2. Use the set_active_channels_bank method to switch between sets of different channels (acquisition banks)
+// 3. Read and interpret touch values from multiple channels in the same group
+//
+// Suggested physical setup on STM32F303ZE Nucleo board:
+// - Connect a 1000pF capacitor between pin PA10 and GND. This is the sampling capacitor for TSC
+//   group 4.
+// - Connect one end of a 1K resistor to pin PA9 and leave the other end loose.
+//   The loose end will act as a touch sensor.
+//
+// - Connect a 1000pF capacitor between pin PA7 and GND. This is the sampling capacitor for TSC
+//   group 2.
+// - Connect one end of another 1K resistor to pin PA6 and leave the other end loose.
+//   The loose end will act as a touch sensor.
+// - Connect one end of another 1K resistor to pin PA5 and leave the other end loose.
+//   The loose end will act as a touch sensor.
+//
+// The example uses pins from two TSC groups.
+// - PA10 as sampling capacitor, TSC group 4 IO2
+// - PA9 as channel, TSC group 4 IO1
+// - PA7 as sampling capacitor, TSC group 2 IO4
+// - PA6 as channel, TSC group 2 IO3
+// - PA5 as channel, TSC group 2 IO2
+//
+// The pins have been chosen to make it easy to simply add capacitors directly onto the board and
+// connect one leg to GND, and to easily add resistors to the board with no special connectors,
+// breadboards, special wires or soldering required. All you need is the capacitors and resistors.
+//
+// The program reads the designated channel pins and adjusts the LED blinking
+// pattern based on which sensor(s) are touched:
+// - No touch: LED off
+// - one sensor touched: Slow blinking
+// - two sensors touched: Fast blinking
+// - three sensors touched: LED constantly on
+//
+// ## Troubleshooting:
+//
+// - If touch is not detected, try adjusting the SENSOR_THRESHOLD value (currently set to 20).
+// - Experiment with different values for ct_pulse_high_length, ct_pulse_low_length, pulse_generator_prescaler, max_count_value, and discharge_delay to optimize sensitivity.
+// - Be aware that for some boards there will be overlapping concerns between some pins, for
+//  example UART connection for the programmer to the MCU and a TSC pin. No errors or warning will
+//  be emitted if you try to use such a pin for TSC, but you will get strange sensor readings.
+//
+// Note: Configuration values and sampling capacitor values have been determined experimentally. Optimal values may vary based on your specific hardware setup. Refer to the official STM32 datasheet and user manuals for more information on pin configurations and TSC functionality.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_stm32::gpio::{Level, Output, Speed};
+use embassy_stm32::tsc::{self, *};
+use embassy_stm32::{mode, peripherals};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+const SENSOR_THRESHOLD: u16 = 10;
+
+async fn acquire_sensors(
+    touch_controller: &mut Tsc<'static, peripherals::TSC, mode::Blocking>,
+    tsc_acquisition_bank: &AcquisitionBank,
+) {
+    touch_controller.set_active_channels_bank(tsc_acquisition_bank);
+    touch_controller.start();
+    touch_controller.poll_for_acquisition();
+    touch_controller.discharge_io(true);
+    let discharge_delay = 5; // ms
+    Timer::after_millis(discharge_delay).await;
+}
+
+#[embassy_executor::main]
+async fn main(_spawner: embassy_executor::Spawner) {
+    let device_config = embassy_stm32::Config::default();
+    let context = embassy_stm32::init(device_config);
+
+    // ---------- initial configuration of TSC ----------
+    //
+    let mut pin_group4: PinGroupWithRoles<peripherals::TSC, G4> = PinGroupWithRoles::default();
+    // D68 on the STM32F303ZE nucleo-board
+    pin_group4.set_io2::<tsc::pin_roles::Sample>(context.PA10);
+    // D69 on the STM32F303ZE nucleo-board
+    let tsc_sensor0 = pin_group4.set_io1(context.PA9);
+
+    let mut pin_group2: PinGroupWithRoles<peripherals::TSC, G2> = PinGroupWithRoles::default();
+    // D11 on the STM32F303ZE nucleo-board
+    pin_group2.set_io4::<tsc::pin_roles::Sample>(context.PA7);
+    // D12 on the STM32F303ZE nucleo-board
+    let tsc_sensor1 = pin_group2.set_io3(context.PA6);
+    // D13 on the STM32F303ZE nucleo-board
+    let tsc_sensor2 = pin_group2.set_io2(context.PA5);
+
+    let config = Config {
+        ct_pulse_high_length: ChargeTransferPulseCycle::_4,
+        ct_pulse_low_length: ChargeTransferPulseCycle::_4,
+        spread_spectrum: false,
+        spread_spectrum_deviation: SSDeviation::new(2).unwrap(),
+        spread_spectrum_prescaler: false,
+        pulse_generator_prescaler: PGPrescalerDivider::_16,
+        max_count_value: MaxCount::_255,
+        io_default_mode: false,
+        synchro_pin_polarity: false,
+        acquisition_mode: false,
+        max_count_interrupt: false,
+    };
+
+    let pin_groups: PinGroups<peripherals::TSC> = PinGroups {
+        g4: Some(pin_group4.pin_group),
+        g2: Some(pin_group2.pin_group),
+        ..Default::default()
+    };
+
+    let mut touch_controller = tsc::Tsc::new_blocking(context.TSC, pin_groups, config).unwrap();
+
+    // ---------- setting up acquisition banks ----------
+    // sensor0 and sensor1 in this example belong to different TSC-groups,
+    // therefore we can acquire and read them both in one go.
+    let bank1 = touch_controller.create_acquisition_bank(AcquisitionBankPins {
+        g4_pin: Some(tsc_sensor0),
+        g2_pin: Some(tsc_sensor1),
+        ..Default::default()
+    });
+    // `sensor1` and `sensor2` belongs to the same TSC-group, therefore we must make sure to
+    // acquire them one at the time. Therefore, we organize them into different acquisition banks.
+    let bank2 = touch_controller.create_acquisition_bank(AcquisitionBankPins {
+        g2_pin: Some(tsc_sensor2),
+        ..Default::default()
+    });
+
+    // Check if TSC is ready
+    if touch_controller.get_state() != State::Ready {
+        crate::panic!("TSC not ready!");
+    }
+
+    info!("TSC initialized successfully");
+
+    // LED2 on the STM32F303ZE nucleo-board
+    let mut led = Output::new(context.PB7, Level::High, Speed::Low);
+
+    let mut led_state = false;
+
+    loop {
+        acquire_sensors(&mut touch_controller, &bank1).await;
+        let readings1 = touch_controller.get_acquisition_bank_values(&bank1);
+        acquire_sensors(&mut touch_controller, &bank2).await;
+        let readings2 = touch_controller.get_acquisition_bank_values(&bank2);
+
+        let mut touched_sensors_count = 0;
+        for reading in readings1.iter() {
+            info!("{}", reading);
+            if reading.sensor_value < SENSOR_THRESHOLD {
+                touched_sensors_count += 1;
+            }
+        }
+        for reading in readings2.iter() {
+            info!("{}", reading);
+            if reading.sensor_value < SENSOR_THRESHOLD {
+                touched_sensors_count += 1;
+            }
+        }
+
+        match touched_sensors_count {
+            0 => {
+                // No sensors touched, turn off the LED
+                led.set_low();
+                led_state = false;
+            }
+            1 => {
+                // One sensor touched, blink slowly
+                led_state = !led_state;
+                if led_state {
+                    led.set_high();
+                } else {
+                    led.set_low();
+                }
+                Timer::after_millis(200).await;
+            }
+            2 => {
+                // Two sensors touched, blink faster
+                led_state = !led_state;
+                if led_state {
+                    led.set_high();
+                } else {
+                    led.set_low();
+                }
+                Timer::after_millis(50).await;
+            }
+            3 => {
+                // All three sensors touched, LED constantly on
+                led.set_high();
+                led_state = true;
+            }
+            _ => crate::unreachable!(), // This case should never occur with 3 sensors
+        }
+    }
+}
diff --git a/examples/stm32l0/.cargo/config.toml b/examples/stm32l0/.cargo/config.toml
index b050334b2..fed9cf9ce 100644
--- a/examples/stm32l0/.cargo/config.toml
+++ b/examples/stm32l0/.cargo/config.toml
@@ -1,6 +1,6 @@
 [target.'cfg(all(target_arch = "arm", target_os = "none"))']
 # replace your chip as listed in `probe-rs chip list`
-runner = "probe-rs run --chip STM32L053R8Tx"
+runner = "probe-rs run --chip STM32L073RZTx"
 
 [build]
 target = "thumbv6m-none-eabi"
diff --git a/examples/stm32l0/Cargo.toml b/examples/stm32l0/Cargo.toml
index 95e215b6f..9d234804a 100644
--- a/examples/stm32l0/Cargo.toml
+++ b/examples/stm32l0/Cargo.toml
@@ -6,7 +6,7 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 # Change stm32l072cz to your chip name, if necessary.
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["defmt", "stm32l072cz", "unstable-pac", "time-driver-any", "exti", "memory-x"]  }
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["defmt", "stm32l073rz", "unstable-pac", "time-driver-any", "exti", "memory-x"]  }
 embassy-sync = { version = "0.6.1", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.6.3", path = "../../embassy-executor", features = ["arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.3.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
diff --git a/examples/stm32l0/README.md b/examples/stm32l0/README.md
new file mode 100644
index 000000000..82d222027
--- /dev/null
+++ b/examples/stm32l0/README.md
@@ -0,0 +1,24 @@
+# Examples for STM32L0 family
+Run individual examples with
+```
+cargo run --bin <module-name>
+```
+for example
+```
+cargo run --bin blinky
+```
+
+## Checklist before running examples
+You might need to adjust `.cargo/config.toml`, `Cargo.toml` and possibly update pin numbers or peripherals to match the specific MCU or board you are using.
+
+* [ ] Update .cargo/config.toml with the correct probe-rs command to use your specific MCU. For example for L073RZ it should be `probe-rs run --chip STM32L073RZTx`. (use `probe-rs chip list` to find your chip)
+* [ ] Update Cargo.toml to have the correct `embassy-stm32` feature. For example for L073RZ it should be `stm32l073rz`. Look in the `Cargo.toml` file of the `embassy-stm32` project to find the correct feature flag for your chip.
+* [ ] If your board has a special clock or power configuration, make sure that it is set up appropriately.
+* [ ] If your board has different pin mapping, update any pin numbers or peripherals in the given example code to match your schematic
+
+If you are unsure, please drop by the Embassy Matrix chat for support, and let us know:
+
+* Which example you are trying to run
+* Which chip and board you are using
+
+Embassy Chat: https://matrix.to/#/#embassy-rs:matrix.org
diff --git a/examples/stm32l0/src/bin/async-tsc.rs b/examples/stm32l0/src/bin/async-tsc.rs
deleted file mode 100644
index c40b86af9..000000000
--- a/examples/stm32l0/src/bin/async-tsc.rs
+++ /dev/null
@@ -1,122 +0,0 @@
-// Example of async TSC (Touch Sensing Controller) that lights an LED when touch is detected.
-//
-// Suggested physical setup on STM32L073RZ Nucleo board:
-// - Connect a 1000pF capacitor between pin A0 and GND. This is your sampling capacitor.
-// - Connect one end of a 1K resistor to pin A1 and leave the other end loose.
-//   The loose end will act as touch sensor which will register your touch.
-//
-// Troubleshooting the setup:
-// - If no touch seems to be registered, then try to disconnect the sampling capacitor from GND momentarily,
-//   now the led should light up. Next try using a different value for the sampling capacitor.
-//   Also experiment with increasing the values for `ct_pulse_high_length`, `ct_pulse_low_length`, `pulse_generator_prescaler`, `max_count_value` and `discharge_delay`.
-//
-// All configuration values and sampling capacitor value have been determined experimentally.
-// Suitable configuration and discharge delay values are highly dependent on the value of the sample capacitor. For example, a shorter discharge delay can be used with smaller capacitor values.
-//
-#![no_std]
-#![no_main]
-
-use defmt::*;
-use embassy_stm32::bind_interrupts;
-use embassy_stm32::gpio::{Level, Output, Speed};
-use embassy_stm32::tsc::{self, *};
-use embassy_time::Timer;
-use {defmt_rtt as _, panic_probe as _};
-
-bind_interrupts!(struct Irqs {
-    TSC => InterruptHandler<embassy_stm32::peripherals::TSC>;
-});
-
-#[cortex_m_rt::exception]
-unsafe fn HardFault(_: &cortex_m_rt::ExceptionFrame) -> ! {
-    cortex_m::peripheral::SCB::sys_reset();
-}
-
-/// This example is written for the nucleo-stm32l073rz, with a stm32l073rz chip.
-///
-/// Make sure you check/update the following (whether you use the L073RZ or another board):
-///
-/// * [ ] Update .cargo/config.toml with the correct `probe-rs run --chip STM32L073RZTx`chip name.
-/// * [ ] Update Cargo.toml to have the correct `embassy-stm32` feature, for L073RZ it should be `stm32l073rz`.
-/// * [ ] If your board has a special clock or power configuration, make sure that it is
-///       set up appropriately.
-/// * [ ] If your board has different pin mapping, update any pin numbers or peripherals
-///       to match your schematic
-///
-/// If you are unsure, please drop by the Embassy Matrix chat for support, and let us know:
-///
-/// * Which example you are trying to run
-/// * Which chip and board you are using
-///
-/// Embassy Chat: https://matrix.to/#/#embassy-rs:matrix.org
-#[embassy_executor::main]
-async fn main(_spawner: embassy_executor::Spawner) {
-    let device_config = embassy_stm32::Config::default();
-    let context = embassy_stm32::init(device_config);
-
-    let config = tsc::Config {
-        ct_pulse_high_length: ChargeTransferPulseCycle::_4,
-        ct_pulse_low_length: ChargeTransferPulseCycle::_4,
-        spread_spectrum: false,
-        spread_spectrum_deviation: SSDeviation::new(2).unwrap(),
-        spread_spectrum_prescaler: false,
-        pulse_generator_prescaler: PGPrescalerDivider::_16,
-        max_count_value: MaxCount::_255,
-        io_default_mode: false,
-        synchro_pin_polarity: false,
-        acquisition_mode: false,
-        max_count_interrupt: false,
-        channel_ios: TscIOPin::Group1Io1.into(),
-        shield_ios: 0, // no shield
-        sampling_ios: TscIOPin::Group1Io2.into(),
-    };
-
-    let mut g1: PinGroup<embassy_stm32::peripherals::TSC, G1> = PinGroup::new();
-    g1.set_io1(context.PA0, PinType::Sample);
-    g1.set_io2(context.PA1, PinType::Channel);
-
-    let mut touch_controller = tsc::Tsc::new_async(
-        context.TSC,
-        Some(g1),
-        None,
-        None,
-        None,
-        None,
-        None,
-        None,
-        None,
-        config,
-        Irqs,
-    );
-
-    // Check if TSC is ready
-    if touch_controller.get_state() != State::Ready {
-        info!("TSC not ready!");
-        loop {} // Halt execution
-    }
-    info!("TSC initialized successfully");
-
-    // LED2 on the STM32L073RZ nucleo-board (PA5)
-    let mut led = Output::new(context.PA5, Level::High, Speed::Low);
-
-    // smaller sample capacitor discharge faster and can be used with shorter delay.
-    let discharge_delay = 5; // ms
-
-    info!("Starting touch_controller interface");
-    loop {
-        touch_controller.start();
-        touch_controller.pend_for_acquisition().await;
-        touch_controller.discharge_io(true);
-        Timer::after_millis(discharge_delay).await;
-
-        let grp1_status = touch_controller.group_get_status(Group::One);
-        match grp1_status {
-            GroupStatus::Complete => {
-                let group_one_val = touch_controller.group_get_value(Group::One);
-                info!("{}", group_one_val);
-                led.set_high();
-            }
-            GroupStatus::Ongoing => led.set_low(),
-        }
-    }
-}
diff --git a/examples/stm32l0/src/bin/blocking-tsc.rs b/examples/stm32l0/src/bin/blocking-tsc.rs
deleted file mode 100644
index 7e4f40946..000000000
--- a/examples/stm32l0/src/bin/blocking-tsc.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-// Example of polling TSC (Touch Sensing Controller) that lights an LED when touch is detected.
-//
-// Suggested physical setup on STM32L073RZ Nucleo board:
-// - Connect a 1000pF capacitor between pin A0 and GND. This is your sampling capacitor.
-// - Connect one end of a 1K resistor to pin A1 and leave the other end loose.
-//   The loose end will act as touch sensor which will register your touch.
-//
-// Troubleshooting the setup:
-// - If no touch seems to be registered, then try to disconnect the sampling capacitor from GND momentarily,
-//   now the led should light up. Next try using a different value for the sampling capacitor.
-//   Also experiment with increasing the values for `ct_pulse_high_length`, `ct_pulse_low_length`, `pulse_generator_prescaler`, `max_count_value` and `discharge_delay`.
-//
-// All configuration values and sampling capacitor value have been determined experimentally.
-// Suitable configuration and discharge delay values are highly dependent on the value of the sample capacitor. For example, a shorter discharge delay can be used with smaller capacitor values.
-//
-#![no_std]
-#![no_main]
-
-use defmt::*;
-use embassy_stm32::gpio::{Level, Output, Speed};
-use embassy_stm32::tsc::{self, *};
-use embassy_time::Timer;
-use {defmt_rtt as _, panic_probe as _};
-
-/// This example is written for the nucleo-stm32l073rz, with a stm32l073rz chip.
-///
-/// Make sure you check/update the following (whether you use the L073RZ or another board):
-///
-/// * [ ] Update .cargo/config.toml with the correct `probe-rs run --chip STM32L073RZTx`chip name.
-/// * [ ] Update Cargo.toml to have the correct `embassy-stm32` feature, for L073RZ it should be `stm32l073rz`.
-/// * [ ] If your board has a special clock or power configuration, make sure that it is
-///       set up appropriately.
-/// * [ ] If your board has different pin mapping, update any pin numbers or peripherals
-///       to match your schematic
-///
-/// If you are unsure, please drop by the Embassy Matrix chat for support, and let us know:
-///
-/// * Which example you are trying to run
-/// * Which chip and board you are using
-///
-/// Embassy Chat: https://matrix.to/#/#embassy-rs:matrix.org
-#[embassy_executor::main]
-async fn main(_spawner: embassy_executor::Spawner) {
-    let device_config = embassy_stm32::Config::default();
-    let context = embassy_stm32::init(device_config);
-
-    let tsc_conf = Config {
-        ct_pulse_high_length: ChargeTransferPulseCycle::_4,
-        ct_pulse_low_length: ChargeTransferPulseCycle::_4,
-        spread_spectrum: false,
-        spread_spectrum_deviation: SSDeviation::new(2).unwrap(),
-        spread_spectrum_prescaler: false,
-        pulse_generator_prescaler: PGPrescalerDivider::_16,
-        max_count_value: MaxCount::_255,
-        io_default_mode: false,
-        synchro_pin_polarity: false,
-        acquisition_mode: false,
-        max_count_interrupt: false,
-        channel_ios: TscIOPin::Group1Io1.into(),
-        shield_ios: 0, // no shield
-        sampling_ios: TscIOPin::Group1Io2.into(),
-    };
-
-    let mut g1: PinGroup<embassy_stm32::peripherals::TSC, G1> = PinGroup::new();
-    g1.set_io1(context.PA0, PinType::Sample);
-    g1.set_io2(context.PA1, PinType::Channel);
-
-    let mut touch_controller = tsc::Tsc::new_blocking(
-        context.TSC,
-        Some(g1),
-        None,
-        None,
-        None,
-        None,
-        None,
-        None,
-        None,
-        tsc_conf,
-    );
-
-    // Check if TSC is ready
-    if touch_controller.get_state() != State::Ready {
-        info!("TSC not ready!");
-        loop {} // Halt execution
-    }
-    info!("TSC initialized successfully");
-
-    // LED2 on the STM32L073RZ nucleo-board (PA5)
-    let mut led = Output::new(context.PA5, Level::High, Speed::Low);
-
-    // smaller sample capacitor discharge faster and can be used with shorter delay.
-    let discharge_delay = 5; // ms
-
-    // the interval at which the loop polls for new touch sensor values
-    let polling_interval = 100; // ms
-
-    info!("polling for touch");
-    loop {
-        touch_controller.start();
-        touch_controller.poll_for_acquisition();
-        touch_controller.discharge_io(true);
-        Timer::after_millis(discharge_delay).await;
-
-        let grp1_status = touch_controller.group_get_status(Group::One);
-        match grp1_status {
-            GroupStatus::Complete => {
-                let group_one_val = touch_controller.group_get_value(Group::One);
-                info!("{}", group_one_val);
-                led.set_high();
-            }
-            GroupStatus::Ongoing => led.set_low(),
-        }
-
-        Timer::after_millis(polling_interval).await;
-    }
-}
diff --git a/examples/stm32l0/src/bin/tsc_async.rs b/examples/stm32l0/src/bin/tsc_async.rs
new file mode 100644
index 000000000..dae351c2e
--- /dev/null
+++ b/examples/stm32l0/src/bin/tsc_async.rs
@@ -0,0 +1,116 @@
+// Example of async TSC (Touch Sensing Controller) that lights an LED when touch is detected.
+//
+// This example demonstrates:
+// 1. Configuring a single TSC channel pin
+// 2. Using the blocking TSC interface with polling
+// 3. Waiting for acquisition completion using `poll_for_acquisition`
+// 4. Reading touch values and controlling an LED based on the results
+//
+// Suggested physical setup on STM32L073RZ Nucleo board:
+// - Connect a 1000pF capacitor between pin PA0 and GND. This is your sampling capacitor.
+// - Connect one end of a 1K resistor to pin PA1 and leave the other end loose.
+//   The loose end will act as the touch sensor which will register your touch.
+//
+// The example uses two pins from Group 1 of the TSC on the STM32L073RZ Nucleo board:
+// - PA0 as the sampling capacitor, TSC group 1 IO1 (label A0)
+// - PA1 as the channel pin, TSC group 1 IO2 (label A1)
+//
+// The program continuously reads the touch sensor value:
+// - It starts acquisition, waits for completion using `poll_for_acquisition`, and reads the value.
+// - The LED is turned on when touch is detected (sensor value < 25).
+// - Touch values are logged to the console.
+//
+// Troubleshooting:
+// - If touch is not detected, try adjusting the SENSOR_THRESHOLD value.
+// - Experiment with different values for ct_pulse_high_length, ct_pulse_low_length,
+//   pulse_generator_prescaler, max_count_value, and discharge_delay to optimize sensitivity.
+//
+// Note: Configuration values and sampling capacitor value have been determined experimentally.
+// Optimal values may vary based on your specific hardware setup.
+// Pins have been chosen for their convenient locations on the STM32L073RZ board. Refer to the
+// official relevant STM32 datasheets and nucleo-board user manuals to find suitable
+// alternative pins.
+//
+// Beware for STM32L073RZ nucleo-board, that PA2 and PA3 is used for the uart connection to
+// the programmer chip. If you try to use these two pins for TSC, you will get strange
+// readings, unless you somehow reconfigure/re-wire your nucleo-board.
+// No errors or warnings will be emitted, they will just silently not work as expected.
+// (see nucleo user manual UM1724, Rev 14, page 25)
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_stm32::gpio::{Level, Output, Speed};
+use embassy_stm32::tsc::{self, *};
+use embassy_stm32::{bind_interrupts, peripherals};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    TSC => InterruptHandler<embassy_stm32::peripherals::TSC>;
+});
+const SENSOR_THRESHOLD: u16 = 25; // Adjust this value based on your setup
+
+#[embassy_executor::main]
+async fn main(_spawner: embassy_executor::Spawner) {
+    let device_config = embassy_stm32::Config::default();
+    let context = embassy_stm32::init(device_config);
+
+    let mut pin_group: PinGroupWithRoles<peripherals::TSC, G1> = PinGroupWithRoles::default();
+    pin_group.set_io1::<tsc::pin_roles::Sample>(context.PA0);
+    let sensor = pin_group.set_io2::<tsc::pin_roles::Channel>(context.PA1);
+
+    let tsc_conf = Config {
+        ct_pulse_high_length: ChargeTransferPulseCycle::_4,
+        ct_pulse_low_length: ChargeTransferPulseCycle::_4,
+        spread_spectrum: false,
+        spread_spectrum_deviation: SSDeviation::new(2).unwrap(),
+        spread_spectrum_prescaler: false,
+        pulse_generator_prescaler: PGPrescalerDivider::_16,
+        max_count_value: MaxCount::_255,
+        io_default_mode: false,
+        synchro_pin_polarity: false,
+        acquisition_mode: false,
+        max_count_interrupt: false,
+    };
+
+    let pin_groups: PinGroups<peripherals::TSC> = PinGroups {
+        g1: Some(pin_group.pin_group),
+        ..Default::default()
+    };
+
+    let mut touch_controller = tsc::Tsc::new_async(context.TSC, pin_groups, tsc_conf, Irqs).unwrap();
+
+    // Check if TSC is ready
+    if touch_controller.get_state() != State::Ready {
+        info!("TSC not ready!");
+        return;
+    }
+    info!("TSC initialized successfully");
+
+    // LED2 on the STM32L073RZ nucleo-board (PA5)
+    let mut led = Output::new(context.PA5, Level::Low, Speed::Low);
+
+    let discharge_delay = 5; // ms
+
+    info!("Starting touch_controller interface");
+    loop {
+        touch_controller.set_active_channels_mask(sensor.pin.into());
+        touch_controller.start();
+        touch_controller.pend_for_acquisition().await;
+        touch_controller.discharge_io(true);
+        Timer::after_millis(discharge_delay).await;
+
+        let group_val = touch_controller.group_get_value(sensor.pin.group());
+        info!("Touch value: {}", group_val);
+
+        if group_val < SENSOR_THRESHOLD {
+            led.set_high();
+        } else {
+            led.set_low();
+        }
+
+        Timer::after_millis(100).await;
+    }
+}
diff --git a/examples/stm32l0/src/bin/tsc_blocking.rs b/examples/stm32l0/src/bin/tsc_blocking.rs
new file mode 100644
index 000000000..e1f24639b
--- /dev/null
+++ b/examples/stm32l0/src/bin/tsc_blocking.rs
@@ -0,0 +1,142 @@
+// Example of blocking TSC (Touch Sensing Controller) that lights an LED when touch is detected.
+//
+// This example demonstrates:
+// 1. Configuring a single TSC channel pin
+// 2. Using the blocking TSC interface with polling
+// 3. Waiting for acquisition completion using `poll_for_acquisition`
+// 4. Reading touch values and controlling an LED based on the results
+//
+// Suggested physical setup on STM32L073RZ Nucleo board:
+// - Connect a 1000pF capacitor between pin PA0 and GND. This is your sampling capacitor.
+// - Connect one end of a 1K resistor to pin PA1 and leave the other end loose.
+//   The loose end will act as the touch sensor which will register your touch.
+//
+// The example uses two pins from Group 1 of the TSC on the STM32L073RZ Nucleo board:
+// - PA0 as the sampling capacitor, TSC group 1 IO1 (label A0)
+// - PA1 as the channel pin, TSC group 1 IO2 (label A1)
+//
+// The program continuously reads the touch sensor value:
+// - It starts acquisition, waits for completion using `poll_for_acquisition`, and reads the value.
+// - The LED is turned on when touch is detected (sensor value < 25).
+// - Touch values are logged to the console.
+//
+// Troubleshooting:
+// - If touch is not detected, try adjusting the SENSOR_THRESHOLD value.
+// - Experiment with different values for ct_pulse_high_length, ct_pulse_low_length,
+//   pulse_generator_prescaler, max_count_value, and discharge_delay to optimize sensitivity.
+//
+// Note: Configuration values and sampling capacitor value have been determined experimentally.
+// Optimal values may vary based on your specific hardware setup.
+// Pins have been chosen for their convenient locations on the STM32L073RZ board. Refer to the
+// official relevant STM32 datasheets and nucleo-board user manuals to find suitable
+// alternative pins.
+//
+// Beware for STM32L073RZ nucleo-board, that PA2 and PA3 is used for the uart connection to
+// the programmer chip. If you try to use these two pins for TSC, you will get strange
+// readings, unless you somehow reconfigure/re-wire your nucleo-board.
+// No errors or warnings will be emitted, they will just silently not work as expected.
+// (see nucleo user manual UM1724, Rev 14, page 25)
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_stm32::gpio::{Level, Output, Speed};
+use embassy_stm32::tsc::{self, *};
+use embassy_stm32::{mode, peripherals};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+const SENSOR_THRESHOLD: u16 = 25; // Adjust this value based on your setup
+
+#[embassy_executor::main]
+async fn main(_spawner: embassy_executor::Spawner) {
+    let device_config = embassy_stm32::Config::default();
+    let context = embassy_stm32::init(device_config);
+
+    let tsc_conf = Config {
+        ct_pulse_high_length: ChargeTransferPulseCycle::_4,
+        ct_pulse_low_length: ChargeTransferPulseCycle::_4,
+        spread_spectrum: false,
+        spread_spectrum_deviation: SSDeviation::new(2).unwrap(),
+        spread_spectrum_prescaler: false,
+        pulse_generator_prescaler: PGPrescalerDivider::_16,
+        max_count_value: MaxCount::_255,
+        io_default_mode: false,
+        synchro_pin_polarity: false,
+        acquisition_mode: false,
+        max_count_interrupt: false,
+    };
+
+    let mut g1: PinGroupWithRoles<peripherals::TSC, G1> = PinGroupWithRoles::default();
+    g1.set_io1::<tsc::pin_roles::Sample>(context.PA0);
+    let tsc_sensor = g1.set_io2::<tsc::pin_roles::Channel>(context.PA1);
+
+    let pin_groups: PinGroups<peripherals::TSC> = PinGroups {
+        g1: Some(g1.pin_group),
+        ..Default::default()
+    };
+
+    let mut touch_controller = tsc::Tsc::new_blocking(context.TSC, pin_groups, tsc_conf).unwrap();
+
+    // Check if TSC is ready
+    if touch_controller.get_state() != State::Ready {
+        crate::panic!("TSC not ready!");
+    }
+    info!("TSC initialized successfully");
+
+    // LED2 on the STM32L073RZ nucleo-board (PA5)
+    let mut led = Output::new(context.PA5, Level::High, Speed::Low);
+
+    // smaller sample capacitor discharge faster and can be used with shorter delay.
+    let discharge_delay = 5; // ms
+
+    // the interval at which the loop polls for new touch sensor values
+    let polling_interval = 100; // ms
+
+    info!("polling for touch");
+    loop {
+        touch_controller.set_active_channels_mask(tsc_sensor.pin.into());
+        touch_controller.start();
+        touch_controller.poll_for_acquisition();
+        touch_controller.discharge_io(true);
+        Timer::after_millis(discharge_delay).await;
+
+        match read_touch_value(&mut touch_controller, tsc_sensor.pin).await {
+            Some(v) => {
+                info!("sensor value {}", v);
+                if v < SENSOR_THRESHOLD {
+                    led.set_high();
+                } else {
+                    led.set_low();
+                }
+            }
+            None => led.set_low(),
+        }
+
+        Timer::after_millis(polling_interval).await;
+    }
+}
+
+const MAX_GROUP_STATUS_READ_ATTEMPTS: usize = 10;
+
+// attempt to read group status and delay when still ongoing
+async fn read_touch_value(
+    touch_controller: &mut tsc::Tsc<'_, peripherals::TSC, mode::Blocking>,
+    sensor_pin: tsc::IOPin,
+) -> Option<u16> {
+    for _ in 0..MAX_GROUP_STATUS_READ_ATTEMPTS {
+        match touch_controller.group_get_status(sensor_pin.group()) {
+            GroupStatus::Complete => {
+                return Some(touch_controller.group_get_value(sensor_pin.group()));
+            }
+            GroupStatus::Ongoing => {
+                // if you end up here a lot, then you prob need to increase discharge_delay
+                // or consider changing the code to adjust the discharge_delay dynamically
+                info!("Acquisition still ongoing");
+                Timer::after_millis(1).await;
+            }
+        }
+    }
+    None
+}
diff --git a/examples/stm32l0/src/bin/tsc_multipin.rs b/examples/stm32l0/src/bin/tsc_multipin.rs
new file mode 100644
index 000000000..6343de141
--- /dev/null
+++ b/examples/stm32l0/src/bin/tsc_multipin.rs
@@ -0,0 +1,209 @@
+// Example of TSC (Touch Sensing Controller) using multiple pins from the same tsc-group.
+//
+// What is special about using multiple TSC pins as sensor channels from the same TSC group,
+// is that only one TSC pin for each TSC group can be acquired and read at the time.
+// To control which channel pins are acquired and read, we must write a mask before initiating an
+// acquisition. To help manage and abstract all this business away, we can organize our channel
+// pins into acquisition banks. Each acquisition bank can contain exactly one channel pin per TSC
+// group and it will contain the relevant mask.
+//
+// This example demonstrates how to:
+// 1. Configure multiple channel pins within a single TSC group
+// 2. Use the set_active_channels_bank method to switch between sets of different channels (acquisition banks)
+// 3. Read and interpret touch values from multiple channels in the same group
+//
+// Suggested physical setup on STM32L073RZ Nucleo board:
+// - Connect a 1000pF capacitor between pin PA0 (label A0) and GND. This is the sampling capacitor for TSC
+//   group 1.
+// - Connect one end of a 1K resistor to pin PA1 (label A1) and leave the other end loose.
+//   The loose end will act as a touch sensor.
+//
+// - Connect a 1000pF capacitor between pin PB3 (label D3) and GND. This is the sampling capacitor for TSC
+//   group 5.
+// - Connect one end of another 1K resistor to pin PB4 and leave the other end loose.
+//   The loose end will act as a touch sensor.
+// - Connect one end of another 1K resistor to pin PB6 and leave the other end loose.
+//   The loose end will act as a touch sensor.
+//
+// The example uses pins from two TSC groups.
+// - PA0 as sampling capacitor, TSC group 1 IO1 (label A0)
+// - PA1 as channel, TSC group 1 IO2 (label A1)
+// - PB3 as sampling capacitor, TSC group 5 IO1 (label D3)
+// - PB4 as channel, TSC group 5 IO2 (label D10)
+// - PB6 as channel, TSC group 5 IO3 (label D5)
+//
+// The pins have been chosen to make it easy to simply add capacitors directly onto the board and
+// connect one leg to GND, and to easily add resistors to the board with no special connectors,
+// breadboards, special wires or soldering required. All you need is the capacitors and resistors.
+//
+// The program reads the designated channel pins and adjusts the LED blinking
+// pattern based on which sensor(s) are touched:
+// - No touch: LED off
+// - one sensor touched: Slow blinking
+// - two sensors touched: Fast blinking
+// - three sensors touched: LED constantly on
+//
+// Troubleshooting:
+// - If touch is not detected, try adjusting the SENSOR_THRESHOLD value.
+// - Experiment with different values for ct_pulse_high_length, ct_pulse_low_length,
+//   pulse_generator_prescaler, max_count_value, and discharge_delay to optimize sensitivity.
+//
+// Note: Configuration values and sampling capacitor value have been determined experimentally.
+// Optimal values may vary based on your specific hardware setup.
+// Pins have been chosen for their convenient locations on the STM32L073RZ board. Refer to the
+// official relevant STM32 datasheets and nucleo-board user manuals to find suitable
+// alternative pins.
+//
+// Beware for STM32L073RZ nucleo-board, that PA2 and PA3 is used for the uart connection to
+// the programmer chip. If you try to use these two pins for TSC, you will get strange
+// readings, unless you somehow reconfigure/re-wire your nucleo-board.
+// No errors or warnings will be emitted, they will just silently not work as expected.
+// (see nucleo user manual UM1724, Rev 14, page 25)
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_stm32::gpio::{Level, Output, Speed};
+use embassy_stm32::tsc::{self, *};
+use embassy_stm32::{bind_interrupts, mode, peripherals};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    TSC => InterruptHandler<embassy_stm32::peripherals::TSC>;
+});
+
+const SENSOR_THRESHOLD: u16 = 35;
+
+async fn acquire_sensors(
+    touch_controller: &mut Tsc<'static, peripherals::TSC, mode::Async>,
+    tsc_acquisition_bank: &AcquisitionBank,
+) {
+    touch_controller.set_active_channels_bank(tsc_acquisition_bank);
+    touch_controller.start();
+    touch_controller.pend_for_acquisition().await;
+    touch_controller.discharge_io(true);
+    let discharge_delay = 5; // ms
+    Timer::after_millis(discharge_delay).await;
+}
+
+#[embassy_executor::main]
+async fn main(_spawner: embassy_executor::Spawner) {
+    let device_config = embassy_stm32::Config::default();
+    let context = embassy_stm32::init(device_config);
+
+    // ---------- initial configuration of TSC ----------
+    let mut pin_group1: PinGroupWithRoles<peripherals::TSC, G1> = PinGroupWithRoles::default();
+    pin_group1.set_io1::<tsc::pin_roles::Sample>(context.PA0);
+    let tsc_sensor0 = pin_group1.set_io2(context.PA1);
+
+    let mut pin_group5: PinGroupWithRoles<peripherals::TSC, G5> = PinGroupWithRoles::default();
+    pin_group5.set_io1::<tsc::pin_roles::Sample>(context.PB3);
+    let tsc_sensor1 = pin_group5.set_io2(context.PB4);
+    let tsc_sensor2 = pin_group5.set_io3(context.PB6);
+
+    let config = tsc::Config {
+        ct_pulse_high_length: ChargeTransferPulseCycle::_16,
+        ct_pulse_low_length: ChargeTransferPulseCycle::_16,
+        spread_spectrum: false,
+        spread_spectrum_deviation: SSDeviation::new(2).unwrap(),
+        spread_spectrum_prescaler: false,
+        pulse_generator_prescaler: PGPrescalerDivider::_16,
+        max_count_value: MaxCount::_255,
+        io_default_mode: false,
+        synchro_pin_polarity: false,
+        acquisition_mode: false,
+        max_count_interrupt: false,
+    };
+
+    let pin_groups: PinGroups<peripherals::TSC> = PinGroups {
+        g1: Some(pin_group1.pin_group),
+        g5: Some(pin_group5.pin_group),
+        ..Default::default()
+    };
+
+    let mut touch_controller = tsc::Tsc::new_async(context.TSC, pin_groups, config, Irqs).unwrap();
+
+    // ---------- setting up acquisition banks ----------
+    // sensor0 and sensor1 in this example belong to different TSC-groups,
+    // therefore we can acquire and read them both in one go.
+    let bank1 = touch_controller.create_acquisition_bank(AcquisitionBankPins {
+        g1_pin: Some(tsc_sensor0),
+        g5_pin: Some(tsc_sensor1),
+        ..Default::default()
+    });
+    // `sensor1` and `sensor2` belongs to the same TSC-group, therefore we must make sure to
+    // acquire them one at the time. Therefore, we organize them into different acquisition banks.
+    let bank2 = touch_controller.create_acquisition_bank(AcquisitionBankPins {
+        g5_pin: Some(tsc_sensor2),
+        ..Default::default()
+    });
+
+    // Check if TSC is ready
+    if touch_controller.get_state() != State::Ready {
+        crate::panic!("TSC not ready!");
+    }
+
+    info!("TSC initialized successfully");
+
+    // LED2 on the STM32L073RZ nucleo-board (PA5)
+    let mut led = Output::new(context.PA5, Level::High, Speed::Low);
+
+    let mut led_state = false;
+
+    loop {
+        acquire_sensors(&mut touch_controller, &bank1).await;
+        let readings1 = touch_controller.get_acquisition_bank_values(&bank1);
+        acquire_sensors(&mut touch_controller, &bank2).await;
+        let readings2 = touch_controller.get_acquisition_bank_values(&bank2);
+
+        let mut touched_sensors_count = 0;
+        for reading in readings1.iter() {
+            info!("{}", reading);
+            if reading.sensor_value < SENSOR_THRESHOLD {
+                touched_sensors_count += 1;
+            }
+        }
+        for reading in readings2.iter() {
+            info!("{}", reading);
+            if reading.sensor_value < SENSOR_THRESHOLD {
+                touched_sensors_count += 1;
+            }
+        }
+
+        match touched_sensors_count {
+            0 => {
+                // No sensors touched, turn off the LED
+                led.set_low();
+                led_state = false;
+            }
+            1 => {
+                // One sensor touched, blink slowly
+                led_state = !led_state;
+                if led_state {
+                    led.set_high();
+                } else {
+                    led.set_low();
+                }
+                Timer::after_millis(200).await;
+            }
+            2 => {
+                // Two sensors touched, blink faster
+                led_state = !led_state;
+                if led_state {
+                    led.set_high();
+                } else {
+                    led.set_low();
+                }
+                Timer::after_millis(50).await;
+            }
+            3 => {
+                // All three sensors touched, LED constantly on
+                led.set_high();
+                led_state = true;
+            }
+            _ => crate::unreachable!(), // This case should never occur with 3 sensors
+        }
+    }
+}
diff --git a/examples/stm32l4/.cargo/config.toml b/examples/stm32l4/.cargo/config.toml
index 83fc6d6f8..d71fb1517 100644
--- a/examples/stm32l4/.cargo/config.toml
+++ b/examples/stm32l4/.cargo/config.toml
@@ -2,7 +2,8 @@
 # replace STM32F429ZITx with your chip as listed in `probe-rs chip list`
 #runner = "probe-rs run --chip STM32L475VGT6"
 #runner = "probe-rs run --chip STM32L475VG"
-runner = "probe-rs run --chip STM32L4S5QI"
+#runner = "probe-rs run --chip STM32L4S5QI"
+runner = "probe-rs run --chip STM32L4R5ZITxP"
 
 [build]
 target = "thumbv7em-none-eabi"
diff --git a/examples/stm32l4/Cargo.toml b/examples/stm32l4/Cargo.toml
index b172878c1..512bb8064 100644
--- a/examples/stm32l4/Cargo.toml
+++ b/examples/stm32l4/Cargo.toml
@@ -6,7 +6,7 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 # Change stm32l4s5vi to your chip name, if necessary.
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = [ "defmt", "unstable-pac", "stm32l4s5qi", "memory-x", "time-driver-any", "exti", "chrono"]  }
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = [ "defmt", "unstable-pac", "stm32l4r5zi", "memory-x", "time-driver-any", "exti", "chrono"]  }
 embassy-sync = { version = "0.6.1", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.6.3", path = "../../embassy-executor", features = ["task-arena-size-32768", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.3.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768", ] }
diff --git a/examples/stm32l4/README.md b/examples/stm32l4/README.md
new file mode 100644
index 000000000..e463c18a0
--- /dev/null
+++ b/examples/stm32l4/README.md
@@ -0,0 +1,24 @@
+# Examples for STM32L4 family
+Run individual examples with
+```
+cargo run --bin <module-name>
+```
+for example
+```
+cargo run --bin blinky
+```
+
+## Checklist before running examples
+You might need to adjust `.cargo/config.toml`, `Cargo.toml` and possibly update pin numbers or peripherals to match the specific MCU or board you are using.
+
+* [ ] Update .cargo/config.toml with the correct probe-rs command to use your specific MCU. For example for L4R5ZI-P it should be `probe-rs run --chip STM32L4R5ZITxP`. (use `probe-rs chip list` to find your chip)
+* [ ] Update Cargo.toml to have the correct `embassy-stm32` feature. For example for L4R5ZI-P it should be `stm32l4r5zi`. Look in the `Cargo.toml` file of the `embassy-stm32` project to find the correct feature flag for your chip.
+* [ ] If your board has a special clock or power configuration, make sure that it is set up appropriately.
+* [ ] If your board has different pin mapping, update any pin numbers or peripherals in the given example code to match your schematic
+
+If you are unsure, please drop by the Embassy Matrix chat for support, and let us know:
+
+* Which example you are trying to run
+* Which chip and board you are using
+
+Embassy Chat: https://matrix.to/#/#embassy-rs:matrix.org
diff --git a/examples/stm32l4/src/bin/tsc_async.rs b/examples/stm32l4/src/bin/tsc_async.rs
new file mode 100644
index 000000000..b9a059e2e
--- /dev/null
+++ b/examples/stm32l4/src/bin/tsc_async.rs
@@ -0,0 +1,108 @@
+// Example of async TSC (Touch Sensing Controller) that lights an LED when touch is detected.
+//
+// This example demonstrates:
+// 1. Configuring a single TSC channel pin
+// 2. Using the async TSC interface
+// 3. Waiting for acquisition completion using `pend_for_acquisition`
+// 4. Reading touch values and controlling an LED based on the results
+//
+// Suggested physical setup on STM32L4R5ZI-P board:
+// - Connect a 1000pF capacitor between pin PB4 (D25) and GND. This is your sampling capacitor.
+// - Connect one end of a 1K resistor to pin PB5 (D21) and leave the other end loose.
+//   The loose end will act as the touch sensor which will register your touch.
+//
+// The example uses two pins from Group 2 of the TSC:
+// - PB4 (D25) as the sampling capacitor, TSC group 2 IO1
+// - PB5 (D21) as the channel pin, TSC group 2 IO2
+//
+// The program continuously reads the touch sensor value:
+// - It starts acquisition, waits for completion using `pend_for_acquisition`, and reads the value.
+// - The LED (connected to PB14) is turned on when touch is detected (sensor value < SENSOR_THRESHOLD).
+// - Touch values are logged to the console.
+//
+// Troubleshooting:
+// - If touch is not detected, try adjusting the SENSOR_THRESHOLD value.
+// - Experiment with different values for ct_pulse_high_length, ct_pulse_low_length,
+//   pulse_generator_prescaler, max_count_value, and discharge_delay to optimize sensitivity.
+//
+// Note: Configuration values and sampling capacitor value have been determined experimentally.
+// Optimal values may vary based on your specific hardware setup.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_stm32::gpio::{Level, Output, Speed};
+use embassy_stm32::tsc::{self, *};
+use embassy_stm32::{bind_interrupts, peripherals};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    TSC => InterruptHandler<embassy_stm32::peripherals::TSC>;
+});
+const SENSOR_THRESHOLD: u16 = 25; // Adjust this value based on your setup
+
+#[embassy_executor::main]
+async fn main(_spawner: embassy_executor::Spawner) {
+    let device_config = embassy_stm32::Config::default();
+    let context = embassy_stm32::init(device_config);
+
+    let mut pin_group: PinGroupWithRoles<peripherals::TSC, G2> = PinGroupWithRoles::default();
+    // D25
+    pin_group.set_io1::<tsc::pin_roles::Sample>(context.PB4);
+    // D21
+    let tsc_sensor = pin_group.set_io2::<tsc::pin_roles::Channel>(context.PB5);
+
+    let pin_groups: PinGroups<peripherals::TSC> = PinGroups {
+        g2: Some(pin_group.pin_group),
+        ..Default::default()
+    };
+
+    let tsc_conf = Config {
+        ct_pulse_high_length: ChargeTransferPulseCycle::_4,
+        ct_pulse_low_length: ChargeTransferPulseCycle::_4,
+        spread_spectrum: false,
+        spread_spectrum_deviation: SSDeviation::new(2).unwrap(),
+        spread_spectrum_prescaler: false,
+        pulse_generator_prescaler: PGPrescalerDivider::_16,
+        max_count_value: MaxCount::_255,
+        io_default_mode: false,
+        synchro_pin_polarity: false,
+        acquisition_mode: false,
+        max_count_interrupt: false,
+    };
+
+    let mut touch_controller = tsc::Tsc::new_async(context.TSC, pin_groups, tsc_conf, Irqs).unwrap();
+
+    // Check if TSC is ready
+    if touch_controller.get_state() != State::Ready {
+        info!("TSC not ready!");
+        return;
+    }
+    info!("TSC initialized successfully");
+
+    let mut led = Output::new(context.PB14, Level::High, Speed::Low);
+
+    let discharge_delay = 1; // ms
+
+    info!("Starting touch_controller interface");
+    loop {
+        touch_controller.set_active_channels_mask(tsc_sensor.pin.into());
+        touch_controller.start();
+        touch_controller.pend_for_acquisition().await;
+        touch_controller.discharge_io(true);
+        Timer::after_millis(discharge_delay).await;
+
+        let group_val = touch_controller.group_get_value(tsc_sensor.pin.group());
+        info!("Touch value: {}", group_val);
+
+        if group_val < SENSOR_THRESHOLD {
+            led.set_high();
+        } else {
+            led.set_low();
+        }
+
+        Timer::after_millis(100).await;
+    }
+}
diff --git a/examples/stm32l4/src/bin/tsc_blocking.rs b/examples/stm32l4/src/bin/tsc_blocking.rs
new file mode 100644
index 000000000..12084f8e2
--- /dev/null
+++ b/examples/stm32l4/src/bin/tsc_blocking.rs
@@ -0,0 +1,147 @@
+// # Example of blocking TSC (Touch Sensing Controller) that lights an LED when touch is detected
+//
+// This example demonstrates how to use the Touch Sensing Controller (TSC) in blocking mode on an STM32L4R5ZI-P board.
+//
+// ## This example demonstrates:
+//
+// 1. Configuring a single TSC channel pin
+// 2. Using the blocking TSC interface with polling
+// 3. Waiting for acquisition completion using `poll_for_acquisition`
+// 4. Reading touch values and controlling an LED based on the results
+//
+// ## Suggested physical setup on STM32L4R5ZI-P board:
+//
+// - Connect a 1000pF capacitor between pin PB4 (D25) and GND. This is your sampling capacitor.
+// - Connect one end of a 1K resistor to pin PB5 (D21) and leave the other end loose.
+//   The loose end will act as the touch sensor which will register your touch.
+//
+// ## Pin Configuration:
+//
+// The example uses two pins from Group 2 of the TSC:
+// - PB4 (D25) as the sampling capacitor, TSC group 2 IO1
+// - PB5 (D21) as the channel pin, TSC group 2 IO2
+//
+// ## Program Behavior:
+//
+// The program continuously reads the touch sensor value:
+// - It starts acquisition, waits for completion using `poll_for_acquisition`, and reads the value.
+// - The LED (connected to PB14) is turned on when touch is detected (sensor value < SENSOR_THRESHOLD).
+// - Touch values are logged to the console.
+//
+// ## Troubleshooting:
+//
+// - If touch is not detected, try adjusting the SENSOR_THRESHOLD value (currently set to 25).
+// - Experiment with different values for ct_pulse_high_length, ct_pulse_low_length,
+//   pulse_generator_prescaler, max_count_value, and discharge_delay to optimize sensitivity.
+// - Be aware that for some boards, there might be overlapping concerns between some pins,
+//   such as UART connections for the programmer. No errors or warnings will be emitted if you
+//   try to use such a pin for TSC, but you may get strange sensor readings.
+//
+// Note: Configuration values and sampling capacitor value have been determined experimentally.
+// Optimal values may vary based on your specific hardware setup. Refer to the official
+// STM32L4R5ZI-P datasheet and user manuals for more information on pin configurations and TSC functionality.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_stm32::gpio::{Level, Output, Speed};
+use embassy_stm32::tsc::{self, *};
+use embassy_stm32::{mode, peripherals};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+const SENSOR_THRESHOLD: u16 = 25; // Adjust this value based on your setup
+
+#[embassy_executor::main]
+async fn main(_spawner: embassy_executor::Spawner) {
+    let device_config = embassy_stm32::Config::default();
+    let context = embassy_stm32::init(device_config);
+
+    let tsc_conf = Config {
+        ct_pulse_high_length: ChargeTransferPulseCycle::_4,
+        ct_pulse_low_length: ChargeTransferPulseCycle::_4,
+        spread_spectrum: false,
+        spread_spectrum_deviation: SSDeviation::new(2).unwrap(),
+        spread_spectrum_prescaler: false,
+        pulse_generator_prescaler: PGPrescalerDivider::_16,
+        max_count_value: MaxCount::_255,
+        io_default_mode: false,
+        synchro_pin_polarity: false,
+        acquisition_mode: false,
+        max_count_interrupt: false,
+    };
+
+    let mut g2: PinGroupWithRoles<peripherals::TSC, G2> = PinGroupWithRoles::default();
+    // D25
+    g2.set_io1::<tsc::pin_roles::Sample>(context.PB4);
+    // D21
+    let tsc_sensor = g2.set_io2::<tsc::pin_roles::Channel>(context.PB5);
+
+    let pin_groups: PinGroups<peripherals::TSC> = PinGroups {
+        g2: Some(g2.pin_group),
+        ..Default::default()
+    };
+
+    let mut touch_controller = tsc::Tsc::new_blocking(context.TSC, pin_groups, tsc_conf).unwrap();
+
+    // Check if TSC is ready
+    if touch_controller.get_state() != State::Ready {
+        crate::panic!("TSC not ready!");
+    }
+    info!("TSC initialized successfully");
+
+    let mut led = Output::new(context.PB14, Level::High, Speed::Low);
+
+    // smaller sample capacitor discharge faster and can be used with shorter delay.
+    let discharge_delay = 5; // ms
+
+    // the interval at which the loop polls for new touch sensor values
+    let polling_interval = 100; // ms
+
+    info!("polling for touch");
+    loop {
+        touch_controller.set_active_channels_mask(tsc_sensor.pin.into());
+        touch_controller.start();
+        touch_controller.poll_for_acquisition();
+        touch_controller.discharge_io(true);
+        Timer::after_millis(discharge_delay).await;
+
+        match read_touch_value(&mut touch_controller, tsc_sensor.pin).await {
+            Some(v) => {
+                info!("sensor value {}", v);
+                if v < SENSOR_THRESHOLD {
+                    led.set_high();
+                } else {
+                    led.set_low();
+                }
+            }
+            None => led.set_low(),
+        }
+
+        Timer::after_millis(polling_interval).await;
+    }
+}
+
+const MAX_GROUP_STATUS_READ_ATTEMPTS: usize = 10;
+
+// attempt to read group status and delay when still ongoing
+async fn read_touch_value(
+    touch_controller: &mut tsc::Tsc<'_, peripherals::TSC, mode::Blocking>,
+    sensor_pin: tsc::IOPin,
+) -> Option<u16> {
+    for _ in 0..MAX_GROUP_STATUS_READ_ATTEMPTS {
+        match touch_controller.group_get_status(sensor_pin.group()) {
+            GroupStatus::Complete => {
+                return Some(touch_controller.group_get_value(sensor_pin.group()));
+            }
+            GroupStatus::Ongoing => {
+                // if you end up here a lot, then you prob need to increase discharge_delay
+                // or consider changing the code to adjust the discharge_delay dynamically
+                info!("Acquisition still ongoing");
+                Timer::after_millis(1).await;
+            }
+        }
+    }
+    None
+}
diff --git a/examples/stm32l4/src/bin/tsc_multipin.rs b/examples/stm32l4/src/bin/tsc_multipin.rs
new file mode 100644
index 000000000..8fec5ddc4
--- /dev/null
+++ b/examples/stm32l4/src/bin/tsc_multipin.rs
@@ -0,0 +1,198 @@
+// # Example of TSC (Touch Sensing Controller) using multiple pins from the same TSC group
+//
+// This example demonstrates how to use the Touch Sensing Controller (TSC) with multiple pins, including pins from the same TSC group, on an STM32L4R5ZI-P board.
+//
+// ## Key Concepts
+//
+// - Only one TSC pin for each TSC group can be acquired and read at a time.
+// - To control which channel pins are acquired and read, we must write a mask before initiating an acquisition.
+// - We organize channel pins into acquisition banks to manage this process efficiently.
+// - Each acquisition bank can contain exactly one channel pin per TSC group and will contain the relevant mask.
+//
+// ## This example demonstrates how to:
+//
+// 1. Configure multiple channel pins within a single TSC group
+// 2. Use the set_active_channels_bank method to switch between sets of different channels (acquisition banks)
+// 3. Read and interpret touch values from multiple channels in the same group
+//
+// ## Suggested physical setup on STM32L4R5ZI-P board:
+//
+// - Connect a 1000pF capacitor between pin PB12 (D19) and GND. This is the sampling capacitor for TSC group 1.
+// - Connect one end of a 1K resistor to pin PB13 (D18) and leave the other end loose. This will act as a touch sensor.
+// - Connect a 1000pF capacitor between pin PB4 (D25) and GND. This is the sampling capacitor for TSC group 2.
+// - Connect one end of a 1K resistor to pin PB5 (D22) and leave the other end loose. This will act as a touch sensor.
+// - Connect one end of another 1K resistor to pin PB6 (D71) and leave the other end loose. This will act as a touch sensor.
+//
+// ## Pin Configuration:
+//
+// The example uses pins from two TSC groups:
+//
+// - Group 1:
+//   - PB12 (D19) as sampling capacitor (TSC group 1 IO1)
+//   - PB13 (D18) as channel (TSC group 1 IO2)
+// - Group 2:
+//   - PB4 (D25) as sampling capacitor (TSC group 2 IO1)
+//   - PB5 (D22) as channel (TSC group 2 IO2)
+//   - PB6 (D71) as channel (TSC group 2 IO3)
+//
+// The pins have been chosen for their convenient locations on the STM32L4R5ZI-P board, making it easy to add capacitors and resistors directly to the board without special connectors, breadboards, or soldering.
+//
+// ## Program Behavior:
+//
+// The program reads the designated channel pins and adjusts the LED (connected to PB14) blinking pattern based on which sensor(s) are touched:
+//
+// - No touch: LED off
+// - One sensor touched: Slow blinking
+// - Two sensors touched: Fast blinking
+// - Three sensors touched: LED constantly on
+//
+// ## Troubleshooting:
+//
+// - If touch is not detected, try adjusting the SENSOR_THRESHOLD value (currently set to 20).
+// - Experiment with different values for ct_pulse_high_length, ct_pulse_low_length, pulse_generator_prescaler, max_count_value, and discharge_delay to optimize sensitivity.
+// - Be aware that for some boards there will be overlapping concerns between some pins, for
+//  example UART connection for the programmer to the MCU and a TSC pin. No errors or warning will
+//  be emitted if you try to use such a pin for TSC, but you will get strange sensor readings.
+//
+// Note: Configuration values and sampling capacitor values have been determined experimentally. Optimal values may vary based on your specific hardware setup. Refer to the official STM32L4R5ZI-P datasheet and user manuals for more information on pin configurations and TSC functionality.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_stm32::gpio::{Level, Output, Speed};
+use embassy_stm32::tsc::{self, *};
+use embassy_stm32::{bind_interrupts, mode, peripherals};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    TSC => InterruptHandler<embassy_stm32::peripherals::TSC>;
+});
+
+const SENSOR_THRESHOLD: u16 = 20;
+
+async fn acquire_sensors(
+    touch_controller: &mut Tsc<'static, peripherals::TSC, mode::Async>,
+    tsc_acquisition_bank: &AcquisitionBank,
+) {
+    touch_controller.set_active_channels_bank(tsc_acquisition_bank);
+    touch_controller.start();
+    touch_controller.pend_for_acquisition().await;
+    touch_controller.discharge_io(true);
+    let discharge_delay = 1; // ms
+    Timer::after_millis(discharge_delay).await;
+}
+
+#[embassy_executor::main]
+async fn main(_spawner: embassy_executor::Spawner) {
+    let device_config = embassy_stm32::Config::default();
+    let context = embassy_stm32::init(device_config);
+
+    // ---------- initial configuration of TSC ----------
+    let mut g1: PinGroupWithRoles<peripherals::TSC, G1> = PinGroupWithRoles::default();
+    g1.set_io1::<tsc::pin_roles::Sample>(context.PB12);
+    let sensor0 = g1.set_io2::<tsc::pin_roles::Channel>(context.PB13);
+
+    let mut g2: PinGroupWithRoles<peripherals::TSC, G2> = PinGroupWithRoles::default();
+    g2.set_io1::<tsc::pin_roles::Sample>(context.PB4);
+    let sensor1 = g2.set_io2(context.PB5);
+    let sensor2 = g2.set_io3(context.PB6);
+
+    let config = tsc::Config {
+        ct_pulse_high_length: ChargeTransferPulseCycle::_16,
+        ct_pulse_low_length: ChargeTransferPulseCycle::_16,
+        spread_spectrum: false,
+        spread_spectrum_deviation: SSDeviation::new(2).unwrap(),
+        spread_spectrum_prescaler: false,
+        pulse_generator_prescaler: PGPrescalerDivider::_16,
+        max_count_value: MaxCount::_255,
+        io_default_mode: false,
+        synchro_pin_polarity: false,
+        acquisition_mode: false,
+        max_count_interrupt: false,
+    };
+
+    let pin_groups: PinGroups<peripherals::TSC> = PinGroups {
+        g1: Some(g1.pin_group),
+        g2: Some(g2.pin_group),
+        ..Default::default()
+    };
+
+    let mut touch_controller = tsc::Tsc::new_async(context.TSC, pin_groups, config, Irqs).unwrap();
+
+    // ---------- setting up acquisition banks ----------
+    // sensor0 and sensor1 belong to different TSC-groups, therefore we can acquire and
+    // read them both in one go.
+    let bank1 = touch_controller.create_acquisition_bank(AcquisitionBankPins {
+        g1_pin: Some(sensor0),
+        g2_pin: Some(sensor1),
+        ..Default::default()
+    });
+    // `sensor1` and `sensor2` belongs to the same TSC-group, therefore we must make sure to
+    // acquire them one at the time. We do this by organizing them into different acquisition banks.
+    let bank2 = touch_controller.create_acquisition_bank(AcquisitionBankPins {
+        g2_pin: Some(sensor2),
+        ..Default::default()
+    });
+
+    // Check if TSC is ready
+    if touch_controller.get_state() != State::Ready {
+        crate::panic!("TSC not ready!");
+    }
+
+    info!("TSC initialized successfully");
+
+    let mut led = Output::new(context.PB14, Level::High, Speed::Low);
+
+    let mut led_state = false;
+
+    loop {
+        acquire_sensors(&mut touch_controller, &bank1).await;
+        let readings1 = touch_controller.get_acquisition_bank_values(&bank1);
+        acquire_sensors(&mut touch_controller, &bank2).await;
+        let readings2 = touch_controller.get_acquisition_bank_values(&bank2);
+
+        let mut touched_sensors_count = 0;
+        for reading in readings1.iter().chain(readings2.iter()) {
+            info!("{}", reading);
+            if reading.sensor_value < SENSOR_THRESHOLD {
+                touched_sensors_count += 1;
+            }
+        }
+
+        match touched_sensors_count {
+            0 => {
+                // No sensors touched, turn off the LED
+                led.set_low();
+                led_state = false;
+            }
+            1 => {
+                // One sensor touched, blink slowly
+                led_state = !led_state;
+                if led_state {
+                    led.set_high();
+                } else {
+                    led.set_low();
+                }
+                Timer::after_millis(200).await;
+            }
+            2 => {
+                // Two sensors touched, blink faster
+                led_state = !led_state;
+                if led_state {
+                    led.set_high();
+                } else {
+                    led.set_low();
+                }
+                Timer::after_millis(50).await;
+            }
+            3 => {
+                // All three sensors touched, LED constantly on
+                led.set_high();
+                led_state = true;
+            }
+            _ => crate::unreachable!(), // This case should never occur with 3 sensors
+        }
+    }
+}
diff --git a/examples/stm32u5/src/bin/tsc.rs b/examples/stm32u5/src/bin/tsc.rs
index eb15d275a..a85acc4c7 100644
--- a/examples/stm32u5/src/bin/tsc.rs
+++ b/examples/stm32u5/src/bin/tsc.rs
@@ -2,8 +2,8 @@
 #![no_main]
 
 use defmt::*;
-use embassy_stm32::bind_interrupts;
 use embassy_stm32::tsc::{self, *};
+use embassy_stm32::{bind_interrupts, peripherals};
 use embassy_time::Timer;
 use {defmt_rtt as _, panic_probe as _};
 
@@ -33,63 +33,52 @@ async fn main(_spawner: embassy_executor::Spawner) {
         synchro_pin_polarity: false,
         acquisition_mode: false,
         max_count_interrupt: false,
-        channel_ios: TscIOPin::Group2Io2 | TscIOPin::Group7Io3,
-        shield_ios: TscIOPin::Group1Io3.into(),
-        sampling_ios: TscIOPin::Group1Io2 | TscIOPin::Group2Io1 | TscIOPin::Group7Io2,
     };
 
-    let mut g1: PinGroup<embassy_stm32::peripherals::TSC, G1> = PinGroup::new();
-    g1.set_io2(context.PB13, PinType::Sample);
-    g1.set_io3(context.PB14, PinType::Shield);
+    let mut g1: PinGroupWithRoles<peripherals::TSC, G1> = PinGroupWithRoles::default();
+    g1.set_io2::<tsc::pin_roles::Sample>(context.PB13);
+    g1.set_io3::<tsc::pin_roles::Shield>(context.PB14);
 
-    let mut g2: PinGroup<embassy_stm32::peripherals::TSC, G2> = PinGroup::new();
-    g2.set_io1(context.PB4, PinType::Sample);
-    g2.set_io2(context.PB5, PinType::Channel);
+    let mut g2: PinGroupWithRoles<peripherals::TSC, G2> = PinGroupWithRoles::default();
+    g2.set_io1::<tsc::pin_roles::Sample>(context.PB4);
+    let sensor0 = g2.set_io2(context.PB5);
 
-    let mut g7: PinGroup<embassy_stm32::peripherals::TSC, G7> = PinGroup::new();
-    g7.set_io2(context.PE3, PinType::Sample);
-    g7.set_io3(context.PE4, PinType::Channel);
+    let mut g7: PinGroupWithRoles<peripherals::TSC, G7> = PinGroupWithRoles::default();
+    g7.set_io2::<tsc::pin_roles::Sample>(context.PE3);
+    let sensor1 = g7.set_io3(context.PE4);
 
-    let mut touch_controller = tsc::Tsc::new_async(
-        context.TSC,
-        Some(g1),
-        Some(g2),
-        None,
-        None,
-        None,
-        None,
-        Some(g7),
-        None,
-        config,
-        Irqs,
-    );
+    let pin_groups: PinGroups<peripherals::TSC> = PinGroups {
+        g1: Some(g1.pin_group),
+        g2: Some(g2.pin_group),
+        g7: Some(g7.pin_group),
+        ..Default::default()
+    };
+
+    let mut touch_controller = tsc::Tsc::new_async(context.TSC, pin_groups, config, Irqs).unwrap();
 
-    touch_controller.discharge_io(true);
-    Timer::after_millis(1).await;
+    let acquisition_bank = touch_controller.create_acquisition_bank(AcquisitionBankPins {
+        g2_pin: Some(sensor0),
+        g7_pin: Some(sensor1),
+        ..Default::default()
+    });
 
-    touch_controller.start();
+    touch_controller.set_active_channels_bank(&acquisition_bank);
 
-    let mut group_two_val = 0;
-    let mut group_seven_val = 0;
     info!("Starting touch_controller interface");
     loop {
+        touch_controller.start();
         touch_controller.pend_for_acquisition().await;
         touch_controller.discharge_io(true);
         Timer::after_millis(1).await;
 
-        if touch_controller.group_get_status(Group::Two) == GroupStatus::Complete {
-            group_two_val = touch_controller.group_get_value(Group::Two);
-        }
+        let status = touch_controller.get_acquisition_bank_status(&acquisition_bank);
 
-        if touch_controller.group_get_status(Group::Seven) == GroupStatus::Complete {
-            group_seven_val = touch_controller.group_get_value(Group::Seven);
+        if status.all_complete() {
+            let read_values = touch_controller.get_acquisition_bank_values(&acquisition_bank);
+            let group2_reading = read_values.get_group_reading(Group::Two).unwrap();
+            let group7_reading = read_values.get_group_reading(Group::Seven).unwrap();
+            info!("group 2 value: {}", group2_reading.sensor_value);
+            info!("group 7 value: {}", group7_reading.sensor_value);
         }
-
-        info!(
-            "Group Two value: {}, Group Seven value: {},",
-            group_two_val, group_seven_val
-        );
-
-        touch_controller.start();
     }
 }