199 lines
8.1 KiB
Rust
199 lines
8.1 KiB
Rust
// # 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
|
|
}
|
|
}
|
|
}
|