QTouch SAMD20E17

[dyne (Gast)]

Hallo,

ich versuche derzeit mit einem ATSAMD20E17 (QFN-Package) kap. 
Touch-Sensoren auszuwerten. Dabei benutze ich das ASF und die 
QTouch-Lib. Problem bei der Sache ist, dass keinerlei Touch-Signale 
ausgewertet werden. Auf einem ATSAMD10 Mini Xplained Board funktioniert 
gleicher Code.
Dazu gehe ich jeweils identisch vor:
1) Neues ASF Projekt mit User-Board Template für D20E17 bzw D1014
2) Im neuen ASF Projekt mit "Add new item" ein QTouch-Design-File 
hinzufügen, worauf ich mit dem QTouch Builder mir meine Sensoren 
konfiguriere.

Das heißt der Q-Touch Code ist Standard und wird von mir nicht 
verändert. Lediglich in der main frage ich den Status des Sensors ab und 
setze entsprechend eine LED auf an.
Auf dem fertigen Xplained Mini Board klappte das auf Anhieb, sodass ich 
irgendwie den Verdacht habe, dass ich an meinem Schaltplan irgendwas 
vergessen habe. Habe dazu das Datenblatt mehrmals zu den entsprechenden 
Kapiteln studiert, aber bisher keinen Erfolg gehabt.
Vielleicht hat ja einer einen Hinweis, wäre über alles dankbar.

Anbei die Schaltung und den Programm-Code des main-Files.

Danke und liebe Grüße

#include <asf.h>

/**
 * Device Revision definition
 */
#define DEVICE_REVISION_MASK (0xFu << 8)
#define DEVICE_REVISION_MASK_POS (8u)
#define DEV_REV_A (0x0)
#define DEV_REV_B (0x1)
#define DEV_REV_C (0x2)

struct rtc_module rtc_instance;
uint32_t device_rev = 0;

/*
 * switch_main_clock 
 */
void switch_main_clock(void);

/*! \brief Initialize timer
 *
 */
void timer_init( void );

/*! \brief RTC timer overflow callback
 *
 */
void rtc_overflow_callback(void);

/*! \brief Configure the RTC timer callback
 *
 */
void configure_rtc_callbacks(void);

/*! \brief Configure the RTC timer count after which interrupts comes
 *
 */
void configure_rtc_count(void);

/*! \brief Set timer period.Called from Qdebug when application
 *     has to change the touch time measurement
 */
void set_timer_period(void);

/*! \brief RTC timer overflow callback
 *
 */
void rtc_overflow_callback(void)
{
  /* Do something on RTC overflow here */
  touch_time.time_to_measure_touch = 1;
  touch_time.current_time_ms = touch_time.current_time_ms +
      touch_time.measurement_period_ms;
}

/*! \brief Configure the RTC timer callback
 *
 */
void configure_rtc_callbacks(void)
{
  /* register callback */
  rtc_count_register_callback(&rtc_instance,
      rtc_overflow_callback, RTC_COUNT_CALLBACK_OVERFLOW);
  /* Enable callback */
  rtc_count_enable_callback(&rtc_instance, RTC_COUNT_CALLBACK_OVERFLOW);
}

/*! \brief Configure the RTC timer count after which interrupts comes
 *
 */
void configure_rtc_count(void)
{
  struct rtc_count_config config_rtc_count;
  rtc_count_get_config_defaults(&config_rtc_count);
    #if ((SAMC20) || (SAMC21))
  config_rtc_count.prescaler           = RTC_MODE0_CTRLA_PRESCALER_DIV32;
    #else
  config_rtc_count.prescaler           = RTC_MODE0_CTRL_PRESCALER_DIV2;
    #endif
  config_rtc_count.mode                = RTC_COUNT_MODE_16BIT;
  #ifdef FEATURE_RTC_CONTINUOUSLY_UPDATED
  config_rtc_count.continuously_update = true;
  #endif
  /* initialize rtc */
  rtc_count_init(&rtc_instance, RTC, &config_rtc_count);

  /* enable rtc */
  rtc_count_enable(&rtc_instance);
}

/*! \brief Initialize timer
 *
 */
void timer_init(void)
{
  /* Configure and enable RTC */
  configure_rtc_count();

  /* Configure and enable callback */
  configure_rtc_callbacks();

  /* Set Timer Period */

  rtc_count_set_period(&rtc_instance, DEF_TOUCH_MEASUREMENT_PERIOD_MS);
}

/*! \brief Set timer period.Called from Qdebug when application
 *     has to change the touch time measurement
 */
void set_timer_period(void )
{
  rtc_count_set_period(&rtc_instance, touch_time.measurement_period_ms);
}

