1

FACULTAD DE INGENIERÍA UNIVERSIDAD NACIONAL DE SAN JUAN

TRABAJO INTEGRADOR FINAL

Cátedras

Aplicaciones Industriales del Ultrasonido

Microcontroladores

Pantalla Táctil por Ultrasonido basada en el

Modulo HC - SR04 Alumno:

Masiero, Renzo 23109

Año 2015

2

Resumen Se presenta el estudio, desarrollo e implementación de una “pantalla táctil” que detecta la posición de un objeto (lápiz, mano, etc) en la misma con sensores de distancia ultrasónicos. La idea plantea el uso de cuatro sensores colocados en cierta posición fija y con ellos poder determinar mediante cálculos matemáticos la posición de un lápiz o la mano de un posible usuario. En este trabajo se llevan a cabo las pruebas necesarias para comprobar la factibilidad de esta propuesta y en caso de ser posible la elaboración de un prototipo funcional. 1. Introducción En la actualidad existen distintos tipos de pantallas táctiles. Las más comunes son las resistivas y las capacitivas, siendo las segundas las de mayor precisión y calidad. En general el costo de las mismas es elevado y el aumento del tamaño de estas recae en costos aun mayores. La idea plantea pantallas de mayor tamaño, ya que los sensores ultrasónicos utilizados miden un máximo de 4 metros. Por otro parte el costo de cada sensor es de aproximadamente 3 dólares, por lo que estamos usando 4 sensores el costo sería bajo. Las pruebas se concentraran en comprobar el funcionamiento de estos módulos para este proyecto en particular, la precisión alcanzada y también determinar la máxima distancia posible a medir considerando el eje vertical del lóbulo, y finalmente el funcionamiento en conjunto de los cuatro sensores juntos. Se plantea un diseño de acuerdo a la figura 1:

Figura 1 Concepto del trabajo a desarrollar

De esta forma la zona gris por ejemplo seria medida por el sensor 1 y cada sensor tendrá una zona similar. Así en cada zona dos sensores podrán medir la distancia desde los mismos hasta el objeto. La Zona 1 mostrara distancias en los sensores S1 y S2, la zona 2 en S1 y S4, la zona 3en S4 y S3 y por último la zona 4 en S3 y S2. Modulo HC - SR04: El modulo posee cuatro pines, de los cuales dos son para alimentación y masa del mismo y dos pines para su control. El pin trigger es por el cual indicaremos al sensor que realice una medición. Para que esta señal sea tomada como valida debe ser un cambio de estado de 0 lógico a 1 lógico y de vuelta a 0 de al menos 10 uSeg en estado alto, este dato es proporcionado por el fabricante en la hoja de datos. Una vez cumplida con la señal

3

anteriormente explicada el modulo pasado un tiempo nos colocara su salida denominada ECO en estado lógico “1”, este tiempo es proporcional a la distancia a la que se detecto un objeto. En la siguiente grafica se explica el proceso:

Figura 2. Formas de ondas del módulo HC - SR04

Figura 3. Vista del módulo HC - SR04 2. Diseño del sistema Se diseña el sistema como se muestra en la figura, los cuatro sensores serán colocados en las esquinas y calibrados, todo se montara sobre una base que simula una pantalla. El proceso de controlar los módulos se llevara a cabo con un microcontrolador msp430 y con el mismo se enviara la información a la PC para ser procesada. La conexión con la PC será una conexión serie y en la PC se trabajara con Linux y usando lenguaje C. Se trata de un microcontrolador pequeño en un encapsulado DIP de 20 pines de bajo costo y ultra bajo consumo. Los módulos sensores trabajan con niveles lógicos: 0 volts para “0” lógico y 5 volts para “1” lógico. El microcontrolador pose niveles lógicos: 0 volts para “0” lógico y 3.3 volts para “1” lógico. Para acoplar estos niveles usaremos una interfaz de 5v a 3,3v.

Figura 4. Esquema general del sistema

4

