Archivo de la categoría: Hardware

Comprendiendo Variables al programar en C

Este es un análisis de la naturaleza y el uso de las variables en lenguaje C en el contexto de las aplicaciones para microcontroladores

Muchos de nosotros escuchamos la palabra “variable” en las clases de matemáticas mucho antes de saber mucho, si es que sabemos algo, acerca de la programación de computadoras. Una variable matemática es una cantidad cuyo valor no se conoce o no se limita a un número. Este uso es similar, aunque no idéntico, al concepto de una variable C.

Dos diferencias importantes: primero, en matemáticas, usualmente usamos una letra como x o y para representar una variable, mientras que en C usamos frecuentemente una palabra o frase descriptiva como contadorPulsos, velocidadMedia o cantidadVueltas. En segundo lugar, hay situaciones en las que usamos una variable de C para identificar una cantidad conocida y que no se pretende que cambie del valor original.

Variables en hardware

Las variables son convenientes e intuitivas para los programadores. Para el hardware computacional, por otro lado, no tienen un significado real. Los microprocesadores almacenan datos en registros y ubicaciones de memoria. Esta diferencia fundamental entre las personas que escriben el idioma de máquina y las máquinas que ejecutan este programa se supera mediante lenguajes de alto nivel como C, que maneja varios detalles asociados con la traducción entre variables basadas en texto y la realidad física de un procesador.

Los diseñadores de sistemas integrados trabajan a menudo con procesadores de 8 bits. En estos dispositivos, por lo general, el tamaño fundamental de los datos es un byte. La memoria se organiza de acuerdo con los bytes, el tamaño de los registros es de un byte y la CPU está diseñada para procesar datos de 8 bits. Esta es una limitación bastante incómoda porque hay muchas situaciones en las que el valor de una variable excederá el valor máximo de un número de 8 bits.

Finalmente, todas las variables C cuidadosamente definidas y con un nombre ilustrativo terminan como bits en la memoria (o registros)

El lenguaje C no limita el tamaño de una variable a 8 bits, incluso cuando está trabajando con un procesador de 8 bits. Esto significa que una variable en el programa en lenguaje de máquina que ejecuta el microprocesador puede corresponder a múltiples registros o ubicaciones de memoria en el hardware. “Manualmente” administrar variables de múltiples bytes (es decir, a través del lenguaje ensamblador) no parece muy deseable, pero a los compiladores no les importa en absoluto, y hacen el trabajo muy bien.

Definiendo variables

El primer paso para usar una variable es definir esa variable. Los componentes esenciales de una definición de variable son el tipo y el nombre.

Hay muchos tipos de variables; La lista completa, así como los detalles de la implementación del hardware, variarán según el compilador que esté utilizando. Aquí hay unos ejemplos:

char : un valor con signo de un byte
int : un valor con signo de dos o cuatro bytes
long : un valor con signo de cuatro bytes
float : un valor de cuatro bytes que puede tener números después del punto decimal; en otras palabras, no está limitado a enteros
bit : el valor de la variable puede ser cero o uno

Esta es una representación visual de cómo una serie de bits se interpreta de manera diferente en función de si una variable se considera con signo (utilizando la notación de complemento a dos) o sin signo:

El siguiente código muestra definiciones de variables que consisten solo en un tipo básico y un nombre (la forma más técnica de referirse al nombre es “identificador”):

Inicializando variables

En muchos casos, es una buena idea darle un valor inicial a una variable. Esto facilita la depuración y es esencial si la variable se utilizará antes de que le fije un valor conocido. Puede inicializar una variable en la definición, o en otra parte de su código, pero incluir el valor inicial en la definición es una buena manera de mantener el código organizado y desarrollar el hábito de inicializar siempre que sea necesario.

Aquí hay ejemplos de definiciones de variables que incluyen una inicialización:

Definiciones de variables delicadas

Hay varias otras palabras que se pueden incluir en una definición de variable. Estos se utilizan para especificar con mayor precisión la naturaleza de la variable o para dar instrucciones al compilador sobre cómo implementar la variable en el hardware.

Las siguientes palabras clave podrían ser útiles en sus proyectos de programa para microcontroladores:

■ unsigned : como habrá adivinado, esto le dice al compilador que interprete la variable como un valor sin signo en lugar de un valor con signo. Uno defino le mayoría de sus variables como sin signo, porque rara vez se necesitan números negativos.

■ const : el calificador de tipo const indica al compilador que el valor de una variable no debe cambiar. Como dice al principio del artículo, a veces el valor de una “variable” C no es variable. Si usted comete un error en su código e intenta modificar el valor de una variable const, el compilador generará un error.

■ volatile : los compiladores sofisticados no solo toman su código original y lo traducen directamente al lenguaje de máquina. También intentan hacer que el código funcione de manera más eficiente, y este proceso se conoce como “optimización”. En general, la optimización es algo bueno. Sin embargo, de vez en cuando, puede arruinar el día, porque el compilador se optimiza solo en función del código y no puede tener en cuenta los eventos de hardware que interactúan con el código. Cuando una variable tiene el calificador de tipo volátil, el compilador sabe que debe tener cuidado con las optimizaciones relacionadas con esa variable.