#if ((SAMC20) || (SAMC21))
void switch_main_clock(void)
{
  /* Update OSC48M Pre-scaler */
  struct system_clock_source_osc48m_config osc48m_config_ptr;
  
  system_clock_source_osc48m_get_config_defaults(&osc48m_config_ptr);
  
  osc48m_config_ptr.div = SYSTEM_OSC48M_DIV_1;
  osc48m_config_ptr.on_demand = false;
  osc48m_config_ptr.run_in_standby = true;
  system_clock_source_osc48m_set_config(&osc48m_config_ptr);
  
  struct system_gclk_gen_config gclk_conf;
  system_gclk_gen_get_config_defaults(&gclk_conf);
  gclk_conf.source_clock    = SYSTEM_CLOCK_SOURCE_OSC48M;
  gclk_conf.division_factor = 1;  //Pre-scaler
  gclk_conf.run_in_standby  = false;
  gclk_conf.output_enable   = false;
  system_gclk_gen_set_config(GCLK_GENERATOR_0, &gclk_conf);
  system_gclk_gen_enable(GCLK_GENERATOR_0);
  
  /* GCLK 1 - Main clock pre-scaled for PTC */
  system_gclk_gen_get_config_defaults(&gclk_conf);
  gclk_conf.source_clock    = SYSTEM_CLOCK_SOURCE_OSC48M;
  gclk_conf.division_factor = 12;  //Pre-scaler
  gclk_conf.run_in_standby  = true;
  gclk_conf.output_enable   = false;
  system_gclk_gen_set_config(GCLK_GENERATOR_1, &gclk_conf);
  system_gclk_gen_enable(GCLK_GENERATOR_1);
  
  /* Disable DPLL and corresponding GCLK */
  system_clock_source_disable(SYSTEM_CLOCK_SOURCE_DPLL);
  system_gclk_gen_disable(GCLK_GENERATOR_2);
  
  /* Set on demand bit of OSC48M to one */
  osc48m_config_ptr.on_demand = true;
  system_clock_source_osc48m_set_config(&osc48m_config_ptr);
}
#endif

/*! \brief Main function
 *
 */
int main(void)
{
  /**
   * Initialize and configure system and generic clocks.
   * Use conf_clocks.h to configure system and generic clocks.
   * This example project uses Internal 8MHz oscillator.
   * The PTC module clock is provided using GCLK generator 1.
   */
  system_init();

    #if ((SAMC20) || (SAMC21))
  device_rev = ((DSU->DID.reg & DEVICE_REVISION_MASK) >> DEVICE_REVISION_MASK_POS);
  
  if(device_rev >= DEV_REV_C)
  { 
  /* configure the cpu clock to OSC48MHz, and enable required GCLKs*/
    switch_main_clock();
  }
  #endif
  /**
   * Initialize delay service.
   */
  delay_init();
  
  //LED0
  
  struct system_pinmux_config config_pinmux;
  system_pinmux_get_config_defaults(&config_pinmux);
  config_pinmux.mux_position = SYSTEM_PINMUX_GPIO;
  config_pinmux.direction = SYSTEM_PINMUX_PIN_DIR_OUTPUT;
  system_pinmux_pin_set_config(PIN_PA00, &config_pinmux);
  
  // ... other pin configs ...
    
  // LED1
  system_pinmux_get_config_defaults(&config_pinmux);
  config_pinmux.mux_position = SYSTEM_PINMUX_GPIO;
  config_pinmux.direction = SYSTEM_PINMUX_PIN_DIR_OUTPUT;
  system_pinmux_pin_set_config(PIN_PA01, &config_pinmux);
  
  //port_pin_set_output_level(PIN_PA00, true);

  /**
   * Initialize timer.
   * This example projects uses RTC timer for providing timing
   * info to QTouch library.
   */
  timer_init();

  /**
   * Initialize QTouch library and configure touch sensors.
   */
  touch_sensors_init();

  /* Configure System Sleep mode to standby MODE. */
      
       system_set_sleepmode(SYSTEM_SLEEPMODE_STANDBY);
    

  while (1) {
    /**
     * Goto STANDBY sleep mode, unless woken by timer or PTC
     *interrupt.
     */
    system_sleep();

    /**
     * Start touch sensor measurement, if
     *touch_time.time_to_measure_touch flag is set by timer.
     */
    touch_sensors_measure();
    if ((p_selfcap_measure_data->measurement_done_touch == 1u)) {
      port_pin_set_output_level(PIN_PA01, true);
      uint8_t sensor_state = GET_SELFCAP_SENSOR_STATE(0);
      if(sensor_state > 0) {
        port_pin_set_output_level(PIN_PA00, true);
      }
      
    }

    /**
     * Update touch status once measurement complete flag is set.
     */

    /**
     * Self Cap method
     * if ((p_selfcap_measure_data->measurement_done_touch == 1u))
     * for self cap
     * Touch sensor ON/OFF status or rotor/slider position.
     *
     * Self Cap method
     * uint8_t sensor_state =
     * GET_SELFCAP_SENSOR_STATE(SENSOR_NUMBER);
     * uint8_t rotor_slider_position =
     * GET_SELFCAP_ROTOR_SLIDER_POSITION(SENSOR_NUMBER);
     *
     */

    /**
     * Mutual Cap method
     * if ((p_mutlcap_measure_data->measurement_done_touch == 1u))
     * for mutual cap
     * Touch sensor ON/OFF status or rotor/slider position.
     *
     *
     * uint8_t sensor_state =
     * GET_MUTLCAP_SENSOR_STATE(SENSOR_NUMBER);
     * uint8_t rotor_slider_position =
     * GET_MUTLCAP_ROTOR_SLIDER_POSITION(SENSOR_NUMBER);
     */
  }
}