Microcontrolador: Para el proyecto se usara el microcontrolador montado en su placa de desarrollo MSP430EXPG2. La misma posee comodidades para el trabajo de desarrollo como por ejemplo cambiar conexiones sin tener que re diseñar un circuito impreso, fácil acceso a los pines y alimentación estabilizada. Lo más importante es que posee un simulador de puerto serie que funciona como interfaz entre el microcontrolador y la Pc. El micro se comunica con la interfaz con una conexión serie normal y configurable en cuanto a velocidad, cantidad de bits de información y cantidad de bits de inicio y parada. Para la PC pose un puerto y cable USB pero que funciona como una comunicación serie tradicional, esto nos permite trabajar en una PC que no posea un puerto serie. Los modelos más avanzados de la empresa Texas poseen comunicación USB directa, y en un futuro se podría directamente trabajar a través de este tipo de conexión. Para la primera etapa de este proceso gracias la utilización de esta placa desarrolladora se conecto fácilmente una pantalla LCD para comprobar el ángulo de medición del modulo de manera más sencilla. A continuación se muestra una imagen con la palca de desarrollo y el microcontrolador montado en ella, en el se puede observar el integrado encargado de simular el puerto serie y la salida USB que se conecta al PC:

Figura 5. MSP430EXPG2

Cálculos: Si un objeto se encontrase en la zona 3 el sensor 4 mediría una distancia y el sensor 3 otra, estos datos nos permitiría de la siguiente manera calcular la posición en X e Y del objeto. De la misma forma funcionaria para las otras cuatro zonas. Matemáticamente las coordenadas se obtienen con el teorema del coseno y trigonometría:

5

Figura 6. Cálculo de la coordenadas del punto

3. Ensayos del prototipo HC- SR04: En la primera etapa se puso en funcionamiento el modulo, comprobando distintas situaciones. Se comprobó que la velocidad del microcontrolador fuese suficiente para contar el tiempo en microsegundos requerido para lograr la conversión de tiempo de señal eco en alto –distancia detectada. A continuación se muestran algunas capturas del osciloscopio donde se constataron los tiempos de respuesta del módulo y también se comprobó que el tiempo en alto de la señal eco era correctamente relevado por el microcontrolador:

6

Figura 7. Tiempos de respuesta

Figura 8. Tiempos de respuesta

Como conclusión se puede decir que se logro el correcto funcionamiento y se constato que el sensor funcionaba según lo esperado. Angulo de Medida El fabricante nos dice que el Angulo de medida es de 15°, siendo este un inconveniente para la medición en línea. Para este proyecto en particular un mayor Angulo permitiría una mayor superficie de medición. Se realizaron experimentos para constatar el real ángulo de estos sensores y se lograron medir distancias en ángulos mayores a 15° obteniendo como promedio 35°. Para el proyecto se decide entonces tomar como un rango de seguridad los 30°. Se conecta al sensor una pantalla LCD para la lectura rápida y calibración de los sensores. También se decide eliminar la parte decimal del resultado obtenido debido a la inestabilidad de la misma. Se toman también con un osciloscopio las señales para constatar los datos calculados por el modulo, y asegurar que se respete el tiempo entre medición y medición que asegura un espacio libre de ondas anteriores. En las imágenes se muestran las pruebas realizadas.

7

Figura 9. Pruebas de calibración

Figura 10. Vista del prototipo

Armado del Prototipo final: Con las pruebas anteriores se realiza el armado del prototipo final esquematizado en la siguiente figura. Se comienza tomando una muestra de cada sensor en orden S1, S2, S3 y S4 y se detectan los primeros problemas. Como se explico los módulos no permiten el control directo de los sensores, sino que funcionan de forma automática. Estos aunque no se le indique que realicen una medición no detienen completamente los sensores y esto afecta todas las mediciones de los demás sensores. Es decir al disparar S1 el sensor S3 colocado

8

