Found an implementation for pins that allows us to specify the tsc group information in the type. can now read from two seperate pins (3 touch keys)

Author: MabezDev

examples/touch.rs

@@ -18,40 +18,48 @@ use hal::prelude::*;
 use hal::stm32l4::stm32l4x2;
 use hal::tsc::Tsc;
 use rt::ExceptionFrame;
-use hal::delay::Delay;
 
 entry!(main);
 
 fn main() -> ! {
     let p = stm32l4x2::Peripherals::take().unwrap();
-    let cp = cortex_m::Peripherals::take().unwrap();
+    // let cp = cortex_m::Peripherals::take().unwrap();
 
     let mut flash = p.FLASH.constrain();
     let mut rcc = p.RCC.constrain();
     // let mut gpioa = p.GPIOA.split(&mut rcc.ahb2);
     let mut gpiob = p.GPIOB.split(&mut rcc.ahb2);
 
     // clock configuration using the default settings (all clocks run at 8 MHz)
-    let clocks = rcc.cfgr.freeze(&mut flash.acr);
+    let _clocks = rcc.cfgr.freeze(&mut flash.acr);
     // TRY this alternate clock configuration (clocks run at nearly the maximum frequency)
     // let clocks = rcc.cfgr.sysclk(64.mhz()).pclk1(32.mhz()).freeze(&mut flash.acr);
 
     // let mut delay = Delay::new(cp.SYST, clocks);
+    let mut led = gpiob.pb3.into_push_pull_output(&mut gpiob.moder, &mut gpiob.otyper);
 
     let sample_pin = gpiob.pb4.into_touch_sample(&mut gpiob.moder, &mut gpiob.otyper, &mut gpiob.afrl);
-    let c1 = gpiob.pb5.into_touch_channel(&mut gpiob.moder, &mut gpiob.otyper, &mut gpiob.afrl);
-    let c2 = gpiob.pb6.into_touch_channel(&mut gpiob.moder, &mut gpiob.otyper, &mut gpiob.afrl);
-    let c3 = gpiob.pb7.into_touch_channel(&mut gpiob.moder, &mut gpiob.otyper, &mut gpiob.afrl);
+    let mut c1 = gpiob.pb5.into_touch_channel(&mut gpiob.moder, &mut gpiob.otyper, &mut gpiob.afrl);
+    let mut c2 = gpiob.pb6.into_touch_channel(&mut gpiob.moder, &mut gpiob.otyper, &mut gpiob.afrl);
+    // let mut c3 = gpiob.pb7.into_touch_channel(&mut gpiob.moder, &mut gpiob.otyper, &mut gpiob.afrl);
 
-    let tsc = Tsc::tsc(p.TSC, sample_pin, (c1, c2, c3) , &mut rcc.ahb1);
+    // , (c1, c2, c3) 
+    let tsc = Tsc::tsc(p.TSC, sample_pin, &mut rcc.ahb1);
 
-    tsc.start();
+    tsc.start(&mut c1);
     let baseline = tsc.wait().unwrap();
-
-    tsc.start();
-    let touched = tsc.wait().unwrap();
-
-    loop {}
+    let threshold = (baseline / 100) * 60;
+    loop {
+        tsc.start(&mut c1);
+        let touched = tsc.wait().unwrap();
+        tsc.start(&mut c2);
+        let _touched_c2 = tsc.wait().unwrap();
+        if touched < threshold {
+            led.set_high();
+        } else {
+            led.set_low();
+        }
+    }
 }
 
 exception!(HardFault, hard_fault);

src/tsc.rs

@@ -17,24 +17,30 @@ pub enum Event {
 pub trait SamplePin<TSC> {}
 impl SamplePin<TSC> for PB4<Alternate<AF9, Output<OpenDrain>>> {}
 
-pub trait ChannelPins<TSC> {}
-impl ChannelPins<TSC> for (
-    PB5<Alternate<AF9, Output<PushPull>>>,
-    PB6<Alternate<AF9, Output<PushPull>>>,
-    PB7<Alternate<AF9, Output<PushPull>>>)
-{}
+pub trait ChannelPin<TSC> {
+    const OFFSET: u32;
+}
+impl ChannelPin<TSC> for PB5<Alternate<AF9, Output<PushPull>>> {
+    const OFFSET: u32 = 1 << 1 + (1 * 4);
+}
+impl ChannelPin<TSC> for PB6<Alternate<AF9, Output<PushPull>>> {
+    const OFFSET: u32 = 1 << 2 + (1 * 4);
+}
+impl ChannelPin<TSC> for PB7<Alternate<AF9, Output<PushPull>>> {
+    const OFFSET: u32 = 1 << 3 + (1 * 4);
+}
+
 
 // TODO currently requires all the pins even if a user wants one channel, fix
-pub struct Tsc<SPIN, PINS> {
+pub struct Tsc<SPIN> {
     sample_pin: SPIN,
-    pins: PINS,
+    // pins: PINS,
     tsc: TSC
 }
 
-impl<SPIN, PINS> Tsc<SPIN, PINS> {
-    pub fn tsc(tsc: TSC, sample_pin: SPIN, pins: PINS, ahb: &mut AHB1) -> Self
-        where PINS: ChannelPins<TSC>,
-              SPIN: SamplePin<TSC>
+impl<SPIN> Tsc<SPIN> {
+    pub fn tsc(tsc: TSC, sample_pin: SPIN, ahb: &mut AHB1) -> Self
+        where SPIN: SamplePin<TSC> // PINS: ChannelPins<TSC>,
     {
         /* Enable the peripheral clock */
         ahb.enr().modify(|_, w| w.tscen().set_bit());
@@ -75,13 +81,6 @@ impl<SPIN, PINS> Tsc<SPIN, PINS> {
 
         // Set the sampling pin
         tsc.ioscr.write(|w| { w.g2_io1().set_bit() });
-
-        // Set the channel pin(s)
-        tsc.ioccr.write(|w| {
-            w.g2_io2().set_bit()
-                .g2_io3().set_bit()
-                .g2_io4().set_bit()
-        });
 
         // set the acquisitiuon groups based of the channel pins, stm32l432xx only has group 2
         tsc.iogcsr.write(|w| { w.g2e().set_bit() });
@@ -95,12 +94,14 @@ impl<SPIN, PINS> Tsc<SPIN, PINS> {
         Tsc {
             tsc: tsc,
             sample_pin: sample_pin,
-            pins: pins,
+            // pins: pins,
         }
     }
 
     /// Starts a charge acquisition
-    pub fn start(&self) {
+    pub fn start<PIN>(&self, _input: &mut PIN) 
+        where PIN: ChannelPin<TSC>
+    {
         // clear interrupt & flags
         self.tsc.icr.write(|w| { 
             w.eoaic().set_bit()
@@ -112,6 +113,11 @@ impl<SPIN, PINS> Tsc<SPIN, PINS> {
             w.iodef().clear_bit()
         });
 
+        // Set the channel pin
+        self.tsc.ioccr.write(|w| unsafe {
+            w.bits(PIN::OFFSET)
+        });
+
         self.tsc.cr.modify(|_, w| { w.start().set_bit() });
     }
 
@@ -152,7 +158,7 @@ impl<SPIN, PINS> Tsc<SPIN, PINS> {
     }
 
     /// Releases the TSC peripheral and associated pins
-    pub fn free(self) -> (TSC, SPIN, PINS) {
-        (self.tsc, self.sample_pin, self.pins)
+    pub fn free(self) -> (TSC, SPIN) {
+        (self.tsc, self.sample_pin)
     }
 }