Una interrupción puede hacer que el valor de una variable se modifique de una manera que el compilador no espera, y esto puede llevar a una optimización problemática

■ tipos de memoria, como xdata , idata y code : estas palabras obligan al compilador a ubicar una variable en una parte específica de la memoria del microprocesador. El tipo que aloja en la memoria de programa es particularmente útil: los recursos de RAM en un microcontrolador a menudo son mucho más limitados que la memoria de programa no volátil, y el tipo de memoria de código le permite utilizar memoria de programa adicional para almacenar datos que se usan en su programa pero nunca se modifican.

Aquí hay unos ejemplos:

Uso de las variables

No hay mucho que decir acerca de cómo usar sus variables después de que se hayan definido. En realidad, con respecto a la variable en sí, la definición es la mayor parte del trabajo. Después de eso, usted simplemente incorpora el identificador de la variable en operaciones matemáticas, bucles, llamadas a funciones, etc. Un buen compilador no solo manejará los detalles de la implementación del hardware, sino que también buscará formas de optimizar el código con respecto a la velocidad de ejecución o el tamaño del programa.

Quizás el error más común relacionado con el uso variable es un desbordamiento. Esto se refiere a una situación en la que el valor asignado a una variable está fuera del rango numérico asociado con el tipo de datos de la variable.

Se debe pensar en todos los escenarios posibles relacionados con una variable determinada y luego elegir el tipo de datos en consecuencia.

Resumen

La funcionalidad de la variable básica proporcionada por el lenguaje C es intuitiva y directa, pero hay algunos detalles que pueden ayudarlo a hacer que una aplicación integrada sea más confiable y eficiente. Si tiene alguna duda relacionada con las variables de C, no dude en preguntar en nuestro grupo en Facebook Robots Didácticos.




Ampliar la cantidad de entradas de Arduino

Para expandir la capacidad de entradas digitales se utilizan registros de desplazamiento (Shift Register en inglés) con entradas en paralelo y salida serie.

Para este ejemplo, utilizamos tres pines digitales de la placa Arduino en conjunto con el circuito integrado 74HC165 (puede ser, también, 74LS165), que nos aportará 8 entradas.

Diagrama de pines:

Se pueden conectar varios de estos chips en cadena, lo que le nos aporta 16, 24, 32 o más entradas, sin usar ningún pin digital adicional de Arduino, simplemente conectando la salida QH de un registro a la entrada de datos serie SER del otro.

En el diagrama que sigue se ve cómo es la conexión completa de dos 74HC165. Los conjuntos de llaves de corredera, llamados DIP Switch en inglés, representan a las diversas entradas que se podrían ingresar. Si son llaves que se cierran (pulsadores, microswitches, relés, salidas de colector abierto), corresponde el circuito tal como se lo ve, con un resistor de polarización (pull-up) conectado a +5V. Si se trata de salidas digitales de otros chips y placas con salidas compatible con lógica TTL, no es necesario colocar el resistor.

Con línea de puntos se indica la conexión para continuar la cadena indefinidamente. La señal CLK (pata 2) va unida entre chips, e igual la señal SH/LD (pata 1), con la única salvedad de que hay que leer la hoja de datos del microcontrolador (según cuál sea) para saber cuántas entradas de este tipo de chip TTL HC se le pueden conectar a una salida digital de Arduino.

La tabla que sigue, y el diagrama interno del chip, los agrego para ofrecer más información y mejor comprensión del funcionamiento. Se pueden encontrar más detalles en su hoja de datos.

Diagrama de tiempo

La señal SH/LD se mantiene en ALTO durante las operaciones de desplazamiento. Un pulso a BAJO en este pin ingresa nuevos datos desde las entradas al registro de desplazamiento. Cuando el pulso vuelve a ALTO, queda todo dispuesto para aplicar pulsos de CLK y desplazar uno a uno los bits del registro hacia la salida serie QH. Si hemos usado un solo chip 74HC165, con 8 pulsos se habrán leído todas las entradas a través de QH (luego de haberlo conectado a una entrada digital del Arduino). Cada chip adicional requiere 8 pulsos más. En los programas se puede entender claramente cómo se ingresan los datos a variables dentro de nuestro microcontrolador.

Leer una de las entradas del 74HC165 – Diseño del programa:

■ Se aplica un pulso de alto a bajo y luego de regreso a alto en SH/LD, y así las entradas ingresan al registro de desplazamiento (condición “LOAD”, o de carga).

■ Aplicar a la salida CLK la cantidad de pulsos necesarios, desplazando los datos, para que el bit que deseamos leer quede ubicado en la línea de salida QH.

■ Leer el valor del pin digital de entrada del Arduino.

Primer programa de prueba

Este programa lee de a un pin e indica su estado en el LED incluido en el Arduino UNO, pin 13 = LED_BUILTIN. Para determinar qué entrada queremos leer para conocer su estado, se lo indicamos tipeando los números 1 a 8 desde el teclado de la computadora a la que esté conectado el Arduino por USB.

