Touch sensing screens have added a lot of functionality to handheld devices. They can also save your (battery) life.
Despite great progress in designing low-energy systems over the last few years — higher battery energy densities, electronics consuming less power, and more elaborate active power management — the most common user complaint is still that devices never last long enough without needing a charge.
Many of these modern low-power devices use touch sensing, a well-accepted technology for both present- and next-generation designs. The controllers that interfaced to them used to be clumsy, cumbersome, and in need of constant calibration.
A new generation of algorithms and approaches has changed all that. As a result, users of modern-generation devices can expect clean, reliable, and well-implemented touch systems.
The marriage of low-power electronics to touch systems is the next challenge, reducing energy use without compromising functionality. This article discusses how to design and implement low-energy touch systems that extend battery life and usability for next-generation designs.
Transparent versus opaque
Touch sensing technology can be broken down into two main categories: transparent and opaque. The transparent technology we are familiar with on tablets and phones is on top of an LCD screen and typically based on analog resistive or capacitive touch technology.
Figure 1: Materials such as indium tin oxide change resistance when stretched by touch.
With analog resistive sensors, conductive layers made of materials such as indium tin oxide change resistance when touched with pressure. By measuring a voltage at each axis, a position is determined (see Figure 1).
Most new designs use capacitive technology because of elastic degradation issues. The resistive-touch layer depends on the elasticity of the material and in time, wear can change the material characteristics.
Capacitive sensors similarly measure position, but by using adjacent electrodes. The change in capacitance of a conductive object (like a finger) placed over an insulated electrode can be sensed and used to determine position.
The opaque touch sensors are typically capacitive as well. A button can be as simple as a large PCB pad, but for sliders and rings, an array of copper surfaces is used to detect position by capacitive measurements between these elements.
Low-cost, rugged, and waterproof designs can take advantage of opaque sensors to implement advanced user interfaces that are tough, resilient, and durable. Even LCD-based tablets and phones can take advantage of opaque sensors to implement hard-wired touch zones which do not take away from the display area.
Architecting for low energy
Regardless of the technology, the system must be constructed to use energy management schemes wisely. Just putting the microcontroller to sleep will not cut it. A touch event may be needed to wake up the system.
Usually, systems designers have a choice whether to use interrupts or polling to wake up a microcontroller that is in a low-energy sleep mode, but that is not the case with capacitive touch systems.
With capacitive touch systems, the sensed capacitance through a protective coating changes a time constant for either a timer or an oscillator. As a result, a gated counter must be used to generate a threshold for use in determining a press. Since you do not want to add external logic, this must be done in the microcontroller, which means it is typically not completely asleep.
Coupling this with the fact that small handheld units are typically space constrained, an ideal solution is a single-chip microcontroller with all the hardware resources necessary to do the sensing and processing on the chip.
Most touch sensing designs will need a stable current source to charge the sense capacitors, an analog multiplexer to route the appropriate element to the ADC or analog comparator, a timer or counter, and an ability to discharge the capacitor.
In addition, the processor should have good energy-saving modes and features, especially if it is functioning as more than just a dedicated touch screen controller.
In other words, if one efficient, low-power microcontroller has the horsepower to do the touch screen processing and the main functions of the device, it is generally better than designing a dual-processor system.
One company that has made inroads into touch controller technology is Cypress Semiconductor, which has the Programmable System-on-Chip technology (PSoC). The PSoC® system is a family of embedded, mixed-signal devices featuring the company's M8C core processor. These Harvard-architected controllers run at speeds up to 24 MHz, achieving 4-MIPS performance.
The rich mix of digital and analog resources (especially analog multiplexing) makes it an ideal candidate for low-power touch-screen control (see Figure 2). The family spans from 8 K to 32 K flash with up to 2 K of RAM in 16-pin to 48-pin packages. The 1.8 V to 5 V power range can also help minimize power draw and match up to battery levels directly.
Figure 2: The PSoC analog multiplexers and current source play a key role in allowing precise touch-sensing applications.
The performance levels are not bad either. For example, the CY8C20xx6A family features up to 33 CapSense® I/Os and six sliders with native I²C, SPI, and USB. Slide sensor sensitivity can be adjusted and interpolated resolutions up to one part in 64 K can be achieved. Both successive-approximation and sigma-delta conversion techniques can be used. Sensing proximity through up to 15-mm glass overlays is possible, allowing more rugged protection for fragile LCDs.
Power wise, applications using this technology can typically run on as little as 1 μA of sleep current, and 1-4 mA during runtime. Design support through the company's free downloadable PSoC Designer™ Integrated Design Environment features a graphic resource configuration utility, as well as a free C compiler (and assembler) with a built-in debugger and ICE support.
Less power, Scotty
For some demanding designs, more processing horsepower is needed with less energy use. A different thought process takes hold here. Both hardware and software blocks take on new relationships as a solution is designed to be low power.
Energy Micro's Gecko family of ARM® Cortex™-M3-based processors is packed with architectural constructs and resources that dramatically reduce the operating power for a next generation of battery-powered and handheld devices. Instead of just a couple of low-power modes, the EFM32 family has five that each allow significant levels of functionality with reduced power consumption.
What makes the Gecko really stand out is how the core can be put to sleep while autonomous functions can still take place using very low power. A unique Reflex Bus architecture (see Figure 3) allows state machine-based interactions to be set up, so that entire sequences of events can take place and be processed without the microcore being awake.
For example, in energy mode 2, the LCD, real-time clock, pulse counter, watchdog timer, UART, I2C, and analog comparators can all be actively running and monitoring the outside world, while the core and flash are in a static-off state (retaining all register and setup values).
Figure 3: The Peripheral Reflex System in the EFM32 microcontrollers makes it possible to directly connect one peripheral to another without involving the CPU. This system enables a peripheral to produce signals that other peripherals can consume and instantly react to while the CPU is sleeping.
In this mode, the system consumes 0.9 μA and will wake up in 2 μs to fully active mode where it consumes 180 μA/MHz. Because of the rich peripheral resources on-chip, and the low-power active processing, this same approach can be used to implement a very low-power capacitive touch system with enough horsepower left over to be the system processor.
The next step forward
In addition to the Reflex Bus, Energy Micro also implements a Low Energy Sensor Interface (LESENSE) that reduces energy use even more. By moving the timer functionality into energy mode 2, the part can perform gated counter functions though a comparator.
This allows the core to remain asleep while a free-running RC relaxation oscillator feeds an array of up to 16 capacitive sensor inputs (see Figure 4).
A user-adjustable feedback resistor can control the charge rate of the capacitive sensors to further tune the power lower when slower polling can be used.
Figure 4: The low-power relaxation oscillator uses the touch capacitor elements as a source for its frequency. A lower-frequency shift indicates a capacitive element, such as a finger, is in close proximity to the sensor pad.
The comparator output drives the internal switches to select references that control the capacitance charge rate as well. The oscillating voltage then generates a frequency waveform which is gated to produce a frequency that indicates if there is a finger (or capacitive object) in proximity. A decreased frequency occurs when a large capacitance (finger) is in proximity to the pad, which trips the digital threshold detector and wakes up the core (see Figure 5).
Figure 5: A relaxation oscillator is formed by setting voltage thresholds for the capacitive waveform.
Setting the numbers
The PCB layout for opaque sensors depends on parallel copper distances and tight spacing. The capacitance is only one factor though; there are actually five factors that effect the oscillations. In addition to PCB capacitance (C), there is series resistance, the upper threshold voltage setting, and the lower threshold voltage setting. The supply voltage can also affect the frequency.
The period (T) that the capacitor takes to charge between VTL and VTH is given by:
T = RC x ln ((Vdd - VTL ) / (Vdd - VTH ))
The discharge period between VTH and VTL is the same as the charge time, so the oscillation frequency is given by:
F = 1 / (2 x T) (2.3)
This lets the designer dictate how many oscillations will occur within a specific timeframe. Adjusting the LESENSE threshold to the right number will then wake up the microcontroller.
Another factor to consider is that large PCB sensors are more sensitive to larger objects like a hand. You can increase sensitivity by removing the ground plane, but you become more sensitive to EMI and noise. A middle-of-the-road approach is to leave space between a sensor and a surrounding ground plane, so the field lines are directed toward the user.
Put it to the test
Fortunately, there is a development board from Energy Micro that implements a capacitive touch sensor, and some additional lowenergy- sensing circuits.
The Tiny Gecko Starter Kit is a USB-programmable ARM Cortex-M3 (EFM32TG840F32) demonstration and development kit. It contains an energy monitor to measure and verify the low-power operations in USB or battery modes.
In addition to the directly-driven 8x20-segment LCD, buttons, and user LED, the Tiny Gecko Starter Kit also contains a touch capacitive slider and software to implement a very low-power touch interface. Other sensors present are resistive, light-level, metal-inductive sensors which can also operate while the microcontroller is asleep.
Where to start
The Hotenda website is the ideal place to start a new design. The site includes suppliers, datasheets, tutorials, and training information to get you up to speed quickly with all the devices you need.
Several OEM solutions are available from stock to satisfy many touch systems requirements. A variety of standard-sized analog resistive touch screens and capacitive touch screens are available for several designs right out of the box.
Even the touch screen controllers are available from OEM suppliers and do a good job to satisfy many applications. For example, the 3M™ MicroTouch™ Series controllers provide a wide range of supported touch devices for different sized capacitive touch screens. Its ASIC-based controller typically draws 500 μA of sleep current, but takes typically 75 to 85 mA during operation. This is an ideal solution for power-insensitive applications such as POS systems, gaming machines, industrial systems, and kiosks.
Small, low-power handheld systems cannot typically use canned solutions. The size constraints, cost constraints, and power constraints will not line up with the demands of handheld users.