en frente modifica el valor obtenido en S1. Los módulos otorgan medidas completamente erróneas e inestables y se comienza a buscar una solución. Como posible solución se prueba colocar una llave electrónica (transistor) y se conecta a Vcc a través del microcontrolador cada modulo en el momento que se requiere el valor del mismo. El nuevo diagrama del proyecto se muestra a continuación, en el mismo se puede apreciar el agregado de las llaves electrónicas (transistores) que permitirán encender los módulos solo cuando se desee.

Figura 11. Esquema prototipo II

Finalmente se corrobora que el nuevo esquema de funcionamiento ofrece la corrección del problema mencionado. El proceso comienza activando el módulo S1 tomando el valor correspondiente y desactivando el módulo S1, esto se repite para S2, S3 y S4 en ese orden. El tiempo mínimo entre una medición y otra es de 20mS por lo que se tiene en cuenta este requerimiento para el proceso. A continuación se muestra una gráfica de tiempo de funcionamiento con un objeto en la Zona 3 detectado por los módulos S4 y S3, donde se observa que el proceso completo tiene una duración de aproximadamente 200ms.

Figura 12. Formas de onda prototipo II

A continuación algunas muestras del prototipo funcionando y capturas de pantalla de los resultados obtenidos.

9

Figura 13. Pantalla táctil

Figura 14. Microcontrolador, transistores e interfaz

10

Figura 15. Prototipo junto con capturas de pantalla

Figura 16. Código primer ejemplo

Segundo ejemplo:

Figura 17. Posición en el segundo ejemplo

11

Figura 18. Código segundo ejemplo

3. Conclusiones Como conclusión se puede decir que se obtiene un funcionamiento correcto. En cuanto a la precisión del sistema se realizan tres mediciones antes de mostrar un resultado y obtener un valor promediado. La precisión de este método esta aproximadamente en 1.5 cm por lo que debería tenerse en cuenta los requerimientos de precisión antes de comenzar con un proyecto de este tipo. Queda probado que la propuesta es factible y se podría profundizar en el tema en cuanto a la optimización del todo el sistema. En cuanto a la distancia, los resultados no se los esperados, el modulo efectivamente mide más de 3 metros, pero sobre una superficie el lóbulo se ve afectado por la misma reduciendo el rango a unos 80 centímetros. Para futuros trabajos y como posibles mejoras se propone un estudio sobre el orden de activación de los módulos según sea necesario, es decir, no mantener el orden repetitivo una vez que se detecta una señal, podría mejorar el tiempo de muestreo y realizar un estudio detallado de precisión.

Anexo I

Codigo del Microcontrolador

#include <msp430.h> #include "intrinsics.h" void ConfigurarTimer(void); void ConfigurarUart(void); unsigned int Medir(int); void Transmitir(unsigned int); unsigned long int contador=0;

12