Incluso, usando comparaciones con IF se podría elegir como comando cualquier caracter. Puede ser “a”, “b”, “c”, o “A”, “B”, “C”, o lo que usted elija. Si la entrada proviene de sensores de puertas o ventanas abiertas, o de luces encendidas, se puede usar, por ejemplo, “C” para cocina, “B” para baño, “P” para pasillo, “p” para patio, “E” para entrada, “H” para una habitación y “h” para otra habitación. Y así. Además, estas letras de comando se pueden enviar a través de un módulo Bluetooth HC-06 o HC-05 y controlar desde el teléfono celular, recibiendo la respuesta por el mismo medio.

En este programa —para simplificar— se eligió tipear un número desde el teclado para leer cada entrada. Lo más interesante es la función que lee las entradas y las desplaza hacia la salida. Se le envía como parámetro un valor numérico y entero de 1 a 8, y devuelve un 1 o un 0 según el estado de la entrada. No es difícil ampliar el código hasta la cantidad de entradas que desee.

Agregando esta función a su programa, puede usarla del modo que usted quiera.

Utilizamos este circuito, que es el mismo que servirá para todos los programas excepto el de manejo por SPI, que requiere conectar dos señales del circuito a las entradas MOSI y SCLK de esta interfaz, como luego veremos.

Disculpen si tiene un aspecto un poco antiestético, pero ocurre que es difícil cablear un conjunto de llavecitas DIP al chip 74HC165 con el programa de dibujo sin hacer cruces de cables, y que sea todo visible. Ya verán en la foto que el circuito real, en la protoboard, quedó más prolijo.

Programa para leer de a una entrada

 


 
Segundo ejemplo: ingresar todas las entradas a variables

El siguiente programa permite listar en el Monitor Serie el estado de los pines de entrada del circuito del ejemplo, o de una cadena de chips para ampliar 16, 24, 32 o más entradas. Tampoco necesita biblioteca. El listado se actualiza cada vez que cambia una entrada. Los comentarios explican en detalle su funcionamiento.

El Monitor Serie mostrará este mensaje, y se renovará cada vez que se cambie el valor de una entrada.


 


 
Biblioteca ShiftIn

Esta es una biblioteca que permite leer 8 o más entradas. Y también, si bien la biblioteca tiene una función que define 4 pines, se pueden usar sólo 3 pines al Arduino. Además, se puede conectar en cadena varios registros de desplazamiento utilizando la misma cantidad de pines digitales, o sea 3. El cableado es con la misma configuración que en el diagrama de protoboard mostrado arriba.

Instalación fácil (importar zip)

La forma más fácil de instalar esta biblioteca es descargar la última versión y luego importarla. No tiene que descomprimirlo. Simplemente abra su IDE de Arduino y navegue a Programa > Incluir Librería > Añadir Biblioteca .ZIP… y luego seleccione el archivo zip, que puede bajar desde aquí.

Instalación manual

Por supuesto también se puede instalar esta biblioteca manualmente. Para hacerlo, descargue la versión más reciente y descomprímala. Luego tiene que copiar la carpeta ShiftIn (NO la carpeta ShiftIn-x.y.z) y colocarla en la carpeta de la biblioteca Arduino:

Windows: Documentos\Arduino\libraries\
Mac and Linux: Documents/Arduino/libraries/

Después de esto solo hay que reiniciar el IDE de Arduino.

Uso de ShiftIn

Si ha instalado esta biblioteca, puede incluirla navegando a Programa > Incluir Librería > ShiftIn. Esto agregará la línea #include <ShiftIn.h> a su programa (por supuesto, también puede escribir esta línea manualmente).

Ahora se puede usar esta biblioteca:

Los datos en el Monitor Serie se verán así:

Si usted necesita usar dos shift registers, sólo tiene que cambiar la declaración de ShiftIn<1> shift; a ShiftIn<2> shift;, y así sucesivamente.

El diagrama para 2 chips – 16 entradas es este:

Detalle de las funciones de la biblioteca ShiftIn

Dependiendo de la cantidad de chips, esta biblioteca utilizará diferentes tipos de datos. Si solo está utilizando un chip, el tipo ShiftType será un unsigned byte (uint8_t). Para dos chips será un unsigned int (uint16_t). Para tres o cuatro chips será un unsigned long (uint32_t) y para 5 a 8 chips será un unsigned long long (uint64_t). La biblioteca todavía no maneja más de ocho chips.

Esta función debe ser llamada en la función de configuración. Se utiliza para indicar a la biblioteca los pines que debe usar.

void begin(int ploadPin, int clockEnablePin, int dataPin, int clockPin)

GetPulseWidth() define el retardo para el pin de clock en microsegundos. Este valor está fijado en 5 us y en general no habrá necesidad de cambiarlo, aunque teniendo en cuenta el tiempo de programa transcurrido entre la ejecución de el inicio del pulso y de su final, puede ser tan pequeño como 1 us, incluso 0.

