Adafruit_FreeTouch.cpp

/*
 * FreeTouch, a QTouch-compatible library - tested on ATSAMD21 only!
 * The MIT License (MIT)
 *
 * Copyright (c) 2017 Limor 'ladyada' Fried for Adafruit Industries
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include "Adafruit_FreeTouch.h"

#include "adafruit_ptc.h"

#if !defined(__SAMD21G18A__) and !defined(__SAMD11D14AM__)
#error "Adafruit FreeTouch does not work on your MCU - consider using QTouch"
#endif

Adafruit_FreeTouch::Adafruit_FreeTouch(int p, oversample_t f, series_resistor_t r, freq_mode_t fh) {
    adafruit_ptc_get_config_default(&config);
    pin = p;
    uint8_t port_offset = 0;
    if (g_APinDescription[pin].ulPort == PORTB) {
        port_offset += 32;
    }
    config.pin = port_offset + g_APinDescription[pin].ulPin;
    config.yline = getYLine();  // determine the Y0-15 #
    config.oversample = f;
    config.seriesres = r;
    config.freqhop = fh;
}

bool Adafruit_FreeTouch::begin(void) {
    if (config.yline == -1) {  // not all pins have Y line
        return false;
    }

#ifdef __SAMD21G18A__ 
    /* Setup and enable generic clock source for PTC module.
       struct system_gclk_chan_config gclk_chan_conf;
       system_gclk_chan_get_config_defaults(&gclk_chan_conf);
    */
    
    uint8_t channel = PTC_GCLK_ID;
    uint8_t source_generator = 1;
    
    // original line: system_gclk_chan_set_config(PTC_GCLK_ID, &gclk_chan_conf);
    uint32_t new_clkctrl_config = (channel << GCLK_CLKCTRL_ID_Pos);  // from gclk.c
    
    // original line: gclk_chan_conf.source_generator = GCLK_GENERATOR_1;
    /* Select the desired generic clock generator */
    new_clkctrl_config |= source_generator << GCLK_CLKCTRL_GEN_Pos;  // from gclk.c
    
    /* Disable generic clock channel */
    // original line: system_gclk_chan_disable(channel);
    noInterrupts();
    
    /* Select the requested generator channel */
    *((uint8_t*)&GCLK->CLKCTRL.reg) = channel;
    
    /* Sanity check WRTLOCK */
    //Assert(!GCLK->CLKCTRL.bit.WRTLOCK);
    
    /* Switch to known-working source so that the channel can be disabled */
    uint32_t prev_gen_id = GCLK->CLKCTRL.bit.GEN;
    GCLK->CLKCTRL.bit.GEN = 0;
    
    /* Disable the generic clock */
    GCLK->CLKCTRL.reg &= ~GCLK_CLKCTRL_CLKEN;
    while (GCLK->CLKCTRL.reg & GCLK_CLKCTRL_CLKEN) {
      /* Wait for clock to become disabled */
    }
    
    /* Restore previous configured clock generator */
    GCLK->CLKCTRL.bit.GEN = prev_gen_id;
    
    //system_interrupt_leave_critical_section();  
    interrupts();
    
    /* Write the new configuration */
    GCLK->CLKCTRL.reg = new_clkctrl_config;
    
    // original line: system_gclk_chan_enable(PTC_GCLK_ID);
    *((uint8_t*)&GCLK->CLKCTRL.reg) = channel;
    GCLK->CLKCTRL.reg |= GCLK_CLKCTRL_CLKEN;	/* Enable the generic clock */
    

    // original line: system_apb_clock_set_mask(SYSTEM_CLOCK_APB_APBC, PM_APBCMASK_PTC);
    PM->APBCMASK.reg |= PM_APBCMASK_PTC;
#endif

#ifdef __SAMD11D14AM__

