cpu/xmega/include/cpu/touch/resistive/touch.h

Go to the documentation of this file.

#ifndef CPU_TOUCH_H
#define CPU_TOUCH_H

#include <compiler.h>
#include <stdint.h>
#include <gpio.h>
#include <pmic.h>
#include <regs/xmega_adc.h>
#include <regs/xmega_portcfg.h>

#define TOUCH_XL_MASK         (1U << CONFIG_TOUCH_XL_PIN)
#define TOUCH_XR_MASK         (1U << CONFIG_TOUCH_XR_PIN)
#define TOUCH_YD_MASK         (1U << CONFIG_TOUCH_YD_PIN)
#define TOUCH_YU_MASK         (1U << CONFIG_TOUCH_YU_PIN)
#define TOUCH_X_MASK          (TOUCH_XL_MASK | TOUCH_XR_MASK)
#define TOUCH_Y_MASK          (TOUCH_YD_MASK | TOUCH_YU_MASK)


__always_inline static void touch_priv_port_init(void)
{
        // Mask touch detection pins for interrupt.
        port_write_reg(CONFIG_TOUCH_PORT_BASE, INT0MASK, TOUCH_Y_MASK);

        /* Set Y pin output for voltage gradient. This configuration
         * is not ever changed by any of the other functions.
         */
        port_write_reg(CONFIG_TOUCH_PORT_BASE, OUTCLR, TOUCH_YD_MASK);
        port_write_reg(CONFIG_TOUCH_PORT_BASE, OUTSET, TOUCH_YU_MASK);
}


__always_inline static void touch_priv_port_enable_int(void)
{
        uint8_t int_bits;

        // Set level for interrupt type 0 on touch port as configured.
        int_bits = port_read_reg(CONFIG_TOUCH_PORT_BASE, INTCTRL);
        int_bits = PORT_BFINS(INTCTRL_INT0LVL, CONFIG_TOUCH_PORT_INTLVL,
                        int_bits);
        port_write_reg(CONFIG_TOUCH_PORT_BASE, INTCTRL, int_bits);
}


__always_inline static void touch_priv_port_disable_int(void)
{
        uint8_t int_bits;

        // Set level for interrupt type 0 on touch port to OFF.
        int_bits = port_read_reg(CONFIG_TOUCH_PORT_BASE, INTCTRL);
        int_bits = PORT_BFINS(INTCTRL_INT0LVL, PMIC_INTLVL_OFF, int_bits);
        port_write_reg(CONFIG_TOUCH_PORT_BASE, INTCTRL, int_bits);
}


__always_inline static bool touch_priv_port_is_int_flag_set(void)
{
        uint8_t int_flags;

        // Read out and check state of interrupt type 0 flag.
        int_flags = port_read_reg(CONFIG_TOUCH_PORT_BASE, INTFLAGS);
        int_flags &= PORT_BIT(INTFLAGS_INT0IF);

        return (int_flags != 0);
}


__always_inline static void touch_priv_port_clear_int_flag(void)
{
        port_write_reg(CONFIG_TOUCH_PORT_BASE, INTFLAGS, PORT_BIT(INTFLAGS_INT0IF));
}


__always_inline static void touch_priv_port_set_detection(void)
{
        // Set YD and YU as inputs with totem pull-up and low level sensing.
        portcfg_write_reg(PORTCFG_BASE, MPCMASK, TOUCH_Y_MASK);
        port_write_reg(CONFIG_TOUCH_PORT_BASE, PIN0CTRL,
                        PORT_BF(PINCTRL_OPC, PORT_PINCTRL_PULLUP)
                        | PORT_BF(PINCTRL_ISC, PORT_PINCTRL_ISC_LEVEL));
        port_write_reg(CONFIG_TOUCH_PORT_BASE, DIRCLR, TOUCH_Y_MASK);

        // Drive XL and XR pins to ground.
        port_write_reg(CONFIG_TOUCH_PORT_BASE, OUTCLR, TOUCH_X_MASK);
        port_write_reg(CONFIG_TOUCH_PORT_BASE, DIRSET, TOUCH_X_MASK);
}


__always_inline static void touch_priv_port_set_gradient_x(void)
{
        // Set surface Y pins as tri-stated inputs.
        portcfg_write_reg(PORTCFG_BASE, MPCMASK, TOUCH_Y_MASK);
        port_write_reg(CONFIG_TOUCH_PORT_BASE, PIN0CTRL,
                        PORT_BF(PINCTRL_OPC, PORT_PINCTRL_TOTEM));
        port_write_reg(CONFIG_TOUCH_PORT_BASE, DIRCLR, TOUCH_Y_MASK);

        // Drive XR to VCC, set XL and XR as outputs to create gradient.
        port_write_reg(CONFIG_TOUCH_PORT_BASE, OUTSET, TOUCH_XR_MASK);
        port_write_reg(CONFIG_TOUCH_PORT_BASE, DIRSET, TOUCH_X_MASK);
}