uint8_t getPulseWidth()
void setPulseWidth(uint8_t value)

Retorna la cantidad de entradas (bits en el estado)
uint16_t getDataWidth()

Retornan VERDADERO si ha cambiado alguna entrada durante la última lectura.
boolean hasChanged()
boolean hasChanged(int i) // lo mismo de arriba, pero solo para la entrada i

Retornan el estado completo del actual y el último grupo de bits
ShiftType getCurrent()
ShiftType getLast()

Retornan el estado de una sola entrada en el grupo actual de bits y el último grupo de bits
boolean state(int i)
boolean last(int i)

Indica cuando una entrada ha cambiado. En el ejemplo de los esquemas, se ha presionado o se ha soltado un pulsador
boolean pressed(int id) // no estaba presionado en la última lectura, pero ahora sí
boolean released(int id) // estaba presionado en la última lectura, pero ahora fue liberado

Esta función (la función para actualizar) debe ser llamada una vez por cada grupo de bits. Leerá todos los valores de los shift registers y retornará el nuevo estado.
ShiftType read()

Esta función es básicamente la misma que la función read, pero retorna VERDADERO si ha cambiado de estado alguna entrada, y FALSO en el caso contrario
boolean update()
 


 
Ingresando datos por SPI

Conectando el 74HC165 a la interfaz SPI se puede leer rápidamente 8 entradas digitales, ingresando los 8 bits en una sola instrucción de SPI. Se los puede encadenar para leer 16, 24, 32 o más entradas a la vez.

Podría usarse, por ejemplo, para examinar la configuración de un interruptor DIP de 8 interruptores (donde se fijaría la configuración del dispositivo).

En el 74HC165 se tiene que pulsar el pin de “cargar” (pin 1 del chip) para que el registro ingrese las entradas externas en sus registros internos.

La habilitación del chip, en esta prueba, es fija. El pin de activación de chip (/CLK INH) está a tierra, ya que el chip también puede funcionar estando siempre habilitado. Tenga en cuenta que la línea MISO siempre está activa, por lo que no es posible compartir este chip con otros dispositivos SPI utilizando el hardware SPI. Se puede solucionar agregando un circuito selector, pero no lo describiré en este artículo ya que si necesita usar otro dispositivo SPI, puede utilizar los otros ejemplos de programa, sin necesidad de SPI.

Código de programa

Es fácil de leer desde el registro. La biblioteca SPI se ocupará de todo.

Los pasos importantes son (dentro de la función de bucle):

1. Aplique un pulse al pin de carga paralela para cargar el registro desde las entradas.
2. Haga una transferencia SPI para leer el registro del chip.

Si desea leer más de 8 interruptores, simplemente use más registros, conecte en paralelo los pines 1, 2 y 15 de los chips, y la salida de cada chip “anterior” en la secuencia (QH) a la entrada del siguiente (SER).

Para leer cuatro bancos de interruptores, se cambia la sección de lectura del programa:

digitalWrite(LATCH, LOW);
digitalWrite(LATCH, HIGH);
bancoEntradas1 = SPI.transfer(0);
bancoEntradas2 = SPI.transfer(0);
bancoEntradas3 = SPI.transfer(0);
bancoEntradas4 = SPI.transfer(0);

NOTA: OBSERVE QUE HAY QUE CAMBIAR, EN EL DIAGRAMA DEL PROTOBOARD DE ARRIBA, LOS PINES QUE IBAN A SALIDA DIGITAL 11 Y SALIDA DIGITAL 12 DEL ARDUINO. LA CONEXIÓN QUE ESTABA EN 12 SE DEBE PASAR A 13, Y LA QUE ESTABA EN 11 SE DEBE PASAR A 12.

Resultados en Monitor Serie. Muestra una indicación del estado al inicio, y luego lista cada cambio que se produce en las entradas:


 


 
Otras opciones

Por último, existen dos librerías relacionadas, llamadas bitBangedSPI y bitBangedSPIfast, que permiten operar las múltiples entradas desde 74HC165 con un SPI implementado por software, y dejar libre el módulo SPI de hardware para otros dispositivos. Entiendo que es lo que hicimos con los programas de ejemplo anteriores, pero les dejo la inquietud de investigarlos y probarlos.


Uso de la EEPROM de Arduino

La memoria EEPROM (del inglés Electrically Erasable Programmable Read-Only Memory = ROM programable y borrable eléctricamente) es una memoria no volátil. Esto significa que los datos que almacena no se pierden al desaparecer la alimentación de un dispositivo.

La EEPROM fue pensada para mantener aquellos datos que deseamos resguardar luego de apagar y reiniciar un microcontrolador, y disponer de ellos al retomar la operación.