unsigned char RXByte=0; void main(void) { WDTCTL = WDTPW | WDTHOLD; // Stop watchdog timer unsigned int distancia1=0,distancia2=0,distancia3=0,distancia4=0; BCSCTL1 = CALBC1_16MHZ; // Set range DCOCTL = CALDCO_16MHZ; // Set DCO step + modulation P1SEL |= BIT1 + BIT2; P1SEL2 |= BIT1 + BIT2; P2SEL |= 0x00; //puertos como E/S P1DIR |= BIT0 + BIT3+ BIT4+ BIT5+ BIT6+ BIT7; //SALIDAS // 6 y 7 transitores para s1 y s4 P2DIR |= BIT4+ BIT5; //SALIDAS de TRANSISTORES s1 y s2 /* * salidas: 1. * 5 4 * * 0 3 Entradas:2. 3 2 0 1 */ ConfigurarUart(); ConfigurarTimer(); __enable_interrupt(); P2OUT &= ~BIT4; P2OUT &= ~BIT5; P1OUT &= ~BIT6; P1OUT &= ~BIT7; while(1) { if(RXByte==0x39){ distancia1=Medir(1); __delay_cycles(100); distancia2=Medir(2); __delay_cycles(100); distancia3=Medir(3); __delay_cycles(100); distancia4=Medir(4); __delay_cycles(100); Transmitir(distancia1); Transmitir(distancia2); Transmitir(distancia3); Transmitir(distancia4); RXByte=0; } if(RXByte==0x31){ P2OUT |= BIT4; __delay_cycles(1000);

13

distancia1=Medir(1); __delay_cycles(2000); distancia1=distancia1+ Medir(1); __delay_cycles(2000); distancia1=distancia1+ Medir(1); P2OUT &= ~BIT4; distancia1=distancia1/3; Transmitir(distancia1); RXByte=0; distancia1=0; } if(RXByte==0x32){ P2OUT |= BIT5; __delay_cycles(1000); distancia1=Medir(2); __delay_cycles(2000); distancia1=distancia1+ Medir(2); __delay_cycles(2000); distancia1=distancia1+ Medir(2); P2OUT &= ~BIT5; distancia2= distancia2/3; Transmitir(distancia2); RXByte=0; distancia2=0; } if(RXByte==0x33){ P1OUT |= BIT6; __delay_cycles(1000); distancia1=Medir(3); __delay_cycles(2000); distancia1=distancia1+ Medir(3); __delay_cycles(2000); distancia1=distancia1+ Medir(3); P1OUT &= ~BIT6; Distancia3=distancia3/3; Transmitir(distancia3); RXByte=0; distancia3=0; } if(RXByte==0x34){ P1OUT |= BIT7;

__delay_cycles(1000); distancia1=Medir(4); __delay_cycles(2000); distancia1=distancia1+ Medir(4); __delay_cycles(2000); distancia1=distancia1+ Medir(4); P1OUT &= ~BIT7; Distancia4=distancia4/3; Transmitir(distancia4); RXByte=0; distancia4=0; } __delay_cycles(200);