// Sets up the clocks needed for the PTC module. The clock setup is described
// in the touch.c implementation in the ASF examples I've replaced the ASF
// calls with their low-level equivilents. Funny enough, the Generic Clock
// Generator 3 is not actually used by arduinio core although it is set up in
// various places.


  const unsigned int PTC_CLOCK_GCGID = 3;

  // Added for PTC - rough hack - JAG

  SYSCTRL->OSC8M.bit.PRESC = SYSCTRL_OSC8M_PRESC_2_Val ;  // recent versions of CMSIS from Atmel changed the prescaler defines
  SYSCTRL->OSC8M.bit.ONDEMAND = 1 ;
  //  SYSCTRL->OSC8M.bit.RUNINSTANDBY = 1 ;

  /* Put OSC8M as source for Generic Clock Generator 3 */
  GCLK->GENDIV.reg = GCLK_GENDIV_ID( PTC_CLOCK_GCGID) ; // Generic Clock Generator 3
  while ( (SYSCTRL->PCLKSR.reg & SYSCTRL_PCLKSR_DFLLRDY) == 0 );

  // This magic actually does the assignment
  GCLK->GENCTRL.reg =
    ( GCLK_GENCTRL_ID( PTC_CLOCK_GCGID ) |
      GCLK_GENCTRL_SRC_OSC8M
      | GCLK_GENCTRL_GENEN
    );
  while ( (SYSCTRL->PCLKSR.reg & SYSCTRL_PCLKSR_DFLLRDY) == 0 );

  // Original ASF code

  // const int GCLK_GENERATOR_3 = 3;
  // struct system_gclk_chan_config gclk_chan_conf;

  // system_gclk_chan_get_config_defaults(&gclk_chan_conf);
  // gclk_chan_conf->source_generator = GCLK_GENERATOR_0;
  // equivilent to:
  //  gclk_chan_conf.source_generator = GCLK_GENERATOR_3;

  //  system_gclk_chan_set_config(PTC_GCLK_ID, &gclk_chan_conf);
  // equivalent to
  {
    uint32_t new_clkctrl_config = (PTC_GCLK_ID << GCLK_CLKCTRL_ID_Pos);
    new_clkctrl_config |= PTC_CLOCK_GCGID << GCLK_CLKCTRL_GEN_Pos;

    //  system_gclk_chan_disable(channel);
    // this is the "disable" function
    {
      /* Select the requested generator channel */
      *((uint8_t*)&GCLK->CLKCTRL.reg) = PTC_CLOCK_GCGID;

      /* Switch to known-working source so that the channel can be disabled */
      uint32_t prev_gen_id = GCLK->CLKCTRL.bit.GEN;
      GCLK->CLKCTRL.bit.GEN = 0;

      /* Disable the generic clock */
      GCLK->CLKCTRL.reg &= ~GCLK_CLKCTRL_CLKEN;
      while (GCLK->CLKCTRL.reg & GCLK_CLKCTRL_CLKEN) {
        /* Wait for clock to become disabled */
      }

      /* Restore previous configured clock generator */
      GCLK->CLKCTRL.bit.GEN = prev_gen_id;
    }

    /* Write the new configuration */
    GCLK->CLKCTRL.reg = new_clkctrl_config;
  }

  //  system_gclk_chan_enable(PTC_GCLK_ID);
  // equivlent to:
  *((uint8_t*)&GCLK->CLKCTRL.reg) = PTC_GCLK_ID;
  GCLK->CLKCTRL.reg |= GCLK_CLKCTRL_CLKEN;


  // system_apb_clock_set_mask(SYSTEM_CLOCK_APB_APBC, PM_APBCMASK_PTC);
  // equivilant is:
  PM->APBCMASK.reg |= PM_APBCMASK_PTC;

#endif


    // Ensure the pin is tri-stated with no-pullups (necessary for PTC to
    // work).
    //
    // Note to developers: pinMode() appears to be the "safest" way to do
    // peripheral selection because it ensures a single code-path inside
    // ArduinoCore handles pinmux. Arduino "Input" mode is equivilent to
    // peripheral "B", and this has been empirically confirmed.

    pinMode( pin, INPUT );

    adafruit_ptc_init(PTC, &config);

    return true;
}

uint16_t Adafruit_FreeTouch::measure(void) {
  uint16_t m;

  m = measureRaw();
  if (m == -1) return -1;

  // normalize the signal
  switch (config.oversample) {
    case OVERSAMPLE_1:   return m;
    case OVERSAMPLE_2:   return m/2;
    case OVERSAMPLE_4:   return m/4;
    case OVERSAMPLE_8:   return m/8;
    case OVERSAMPLE_16:  return m/16;
    case OVERSAMPLE_32:  return m/32;
    case OVERSAMPLE_64:  return m/64;
  }

  return -1; // shouldn't reach here but fail if we do!
}

uint16_t Adafruit_FreeTouch::measureRaw(void) {
    adafruit_ptc_start_conversion(PTC, &config);

    while (!adafruit_ptc_is_conversion_finished(PTC)) {
        yield();
    }

    return adafruit_ptc_get_conversion_result(PTC);
}

/*********************************** low level config **/

int Adafruit_FreeTouch::getYLine(void) {
  int p = g_APinDescription[pin].ulPin;
  if (g_APinDescription[pin].ulPort == PORTA) {
    if ((p >= 2) && (p <= 7)) {
      return (p - 2);
    }
  }
  if (g_APinDescription[pin].ulPort == PORTB) {
    if ((p >= 0) && (p <= 9)) {
      return (p + 6);
    }
  }

  // not valid
  return -1;
}

void Adafruit_FreeTouch::setCompCap(uint16_t cc) {
    config.compcap = cc & 0x3FFF;
}

void Adafruit_FreeTouch::setIntCap(uint8_t ic) {
    config.intcap = ic & 0x3F;
}

void Adafruit_FreeTouch::setOversampling(oversample_t lvl) {
    config.oversample = lvl; // back it up for later
}

void Adafruit_FreeTouch::setSeriesResistor(series_resistor_t res) {
    config.seriesres = res;
}

void Adafruit_FreeTouch::setFreqHopping(freq_mode_t fh, freq_hop_t hs) {
    config.freqhop = fh;
    config.hops = hs;
}