El ATmega328P —el microcontrolador del Arduino UNO, el Nano y otros de la línea Arduino— tiene una capacidad de 1.024 bytes (1 Kb) de memoria EEPROM. La hoja de datos nos indica que la EEPROM del ATmega328P acepta hasta 100.000 ciclos de lectura/escritura. Parece mucho, pero el solo hecho de tener una cantidad de ciclos de escritura acotada ya nos indica que su función no es en nada similar a una RAM. Es para guardar datos, y no en forma momentánea y veloz, sino de manera durable. No ponga nunca operaciones con la EEPROM dentro de la función loop(), ya que, dada la velocidad de trabajo del microcontrolador, llegará rápidamente al límite de 100.000.

Tengamos también en cuenta otro dato importante: una operación de escritura en la EEPROM requiere 3,3 ms para completarse frente a la velocidad miles de veces superior de la RAM, capaz de operar a 20 MHz.

Para acceder a la memoria EEPROM debemos usar la librería EEPROM disponible de manera estándar desde el IDE de Arduino. La biblioteca —o librería— se llama EEPROM.h, y se debe incluir al inicio del programa.

Funciones en la biblioteca EEPROM:

FUNCIÓN EEPROM.read()

Lee un byte de la posición de memoria que indica su parámetro. De fábrica, todas las posiciones de memoria tienen escrito el valor 255 (0xFF).

Sintaxis:

      EEPROM.read(direccion)

Parámetros:

direccion: la posición de memoria (de 0 a 1023 = 1024).

Ejemplo con EEPROM.read(), leer toda la EEPROM y mostrarla en Monitor Serie

FUNCIÓN EEPROM.write()

Esta función escribe un byte en la posición indicada de la EEPROM. Tiene dos parámetros: el primero es la dirección de memoria (de 0 a 1023) donde se escribirá el byte; el segundo es el valor que se va a escribir en la EEPROM, que debe ser un valor entero entre 0 y 255. La función no retorna ningún valor.

Sintaxis:

      EEPROM.write(direccion,valor)

Parámetros:

direccion: dirección en la memoria (de 0 a 1023)
valor: el valor a escribir en la memoria

Ejemplo: Escribir valores en un sector de la memoria

FUNCIÓN EEPROM.update()

Escribe un byte en la EEPROM. El valor es escrito solo si es diferente al valor que esta previamente almacenado en esa posición de memoria.

Sintaxis:

      EEPROM.update(direccion,valor)

Parámetros:

direccion: la dirección de la memoria (0 a 1023)
valor: el valor a escribir en la memoria




FUNCIÓN EEPROM.put()

Esta función escribe cualquier tipo de dato en la EEPROM. El valor es escrito solo si es diferente al valor que esta previamente almacenado en esa posición de memoria, por lo que es mucho más versátil.

Sintaxis:

      EEPROM.put(direccion,valor)

Parámetros:

direccion: dirección en la memoria (0 a 1023)
valor: valor a escribir en la memoria

Ejemplo: Guardar una variable tipo float en la memoria EEPROM

FUNCIÓN EEPROM.get()

Permite leer cualquier tipo de dato en la EEPROM.

Sintaxis:

      EEPROM.get(direccion,variable)

Parámetros:

direccion: dirección en la memoria (0 a 1023)
variable: el nombre de la variable donde guardaremos el valor leído de la memoria

Ejemplo: Leer un valor float

OPERADOR EEPROM[]

Este operador permite usar el identificador EEPROM[] como una matriz en la cual indicamos la dirección.

Sintaxis:

      EEPROM[direccion]

Parámetros:

direccion: dirección en la memoria (0 a 1023)

Ejemplo: Uso del operador EEPROM[]


Dando sentido del tacto a los robots

La tecnología GelSight permite a los robots medir la dureza de los objetos y manipular herramientas pequeñas

Hace ocho años, el grupo de investigación de Ted Adelson en el Laboratorio de Ciencias de la Computación e Inteligencia Artificial (CSAIL) de MIT reveló una nueva tecnología de sensores, llamada GelSight, que utiliza el contacto físico con un objeto para proporcionar un mapa tridimensional notablemente detallado de su superficie.

Ahora, al montar sensores GelSight en las pinzas de los brazos robóticos, dos equipos del MIT le han dado a los robots una mayor sensibilidad y destreza. Los investigadores presentaron su trabajo en dos artículos en la Conferencia Internacional sobre Robótica y Automatización.

En un artículo, el grupo de Adelson usa los datos del sensor GelSight para permitir que un robot juzgue la dureza de las superficies que toca, una habilidad crucial si los robots domésticos deben manejar objetos cotidianos.

En el otro, Robot Locomotion Group de Russ Tedrake en CSAIL utiliza sensores GelSight para permitir que un robot manipule objetos más pequeños de lo que era posible antes.

El sensor GelSight es, de alguna manera, una solución de baja tecnología para un problema difícil. Consiste en un bloque de elastómero transparente, el “gel” en el nombre de sensor, una cara del cual está recubierta con pintura metálica. Cuando la cara cubierta de pintura se presiona contra un objeto, se ajusta a la forma del objeto.

La pintura metálica hace que la superficie del objeto sea reflectiva, por lo que su geometría se vuelve mucho más fácil de inferir para los algoritmos de visión de computadora. Montados en el sensor opuesto a la cara recubierta de pintura del bloque elástico, hay tres luces de colores y una sola cámara.