14

} } unsigned int Medir(int A) { switch(A) { case 1: contador=0; P1OUT = BIT0; __delay_cycles(100); P1OUT =~ BIT0; while((P2IN & BIT0) == 0){ } CCTL0 = CCIE; while((P2IN & BIT0) != 0){ } CCTL0 = ~ CCIE; break; case 2: contador=0; P1OUT = BIT3; __delay_cycles(100); P1OUT =~ BIT3; while((P2IN & BIT1) == 0){ } CCTL0 = CCIE; while((P2IN & BIT1) != 0){ } CCTL0 = ~ CCIE; break; case 3: contador=0; P1OUT = BIT4; __delay_cycles(100); P1OUT =~ BIT4; while((P2IN & BIT2) == 0){ } CCTL0 = CCIE; while((P2IN & BIT2) != 0){ } CCTL0 = ~ CCIE; break; case 4: contador=0; P1OUT = BIT5; __delay_cycles(100); P1OUT =~ BIT5; while((P2IN & BIT3) == 0){ } CCTL0 = CCIE; while((P2IN & BIT3) != 0){ } CCTL0 = ~ CCIE; break; } return (contador/58); } void ConfigurarTimer(void) { CCTL0 =~CCIE;

15

CCR0 =16; TACTL = TASSEL_2 + MC_1; } void ConfigurarUart(void) { UCA0CTL1 |= UCSSEL_2; UCA0BR0 = 130; // 1MHz 9600 UCA0BR1 = 6; // 1MHz 9600 //UCA0BR0 = 1666; // 16MHz 9600 //UCA0BR1 = 0; // 16MHz 9600 UCA0MCTL = UCBRS0; UCA0CTL1 &= ~UCSWRST; IE2 |= UCA0RXIE; } void Transmitir(unsigned int dato) { while (!(IFG2 & UCA0TXIFG)); UCA0TXBUF = dato; } #pragma vector=TIMER0_A0_VECTOR __interrupt void Timer_A (void) { contador ++; } #pragma vector=USCIAB0RX_VECTOR __interrupt void USCI0RX_ISR(void) { RXByte = UCA0RXBUF; }

ANEXO II

Módulos Usados en el Microcontrolador

Modulo UART

La configuración de este modulo comienza seleccionando el reloj colocando dos valores de la tabla provista por el fabricante para que el envío se realice a la velocidad deseada, en nuestro caso a 9600 baudios. Para nuestro envío utilizaremos la configuración más sencilla con 7 bits de información y un bit de parada. Para la recepción de información se utilizaran interrupciones, es decir cuando el buffer de entrada este completo interrumpirá el programa principal y se podrá extraer el dato del buffer. Para la transmisión solo se procederá escribiendo en el buffer el dato que se desea enviar. Solo se deberá tener en cuenta las banderas que indican que la transmisión anterior ya finalizo.

16

Timer

Se utiliza el timer A en el “Up Mode”, cuando el mismo llega al valor de cuenta deseado, desborda e interrumpe.

o TAR cuenta hacia arriba hasta que alcanza el valor del registro CCRO o TAR -> CCRO: TACCRO genera la bandera de interrupción, si CCIFG esta en 1. o En el próximo ciclo se reinicia la cuenta del TAR. Periodo de interrupción: Tint= 1/[fclk/Divisor/(TACCRO+1)] = 1/[16Mhz/1/16] = 1 uS

Up Mode

Diagrama en bloques del timer A

Anexo III

Desarrollo del programa de PC en C++

Programa solo desarrollado para ejecutar en consola y probar el S1 y S2 solos o en conjunto devolviendo la posición x , y del objeto. #include <iostream> #include <SerialPort.h> #include <string.h> #include <fstream> #include <iomanip> #include <unistd.h> #include <sstream> #include <stdlib.h> #include <cmath> using namespace std;

17

int main() { int aux1=0,aux2=0,suma; float x=0,y=0; SerialPort serial_port( "/dev/ttyACM0"); serial_port.Open(SerialPort::BAUD_9600, SerialPort::CHAR_SIZE_8, SerialPort::PARITY_NONE, SerialPort::STOP_BITS_1, SerialPort::FLOW_CONTROL_NONE); unsigned int opcion; cout<<"1 => 1 ::::: 2=> 2 ::::::: 9 => 1 Y 2 "<<endl; cin>>opcion; if (opcion==1) { for(int i=0;i<10000;i++) { try { serial_port.Write("1"); aux1= serial_port.ReadByte(2000); } catch (SerialPort::ReadTimeout &E) { cout << "No se recivieron datos, tiempo de espera exedido"<<endl; return 0; } aux1=(aux1/7)-1.8+(aux1); cout<<"sensor1 " << aux1<<endl; }//for opcion 1 }//if opcion 1 if (opcion==2) { for(int i=0;i<10000;i++) { try { serial_port.Write("2"); aux1= serial_port.ReadByte(2000); } catch (SerialPort::ReadTimeout &E) { cout << "No se recivieron datos, tiempo de espera exedido"<<endl; return 0; } aux1=(aux1/7)-1.8+(aux1); cout<<"sensor2 " << aux1<<endl; }//for opcion 2

18

}//if opcion 2 if (opcion==9) { for(int i=0;i<1000;i++) { try { serial_port.Write("1"); aux1= serial_port.ReadByte(2000); } catch (SerialPort::ReadTimeout &E) { cout << "No se recivieron datos, tiempo de espera exedido"<<endl; return 0; } aux1=((suma/4)/7)-1.8+(suma/4); aux1=aux1*1.2; try { serial_port.Write("2"); aux2= serial_port.ReadByte(2000); } catch (SerialPort::ReadTimeout &E) { cout << "No se recivieron datos, tiempo de espera exedido"<<endl; return 0; } aux2=((suma/4)/7)-1.8+(suma/4); aux2=aux2*1.1; cout<<"sensor 1: "<<aux1<<" sensor 2:"<<aux2<<endl; x= (50*50)+ (aux1*aux1) - (aux2*aux2); x= x / (2*50*aux1); x= x * aux1; x = 50-x; y = 30-sqrt((aux2*aux2)-(x*x)); cout<<"x = "<<x<<" y = "<<y<<endl; usleep(1000); }//for opcion 9 }//if opcion 9 }// fin main