Cómo funciona el sistema táctil de una pantalla

Los dispositivos móviles táctiles llegaron para quedarse hace años. Y no sólo eso, sino que cada vez son más y más complejos, con más sensores, hardware más potente y un largo etcétera.

Sin embargo, no todo el mundo conoce cómo funciona realmente por dentro, incluso en los componentes que tan habituales son para nosotros como es el ejemplo de la pantalla táctil, un elemento crucial en su evolución para que los dispositivos táctiles se asentaran con el éxito que lo han hecho. De hecho, han pasado de ser habituales a fundamentales, sobre todo cuando se trata de la interfaz más intuitiva de todas para las personas: tocar las cosas.

Hace un tiempo ya os hablábamos sobre Atmel MaxTouch, así son los sensores táctiles de tu móvil, un sensor específico utilizado por algunos modelos. Sin embargo, eso no responde a la pregunta que realmente hoy nos planteamos aquí: ¿cómo funcionan realmente la tecnología táctil? Veamos paso a paso cómo funciona, desde que el usuario toca la pantalla, hasta que ésta muestra un resultado.

Recopilando los gestos: el panel táctil capacitivo

El hecho de que la tecnología táctil haya llegado a ser una realidad radica en que fue posible encontrar un ecosistema donde hardware y software podían llegar a responder ante una señal táctil. Todo ello empieza en el panel táctil, que es el componente físico que toca el usuario. Es este elemento el que debe ser capaz de recoger la señal que transmite el usuario a través de sus dedos.

Seguramente habréis oído hablar sobre tecnología táctil capacitiva, la cual es la más extendida actualmente. En este tipo de tecnología, se utiliza la teoría de los campos y ondas eléctricas, las cuales se proyectan fuera de la superficie de contacto cuando un dedo está en contacto con ella, provocando una distorsión del campo eléctrico. Así, el panel podrá tener un determinado puntos de nodos de contacto, los cuales comprueban sus campos con cierta tasa de refresco (estos valores ya varían según la tecnología concreta empleada -normalmente entre 60 Hz y 120 Hz-).

Entonces, entra en juego la recopilación de datos, de forma que podemos transformar dichas distorsiones en coordenadas X-Y, aparte de otros parámetros. Además, el panel táctil deberá hacerse cargo de reducir el ruido (lo que nuestra señal ha variado debido a componentes que también distorsionan la información), para que los resultados sean lo más precisos posible. Si en algún momento la señal contiene mucho ruido, el panel es lo suficientemente inteligente como para escanear de nuevo los datos.

Aquí entra en juego el concepto de tasa de respuesta táctil, que consiste en la velocidad con que el dispositivo es capaz de interpretar las veces que tocamos la pantalla. Cuanto mejor sea dicha tasa, menor será la latencia del sistema, que es el tiempo de respuesta del sistema ante nuestra señal táctil.

De esta forma, el panel sabe en qué punto se está estableciendo un contacto y en qué momento, con la mayor exactitud posible.

Pasando los datos hasta el sistema operativo: el driver táctil

Una vez tenemos los datos como una recopilación de coordenadas y otros parámetros, ahora es necesario establecer una comunicación con el sistema operativo, de tal forma que éste pueda recibir dicha información para ya trabajar según convenga. Para ello, entra en juego el driver táctil, el cual recibe los datos del panel táctil y publica esta serie de eventos táctiles hacia el sistema operativo a través de una cola de eventos de entrada.

Dicho driver también puede presentar una latencia, consecuencia del bus (cable) de datos, lectura de los datos, ensamblado de los datos previo al envío… Por tener un latencia de referencia, se considera razonable una latencia de 2 a 3 ms para un único gesto con un sólo dedo. En el caso de paneles multitouch (con varios dedos a la vez), la latencia se ve incrementada.

Gestionando los eventos táctiles: el Choreographer de Jelly Beans

A partir de este punto, el panel y el driver han realizado su trabajo y es turno del sistema operativo. En nuestro caso, Android deberá ir leyendo los diferentes eventos táctiles que vienen ordenados para poder procesarlos a un alto nivel.  Esta interpretación, con vistas a reducir al máximo la latencia, suele venir definida por el patrón del observador, el cual consiste en que tenemos unos observadores que saben interpretar los eventos, los cuales están en estado de reposo hasta que un evento es disparado.

Google para ello introdujo Choreographer en la versión 4.3 (Jelly Beans), el cual iba principalmente orientada a maximizar la suavidad en Android, pues hasta entonces era notorio la diferencia con respecto a otros sistemas operativos.  Dicha entidad sirve para sincronizar la señal táctil y distribuir correctamente el evento hacia el sistema operativo. Y desde entonces, la suavidad en la pantalla ha sido uno de los grandes avances en nuestros dispositivos Android. De esta forma, las aplicaciones pueden ganar tiempo para realizar el procesamiento del evento y mostrar el resultado sobre la pantalla.

Una vez conseguido esto, la aplicación debe gestionar los diferentes eventos, registrando sólo aquellos que quiera en cada momento. En este punto ya será el sistema operativo quién pueda notificar a cada aplicación los eventos disponibles, y ésta la que ignorará o procesará dicho evento según desee el desarrollador de la app.

Mostrando los resultados: la composición de gráficos y la pantalla

Tan pronto como la app procese el evento, las consecuencias deben ser mostradas en pantalla. Para ello, la aplicación invalida lo que actualmente muestra la pantalla, requiriendo de esta forma que la pantalla vuelva a mostrar el contenido de nuevo tras ser actualizado. En este punto, entra en juego el framework de composición de gráficos, el cual es el encargado de repintar la pantalla con todas las capas de contenido visibles, de tal forma que sean formadas en una única capa y mostrada por pantalla.

Según la configuración del sistema, este punto podría hacerse tanto por hardware como por software, pero en el caso de Android es hecho vía software gracias a SurfaceFlinger, el cual permite componer los gráficos tal como describimos, para posteriormente delegar en el kernel, el cual compondrá la imagen basándose en el marco proporcionado por SurfaceFlinger, así como con el tamaño ya adecuado a nuestra pantalla.

Una vez los datos están listos, toda la información se enviará a la pantalla táctil, la cual se encargará de mostrar el resultado sin importar de la tecnología utilizada (por ejemplo, LCD o OLED).

Para finalizar, en la siguiente imagen podríamos ver un esquema sobre todo el proceso que acabamos de mostraros, para el caso concreto de Android:

Con esto, ya somos ser más conscientes de qué está pasando en nuestro dispositivo táctil cuando lo tocamos, de forma que podamos entender un poco mejor ese dispositivo al que solemos dedicar tanto tiempo.

Más información | Sony Mobile Developer: Series 1 – Series 2