“[El sistema] tiene luces de colores en diferentes ángulos, y luego tiene este material reflectivo, y al mirar los colores, la computadora … puede descubrir la forma 3D y qué es esa cosa”, explica Adelson, profesora de Ciencias de la Visión en el Departamento de Cerebro y Ciencias Cognitivas.

En ambos conjuntos de experimentos, se montó un sensor GelSight en un lado de una pinza robótica, un dispositivo parecido a la cabeza de una pinza pero con superficies de agarre planas en lugar de puntas puntiagudas.

Puntos de contacto

Para un robot autónomo, medir la suavidad o dureza de los objetos es esencial para decidir no solo dónde y qué tan difícil es agarrarlos, sino también cómo se comportarán cuando los mueva, apile o coloque en diferentes superficies. La detección táctil también podría ayudar a los robots a distinguir objetos que se ven parecidos.

En trabajos anteriores, los robots han intentado evaluar la dureza de los objetos colocándolos sobre una superficie plana y empujándolos suavemente para ver cuánto dan. Pero esta no es la principal forma en que los humanos miden la dureza. Más bien, nuestros juicios parecen basarse en el grado en que el área de contacto entre el objeto y nuestros dedos cambia a medida que lo presionamos. Los objetos más blandos tienden a aplanarse más, aumentando el área de contacto.

Los investigadores del MIT adoptaron el mismo criterio. Wenzhen Yuan, una estudiante graduada en ingeniería mecánica y primera autora del artículo del grupo de Adelson, usó moldes de confitería para crear 400 grupos de objetos de silicona, con 16 objetos por grupo. En cada grupo, los objetos tenían las mismas formas pero diferentes grados de dureza, que Yuan medía usando un instrumento industrial estándar.

Ella luego presionó un sensor GelSight contra cada objeto manualmente, y registró cómo iba cambiando el patrón de contacto, en esencia produciendo una corta película para cada objeto. Para estandarizar el formato de los datos y mantener el tamaño de los datos manejable, extrajo cinco cuadros de cada película, espaciados uniformemente en el tiempo, lo que describe la deformación del objeto que se presionó.

Finalmente, alimentó los datos a una red neuronal, que buscaba automáticamente las correlaciones entre los cambios en los patrones de contacto y las mediciones de dureza. El sistema resultante toma cuadros de video como entradas y produce un puntaje de dureza con una precisión muy alta. Yuan también realizó una serie de experimentos informales en los que sujetos humanos palparon frutas y verduras y los clasificaron según su dureza. En todos los casos, el robot equipado con GelSight llegó a las mismas conclusiones.

A Yuan se le unieron en el documento sus dos asesores de tesis, Adelson y Mandayam Srinivasan, investigador científico senior en el Departamento de Ingeniería Mecánica; Chenzhuo Zhu, estudiante de la Universidad de Tsinghua que visitó el grupo de Adelson el verano pasado; y Andrew Owens, quien realizó su doctorado en ingeniería eléctrica y ciencias de la computación en el MIT y ahora es postdoctorado en la Universidad de California en Berkeley.

Visión obstruida

El documento de Robot Locomotion Group nació de la experiencia del grupo con el Desafío de Robótica (DRC) de la Agencia de Proyectos de Investigación Avanzada de la Defensa, en el que equipos académicos y de la industria compitieron para desarrollar sistemas de control que guiarían a un robot humanoide a través de una serie de tareas relacionadas con una emergencia hipotética.

Normalmente, un robot autónomo utiliza algún tipo de sistema de visión por computadora para guiar su manipulación de objetos en su entorno. Dichos sistemas pueden proporcionar información muy confiable sobre la ubicación de un objeto, hasta que el robot recoge el objeto. Especialmente si el objeto es pequeño, gran parte de él será ocluido por la pinza del robot, lo que hace que la estimación de la ubicación sea mucho más difícil. Por lo tanto, exactamente en el punto en el que el robot necesita conocer la ubicación del objeto con precisión, su estimación se vuelve poco confiable. Este fue el problema al que se enfrentó el equipo de MIT durante el DRC, cuando su robot tuvo que levantar y encender un taladro eléctrico.




“Puedes ver en nuestro video para el DRC que pasamos dos o tres minutos encendiendo el taladro”, dice Greg Izatt, un estudiante graduado en ingeniería eléctrica y ciencias de la computación y primer autor del nuevo artículo. “Sería mucho mejor si tuviéramos una estimación precisa y actualizada de dónde se realizó ese ejercicio y dónde estaban nuestras manos en relación con él”.

Es por eso que Robot Locomotion Group se dirigió a GelSight. Izatt y sus coautores: Tedrake, el profesor de ingeniería eléctrica y ciencias de la computación de Toyota, aeronáutica y astronáutica, e ingeniería mecánica; Adelson; y Geronimo Mirano, otro estudiante graduado en el grupo de Tedrake, que diseñaron algoritmos de control que utilizan un sistema de visión computarizada para guiar la pinza del robot hacia una herramienta y luego pasar la estimación de la ubicación a un sensor GelSight una vez que el robot tiene la herramienta en mano.