__always_inline static void touch_priv_port_set_gradient_y(void)
{
        // Set surface X pins as tri-stated inputs.
        portcfg_write_reg(PORTCFG_BASE, MPCMASK, TOUCH_X_MASK);
        port_write_reg(CONFIG_TOUCH_PORT_BASE, PIN0CTRL,
                        PORT_BF(PINCTRL_OPC, PORT_PINCTRL_TOTEM));
        port_write_reg(CONFIG_TOUCH_PORT_BASE, DIRCLR, TOUCH_X_MASK);

        // Set YD and YU as outputs to create voltage gradient.
        port_write_reg(CONFIG_TOUCH_PORT_BASE, DIRSET, TOUCH_Y_MASK);
}


__always_inline static void touch_priv_adc_init(void)
{
        // Set 12 bit resolution, maximum prescaling and VCC/1.6 as reference.
        adc_write_reg(CONFIG_TOUCH_ADC_BASE, CTRLB,
                        ADC_BF(RESOLUTION, ADC_RESOLUTION_12BIT));
        adc_write_reg(CONFIG_TOUCH_ADC_BASE, PRESCALER,
                        ADC_BF(PRESCALER, ADC_PRESCALER_DIV512));
        adc_write_reg(CONFIG_TOUCH_ADC_BASE, REFCTRL,
                        ADC_BF(REFSEL, ADC_REFSEL_INTVCC));

        // Set ADC channel 0 and 1 to single ended input mode.
        adcch_write_reg(CONFIG_TOUCH_ADC_BASE, CH0, CTRL,
                        ADCCH_BF(INPUTMODE, ADCCH_INPUTMODE_SINGLEENDED));
        adcch_write_reg(CONFIG_TOUCH_ADC_BASE, CH1, CTRL,
                        ADCCH_BF(INPUTMODE, ADCCH_INPUTMODE_SINGLEENDED));

        // Enable the ADC.
        adc_write_reg(CONFIG_TOUCH_ADC_BASE, CTRLA, ADC_BIT(ENABLE));
}


__always_inline static void touch_priv_adc_enable_int(void)
{
        adcch_write_reg(CONFIG_TOUCH_ADC_BASE, CH1, INTCTRL,
                        ADCCH_BF(INTLVL, CONFIG_TOUCH_ADC_INTLVL));
}


__always_inline static void touch_priv_adc_disable_int(void)
{
        adcch_write_reg(CONFIG_TOUCH_ADC_BASE, CH1, INTCTRL,
                        ADCCH_BF(INTLVL, ADCCH_INTLVL_OFF));
}


__always_inline static void touch_priv_adc_clear_int_flag(void)
{
        adc_write_reg(CONFIG_TOUCH_ADC_BASE, INTFLAGS, ADC_BIT(CH1IF));
}


__always_inline static void touch_priv_adc_set_surface_y(void)
{
        adcch_write_reg(CONFIG_TOUCH_ADC_BASE, CH0, MUXCTRL,
                        ADCCH_BF(MUXPOS, CONFIG_TOUCH_XL_PIN));
        adcch_write_reg(CONFIG_TOUCH_ADC_BASE, CH1, MUXCTRL,
                        ADCCH_BF(MUXPOS, CONFIG_TOUCH_XR_PIN));
}


__always_inline static void touch_priv_adc_set_surface_x(void)
{
        adcch_write_reg(CONFIG_TOUCH_ADC_BASE, CH0, MUXCTRL,
                        ADCCH_BF(MUXPOS, CONFIG_TOUCH_YD_PIN));
        adcch_write_reg(CONFIG_TOUCH_ADC_BASE, CH1, MUXCTRL,
                        ADCCH_BF(MUXPOS, CONFIG_TOUCH_YU_PIN));
}


__always_inline static void touch_priv_adc_start(void)
{
        adc_write_reg(CONFIG_TOUCH_ADC_BASE, CTRLA,
                        ADC_BF(CHSTART, ADC_CHSTART_0 | ADC_CHSTART_1)
                        | ADC_BIT(ENABLE));
}


__always_inline static uint16_t touch_priv_adc_get_x(void)
{
        uint16_t adc_result;

        // Read CH0 result, add CH1 result and divide by two.
        adc_result = adc_read_reg(CONFIG_TOUCH_ADC_BASE, CH0RESL);
        adc_result |= adc_read_reg(CONFIG_TOUCH_ADC_BASE, CH0RESH) << 8;
        adc_result += adc_read_reg(CONFIG_TOUCH_ADC_BASE, CH1RESL);
        adc_result += adc_read_reg(CONFIG_TOUCH_ADC_BASE, CH1RESH) << 8;

        // Divide by two to get the mean.
        adc_result >>= 1;

        return (adc_result);
}


#define touch_priv_adc_get_y       touch_priv_adc_get_x


#endif /* CPU_TOUCH_H */

---