/**************************** DEBUGGING ASSIST *************************/
void Adafruit_FreeTouch::snapshotRegsAndPrint(uint32_t base, uint8_t numregs) {
  volatile uint32_t addr = base;
  uint8_t datas[255];

  digitalWrite(LED_BUILTIN, HIGH);
  for (uint8_t i=0; i<numregs; i++) {
    datas[i] = *(uint8_t *)(addr+i);
  }
  digitalWrite(LED_BUILTIN, LOW);
  printPTCregs(base, datas, numregs);

  for (uint8_t i=0; i<numregs; i++) {
  //  Serial.print("$"); Serial.print(addr+i, HEX); Serial.print("\t0x");
  //  printHex(datas[i]); Serial.println();
  }

}

// Print a hex with leading zero
void Adafruit_FreeTouch::printHex(uint8_t h, boolean newline) {
  if (h < 0x10) Serial.print("0");
  Serial.print(h, HEX);
  if (newline)  Serial.println();
}

void Adafruit_FreeTouch::printPTCregs(uint32_t base, uint8_t *regs, uint8_t num) {
  Serial.println("--------------------------------------------------------");
  for (uint8_t i=0; i<num; i++) {
      switch (i + base) {
        case 0x41004430:  Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" PMUX0:\t\t0x"); printHex(regs[i], true); break;
        case 0x41004431:  Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" PMUX1:\t\t0x"); printHex(regs[i], true); break;
        case 0x41004432:  Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" PMUX2:\t\t0x"); printHex(regs[i], true); break;
        case 0x41004433:  Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" PMUX3:\t\t0x"); printHex(regs[i], true); break;

        case 0x41004440:  Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" PCFG0:\t\t0x"); printHex(regs[i], true); break;
        case 0x41004441:  Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" PCFG1:\t\t0x"); printHex(regs[i], true); break;
        case 0x41004442:  Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" PCFG2:\t\t0x"); printHex(regs[i], true); break;
        case 0x41004443:  Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" PCFG3:\t\t0x"); printHex(regs[i], true); break;
        case 0x41004444:  Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" PCFG4:\t\t0x"); printHex(regs[i], true); break;


        case 0x42004C00: Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" Control A:\t\t0x"); printHex(regs[i], true); break;
        case 0x42004C01: Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" Sync:     \t\t0x"); printHex(regs[i], true); break;
        case 0x42004C04: Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" Prescaler:\t\t0x"); printHex(regs[i], true); break;
        case 0x42004C05: Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" Init:     \t\t0x"); printHex(regs[i], true); break;
        case 0x42004C08: Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" Disable Irq:\t\t0x"); printHex(regs[i], true); break;
        case 0x42004C09: Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" Enable Irq:\t\t0x"); printHex(regs[i], true); break;
        case 0x42004C0A: Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" Flags:     \t\t0x"); printHex(regs[i], true); break;
        case 0x42004C0C: Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" Freq Cntl:\t\t0x"); printHex(regs[i], true); break;
        case 0x42004C0D: Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" Conv Cntl:\t\t0x"); printHex(regs[i], true); break;
        case 0x42004C10: Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" Y Select1:\t\t0x"); printHex(regs[i], true); break;
        case 0x42004C11: Serial.print("0x"); Serial.print(i+0x42004C00, HEX);
          Serial.print(" Y Select2:\t\t0x"); printHex(regs[i], true); break;
/*
        case 0x42004C12: Serial.print("0x"); Serial.print(i+0x42004C00, HEX);
          Serial.print(" X Select1:\t\t0x"); printHex(regs[i], true); break;
        case 0x42004C13: Serial.print("0x"); Serial.print(i+0x42004C00, HEX);
          Serial.print(" X Select2:\t\t0x"); printHex(regs[i], true); break;
*/
        case 0x42004C14: Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" Y Enable1:\t\t0x"); printHex(regs[i], true); break;
        case 0x42004C15: Serial.print("0x"); Serial.print(i+0x42004C00, HEX);
          Serial.print(" Y Enable2:\t\t0x"); printHex(regs[i], true); break;
/*
        case 0x42004C16: Serial.print("0x"); Serial.print(i+0x42004C00, HEX);
          Serial.print(" X Enable1:\t\t0x"); printHex(regs[i], true); break;
        case 0x42004C17: Serial.print("0x"); Serial.print(i+0x42004C00, HEX);
          Serial.print(" X Enable2:\t\t0x"); printHex(regs[i], true); break;
*/
        case 0x42004C18: Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" Compcap L:\t\t0x"); printHex(regs[i], true); break;
        case 0x42004C19: Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" Compcap H:\t\t0x"); printHex(regs[i], true); break;
        case 0x42004C1A: Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" Intcap:   \t\t0x"); printHex(regs[i], true); break;
        case 0x42004C1B: Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" Sense res:\t\t0x"); printHex(regs[i], true); break;
        case 0x42004C1C: Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" Result L:\t\t0x"); printHex(regs[i], true); break;
        case 0x42004C1D: Serial.print("0x"); Serial.print(i+base, HEX);
          Serial.print(" Result H:\t\t0x"); printHex(regs[i], true); break;

       }
  }
}