En general, el desafío con este enfoque es reconciliar los datos producidos por un sistema de visión con los datos producidos por un sensor táctil. Pero GelSight se basa en una cámara, por lo que su salida de datos es mucho más fácil de integrar con datos visuales que los datos de otros sensores táctiles.

En los experimentos de Izatt, un robot con una pinza equipada con GelSight tuvo que agarrar un destornillador pequeño, sacarlo de una funda y volverlo a su lugar. Por supuesto, los datos del sensor GelSight no describen el destornillador completo, solo una pequeña parte de él. Pero Izatt descubrió que, mientras la estimación del sistema de visión de la posición inicial del destornillador era precisa en unos pocos centímetros, sus algoritmos podrían deducir qué parte del destornillador estaba tocando el sensor GelSight y así determinar la posición del destornillador en la mano del robot.

“Creo que la tecnología GelSight, así como otros sensores táctiles de gran ancho de banda, tendrán un gran impacto en la robótica”, dice Sergey Levine, profesor asistente de ingeniería eléctrica y ciencias de la computación en la Universidad de California en Berkeley. “Para los seres humanos, nuestro sentido del tacto es uno de los factores clave en nuestra sorprendente destreza manual. Los robots actuales carecen de este tipo de destreza y tienen una capacidad limitada para reaccionar a las características de la superficie cuando manipulan objetos. Si se imagina buscar un interruptor de luz en la oscuridad, extraer un objeto de su bolsillo o cualquiera de las otras muchas cosas que puede hacer sin siquiera pensar, todo se basa en la detección táctil.”

“El software finalmente está alcanzando las capacidades de nuestros sensores”, agrega Levine. “Los algoritmos de aprendizaje automático inspirados por las innovaciones en el aprendizaje profundo, y la visión por computadora puede procesar los ricos datos sensoriales de sensores como GelSight para deducir las propiedades de los objetos. En el futuro, veremos este tipo de métodos de aprendizaje incorporados en el entrenamiento de las habilidades de manipulación de inicio a final, que hará que nuestros robots sean más diestros y capaces, y tal vez nos ayuden a comprender algo sobre nuestro propio sentido del tacto y control motor”.

Artículos relacionados:

FlexShapeGripper: el agarre de la lengua de un camaleón


Usando electricidad y agua, un nuevo tipo de motor puede poner microrobots en movimiento

Los actuadores microhidráulicos, más delgados que un tercio del ancho del cabello humano, están demostrando ser los motores más potentes y eficientes a microescala.

Mire a su alrededor y probablemente verá algo que funciona con un motor eléctrico. Potentes y eficientes, mantienen gran parte de nuestro mundo en movimiento, desde nuestras computadoras hasta refrigeradores y ventanas automáticas en nuestros autos. Pero estas cualidades se hacen difíciles cuando estos motores se reducen a tamaños más pequeños que un centímetro cúbico.

“A escalas muy pequeñas, se obtiene un calentador en lugar de un motor”, dijo Jakub Kedzierski, personal del Grupo de Tecnologías de Química, Microsistema y Nanoescala del Laboratorio Lincoln del MIT. Hoy en día, no existe ningún motor que sea altamente eficiente y poderoso a la vez que microscópico. Y eso es un problema, porque los motores a esa escala son necesarios para poner en movimiento los sistemas miniaturizados: micro guías que pueden apuntar los láseres con una fracción de un grado a lo largo de miles de kilómetros, drones diminutos que pueden meterse entre escombros para encontrar sobrevivientes, o incluso bots que pueden arrastrarse por el tracto digestivo humano.

Para ayudar a sistemas de energía como estos, Kedzierski y su equipo están creando un nuevo tipo de motor llamado actuador microhidráulico. Los actuadores se mueven con un nivel de precisión, eficiencia y potencia que aún no ha sido posible a microescala. Un artículo que describe este trabajo fue publicado en Science Robotics.

Los actuadores microhidráulicos utilizan una técnica llamada electrohumectación para lograr el movimiento. El electrohumectado aplica una tensión eléctrica a las gotas de agua sobre una superficie sólida para distorsionar la tensión superficial del líquido. Los actuadores aprovechan esta distorsión para forzar a las gotas de agua dentro del actuador a moverse, y con ellas, a todo el actuador.

“Piensa en una gota de agua en una ventana; la fuerza de la gravedad la distorsiona y se mueve hacia abajo”, dijo Kedzierski. “Aquí, usamos voltaje para causar la distorsión, que a su vez produce movimiento”.

El actuador está construido en dos capas. La capa inferior es una lámina de metal con electrodos estampados en ella. Esta capa está cubierta con un dieléctrico, un aislante que se polariza cuando se aplica un campo eléctrico. La capa superior es una lámina de polyimida, un plástico fuerte, que tiene perforados canales poco profundos. Los canales guían la trayectoria de docenas de gotas de agua que se aplican entre las dos capas y se alinean con los electrodos. Para evitar la evaporación, el agua se mezcla antes con una solución de cloruro de litio, que reduce la presión de vapor del agua lo suficiente como para que las gotas del tamaño de un micrómetro duren meses. Las gotas mantienen su forma redondeada (en lugar de ser aplastadas entre las capas) debido a su tensión superficial y su tamaño relativamente pequeño.

El actuador cobra vida cuando se aplica voltaje a los electrodos, aunque no a todos a la vez. Se realiza en un ciclo de activación de dos electrodos por gota a la vez. Sin voltaje, una sola gota de agua descansa neutralmente en dos electrodos, 1 y 2. Pero al aplicar un voltaje a los electrodos 2 y 3, de repente la gota se deforma, estirándose para tocar el electrodo energizado 3 y se retira del electrodo 1.

Esta fuerza horizontal en una gota no es suficiente para mover el actuador. Pero con este ciclo de voltaje aplicado simultáneamente a los electrodos debajo de cada gota en la matriz, la capa de polyimida completa se desliza para apaciguar la atracción de las gotas hacia los electrodos energizados. Al continuar haciendo circular el voltaje, las gotitas siguen caminando sobre los electrodos y la capa continúa deslizándose; si se corta la tensión, y el actuador se detiene en sus pistas. El voltaje, entonces, se convierte en una herramienta poderosa para controlar con precisión el movimiento del actuador.

Pero, ¿cómo queda el actuador frente a otros tipos de motores? Las dos métricas para medir el rendimiento son la densidad de potencia, o la cantidad de potencia que produce el motor en relación con su peso y eficiencia, o la medida de la energía desperdiciada. Uno de los mejores motores eléctricos en términos de eficiencia y densidad de potencia es el motor del sedán Tesla Modelo S. Cuando el equipo probó los actuadores microhidráulicos, descubrieron que estaban justo detrás de la densidad de potencia del Modelo S (a 0,93 kilovatios por kilogramo) y el rendimiento de eficiencia (con una eficiencia del 60 por ciento a la densidad de potencia máxima). Superaron ampliamente los actuadores piezoeléctricos y otros tipos de microactuadores.

“Estamos entusiasmados porque estamos cumpliendo con ese punto de referencia, y aún estamos mejorando a medida que escalamos a tamaños más pequeños”, dijo Kedzierski. Los actuadores mejoran en tamaños más pequeños porque la tensión de la superficie sigue siendo la misma independientemente del tamaño de las gotas de agua, y las gotas más pequeñas dejan espacio para que aun más gotas entren en el actuador y ejerzan su fuerza horizontal. “La densidad de potencia simplemente se dispara. Es como tener una cuerda cuya fuerza no se debilita a medida que se adelgaza”, agregó.

El último actuador, el que está más cerca del modelo S de Tesla, tenía una separación de 48 micrómetros entre las gotas. El equipo ahora está reduciendo eso a 30 micrómetros. Proyectan que, a esa escala, el actuador coincidirá con el Tesla en densidad de potencia y, a 15 micrómetros, lo superará.

La reducción de los actuadores es solo una parte de la ecuación. El otro aspecto en el que el equipo está trabajando activamente es la integración 3D. En este momento, un solo actuador es un sistema de dos capas, más delgado que una bolsa de plástico y flexible como ella, también. Quieren apilar los actuadores en un sistema similar a un andamio que pueda moverse en tres dimensiones.

Kedzierski imagina un sistema semejante que imita la matriz muscular de nuestro cuerpo, la red de tejidos que permite a nuestros músculos lograr un movimiento instantáneo, potente y flexible. Diez veces más potentes que el músculo, los actuadores se inspiraron en los músculos de muchas maneras, desde su flexibilidad y ligereza hasta su composición de componentes sólidos y fluidos.

Y así como el músculo es un excelente actuador en la escala de una hormiga o un elefante, estos actuadores microhidráulicos también podrían tener un impacto poderoso no solo a microescala, sino en la macroescala.

“Uno podría imaginar”, dijo Eric Holihan, quien ha estado ensamblando y probando los actuadores, “la tecnología aplicada a los exoesqueletos”, construida con los actuadores como un músculo real, configurado en juntas flexibles en lugar de engranajes. O un ala de avión podría cambiar de forma con comandos eléctricos, con miles de actuadores deslizándose uno sobre el otro para cambiar la forma aerodinámica del ala.

Mientras sus imaginaciones se agitan, el equipo enfrenta desafíos en el desarrollo de grandes sistemas de actuadores. Un desafío es cómo distribuir la potencia en ese volumen. Un esfuerzo paralelo en el laboratorio, que está desarrollando microbaterías para integrarse con los actuadores, podría ayudar a resolver ese problema. Otro desafío es cómo empaquetar los actuadores para eliminar la evaporación.

“La confiabilidad y el empaque continuarán siendo las preguntas predominantes que se nos plantean sobre esta tecnología hasta que demostremos una solución”, dijo Holihan. “Esto es algo que esperamos atacar frontalmente en los próximos meses”.

Fuente: MIT NEWS