soporte plataforma robotica rp6v2 adiciÓn de mÓdulos y...
TRANSCRIPT
1
SOPORTE PLATAFORMA ROBOTICA RP6V2
ADICIÓN DE MÓDULOS Y SENSORES EXTERNOS A LA PLATAFORMA
ROBÓTICA RP6V2 Y ADICIÓN DE ACTIVIDADES A LA APLICACIÓN
DESARROLLADA EN ANDROID.
LIZETH VANESSA MENDIVELSO RODRÍGUEZ
BRAYAN STICK MOLINA ESCOBAR
UNIVERSIDAD DISTRITAL FRANCISCO JOSE DE CALDAS
TECNOLOGÍA EN ELECTRÓNICA
NUEVOS RECURSOS S.A.S.
2
CONTENIDO
INTRODUCCIÓN .............................................................................................................................. 3
ADICIÓN DE PERIFÉRICOS EXTERNOS A LA PLATAFORMA ROBÓTICA RP6V2 ....... 4
SOPORTE DE COMUNICACIÓN .............................................................................................. 4
CONEXIÓN DEL NUEVO PERIFÉRICO A LA PLATAFORMA .......................................... 4
EL BUS I2C DEL RP6V2 ............................................................................................................ 5
MODO MAESTRO ................................................................................................................... 6
MODO ESCLAVO .................................................................................................................... 8
CREACIÓN DE NUEVAS ACTIVIDADES EN LA APLICACIÓN .......................................... 10
ARCHIVO XML ........................................................................................................................... 10
CONSTRAINT LAYOUT ....................................................................................................... 10
ARCHIVO JAVA ......................................................................................................................... 11
REFERENCIAS .............................................................................................................................. 14
3
INTRODUCCIÓN
Este documento contiene información detallada acerca de cómo adicionar módulos
y sensores externos a la plataforma robótica RP6V2. Además, contiene una guía
para la adición tareas, a través de actividades, a la aplicación desarrollada para
dicha plataforma.
Es importante tener en cuenta que la plataforma robótica RP6V2 cuenta con un
manual el cual describe su funcionamiento de una forma más general. [1]
También cabe destacar, que para el uso de este manual se debe contar con
conocimientos básicos de programación en lenguaje C. Si no se dispone de dichos
conocimientos, en la sección 4.4 del manual del RP6V2, se encuentra un curso
rápido de programación en dicho lenguaje, como la explicación y el debido uso de
las librerías que se nombrarán en este manual. Adicionalmente se debe contar con
conocimientos básicos de programación en lenguaje JAVA para el desarrollo de la
aplicación en Android Studio.
En el siguiente enlace encontrará el manual del RP6V2, una introducción al lenguaje
JAVA y un tutorial de programación en Android Studio:
https://drive.google.com/drive/u/3/folders/1LTVsaRclk47-gLMsPTtaqWN9fy-Y6X0i
4
ADICIÓN DE MODULOS Y SENSORES EXTERNOS A LA
PLATAFORMA ROBÓTICA RP6V2
SOPORTE DE COMUNICACIÓN
Para empezar, es necesario que tenga claro el tipo de módulo o sensor que va a
añadir y su funcionamiento. La plataforma robótica tiene un sistema de expansión
por medio de un bus Two-Wire Interface (TWI) o mejor conocido como Inter-
Integrated Circuit (I2C) el cual proporciona una capacidad de hasta 255 dispositivos
conectados al bus por lo cual, el periférico que usted va a añadir debe soportar este
tipo de comunicación.
NUEVA CONEXIÓN A LA PLATAFORMA
Luego de validar que el módulo o sensor que va a añadir tenga soporte de
comunicación I2C, deberá verificar la forma en que se conecta y su nivel lógico de
funcionamiento. Si el módulo o sensor cuenta con un voltaje lógico diferente a 5V
(voltaje lógico de la plataforma robótica), deberá diseñar el circuito conversor de
nivel bidireccional, mostrado en la figura 1, para evitar daños en el nuevo periférico
o en la plataforma robótica.
Figura 1: Conversor de nivel lógico.
ATENCIÓN: La alimentación del Low Side puede variar dependiendo del nivel lógico
de su módulo o sensor. También cabe añadir que se pueden adicionar tantos
dispositivos como requiera (hasta 255) como se muestra en la figura 2. Las
resistencias también pueden variar dependiendo de la velocidad que usted
disponga a usar en la comunicación, por defecto se usan de 10KΩ para una
velocidad de 100KHz.
5
Figura 2: Bus I2C con conversor lógico.
Por otro lado, la plataforma robótica cuenta con conectores de expansión de 14
pines (figura 3) entre los cuales se encuentran: pines de alimentación, tierra,
interrupciones y por supuesto los pines SCL y SDA pertenecientes al bus I2C. Para
mayor información acerca de los conectores de expansión puede leer la sección 2.5
del manual del RP6v2.
Figura 3: Conector de expansión RP6v2.
EL BUS I2C DEL RP6V2
La plataforma robótica cuenta con una librería llamada RP6Library, la cual provee
al usuario una gran cantidad de funciones para asignar tareas a la plataforma de
una manera más sencilla. Entre estas funciones se encuentran: Funciones UART,
contadores, delays, estado de los sensores, conversores análogo-digitales,
funciones propias para el control de la plataforma y funciones para control del bus
6
I2C. Este documento hace énfasis en las funciones del bus I2C incluidas en la
librería. Si requiere mayor información acerca de la librería y todas las funciones de
esta, diríjase al numeral 4.6 del manual del RP6v2.
La plataforma robótica tiene la cualidad, como la mayoría de los dispositivos que
soportan el bus I2C, de funcionar en modo maestro y en modo esclavo.
Mediante modo maestro la plataforma robótica será la encargada de controlar los
periféricos externos, tanto en la recolección como en el envío de datos. Por otro
lado, en el modo esclavo la plataforma será controlada por otro dispositivo ya sea
un microcontrolador u otro periférico que cuente con circuitos integrados
programables.
MODO MAESTRO
Figura 4: Comunicación I2C modo maestro.
7
INICIALIZACIÓN DE LA PLATAFORMA E INLUSIÓN DE LAS LIBRERÍAS DEL
MODO MAESTRO:
En el modo maestro se definen dos líneas de código para llamar la librería del RP6v2
(siempre debe ser incluida) y para incluir la librería del modo maestro:
ESPECIFICAR VELOCIDAD DEL BUS I2C
Además de estas librerías, se debe especificar la velocidad del bus I2C mediante la
sentencia I2CTWI_initMaster(FREQ). Si no se especifica la velocidad de
transmisión del bus I2C, por defecto esta será de 100KHz.
ENVÍO Y RECEPCIÓN DE DATOS
La librería RP6I2CmasterTWI.h incluye funciones de escritura que tiene la
capacidad de enviar desde uno hasta veinte bytes dependiendo del uso que se
desee darle al bus I2C.
Por otro lado, la librería RP6I2CmasterTWI.h cuenta con funciones de lectura. Estas funciones son similares a las de escritura y los datos obtenidos pueden ser almacenados en un buffer del tamaño de la cantidad de datos que usted desee recibir.
8
MODO ESCLAVO
Figura 5: Comunicación I2C modo esclavo.
INICIALIZACIÓN DE LA PLATAFORMA E INLUSIÓN DE LAS LIBRERÍAS DEL
MODO ESCLAVO:
En el modo esclavo se definen dos líneas de código para incluir la librería del RP6v2
(siempre debe ser incluida) y para incluir la librería del modo esclavo.
9
ESPECIFICAR DIRECCION DEL BUS I2C
Además de estás librerías, se debe definir la dirección de esclavo con la que
funcionará el RP6v2.
ENVÍO Y RECEPCIÓN DE DATOS
El modo esclavo cuenta con dos vectores llamados I2CTWI_readRegisters,
I2CTWI_writeRegisters. I2CTWI_readRegisters se encarga de almacenar la
información interna, es decir, de almacenar el estado de los periféricos internos o
los periféricos con los que cuenta la plataforma robótica. Sin embargo,
I2CTWI_writeRegisters se encarga de almacenar la información que es enviada
desde el maestro, es decir, la información de los periféricos externos que el usuario
desde almacenar en la plataforma robótica para su posterior tratamiento.
Existen también funciones para verificar si el bus I2C se encuentra ocupado tanto
para lectura como para escritura, esto con el fin de tener una lectura y/o escritura
limpia y sin errores. La primera, I2CTWI_readBusy, se encarga de verificar si el
maestro se encuentra leyendo los datos de la plataforma para no sobrescribir los
datos de los periféricos internos en el vector I2CTWI_readRegisters. La segunda,
I2CTWI_writeBusy, se encarga de verificar si el maestro se encuentra escribiendo
datos en la plataforma para no alterar la lectura del vector I2CTWI_readRegisters
desde el maestro.
Se debe tener en cuenta que el vector I2CTWI_readRegisters varía según la
cantidad de datos obtenidos mediante el bus I2C, es decir, si usted está recibiendo
tres datos a través del bus I2C (estos se almacenan en el vector
I2CTWI_writeRegisters de forma ordenada a medida que llegan los datos), el vector
I2CTWI_readRegisters empezará a ser válido desde la posición tres, es decir, la
posición cero, uno y dos del vector, estarán vacías.
Para mayor información y ejemplos acerca del bus I2C tanto en modo maestro como
en modo esclavo, lea la sección 4.6.11 del manual del RP6v2.
Para mayor información y ejemplos acerca del bus las librerías nativas de la
plataforma robótica, lea la sección 4.6 del manual del RP6v2.
10
CREACIÓN DE NUEVAS ACTIVIDADES EN LA APLICACIÓN
Al momento de diseñar la aplicación se utilizó Android Studio, que es un sistema operativo de código abierto para dispositivos móviles, que se programa principalmente en Java y su núcleo está basado en Linux [2]. Se recomienda desarrollar la aplicación en el API 21, es decir, en Android 5.0, debido a que esta versión ofrece mayor compatibilidad con otras versiones de Android. Una actividad está conformada por dos partes: una parte lógica (archivo .java) y una parte gráfica (archivo .xml) [3].
ARCHIVO XML
XML es un lenguaje de marcas extensible, lo que significa que no es un lenguaje
de programación sino un meta-lenguaje utilizado para almacenar datos de manera
legible, muy parecido al HTML.
La parte gráfica de la actividad, es un archivo de éste tipo, el cual nos ayuda a crear
layouts, valores, menús, AppWidgets, preferencias, entre otras. En éste caso, se le
permite al usuario alternar en dos vistas diferentes ya sea de diseño (Constraint
layout) o texto, trabajando con ambas la misma interfaz.
CONSTRAINT LAYOUT
Es una herramienta que facilita la construcción de interfaces para las aplicaciones,
la cual está dividida en dos partes: el modo diseño, que nos permite visualizar cómo
ve la actividad el usuario final, y el modo blueprint, el cual permite visualizar el
esqueleto de la aplicación. La ventaja de ésta herramienta es que no es necesario
escribir código para poder editar la interfaz, ya que cuenta con una paleta de
componentes, los cuales solo es necesario arrastrar y colocar, dentro de la interfaz
(figura 6).
11
Figura 6: Herramienta ConstraintLayout.
ARCHIVO JAVA
La parte lógica de la actividad, es un archivo JAVA, el cual se crea para poder
manipular, interactuar y colocar el código que proporciona la funcionalidad de la
actividad (figura 7) [4].
Figura 7: Ejemplo, archivo java.
12
Figura 8: Diagrama de flujo de una actividad
Como se muestra en la figura 8, hay una comunicación constante entre la aplicación y la plataforma, para esto se utilizó la librería Volley, que es una librería desarrollada por Google para optimizar el envío de peticiones http desde las aplicaciones Android, hacia servidores externos [5].
El método obtenerdatos () es utilizado para la petición de datos a una dirección web
local, en el cual la función mStringRequest es la petición que hace la aplicación al
servidor, para solicitar datos de determinada URL, el método onResponse () se
utiliza en caso de que exista una respuesta desde el servidor y, por otra parte, el
método onErrorResponse () se utiliza en caso de que haya un error en la respuesta.
Se debe tener en cuenta que la aplicación recibe los datos en forma de cadena
(String) y como se puede ver en las anteriores líneas de código, se guarda en una
variable llamada sensores, de carácter público para posteriormente ser usada fuera
del método obtenerdatos ().
El método llamarUrl () se utiliza para enviarle datos a la plataforma. En éste caso se utiliza la misma librería Volley utilizada anteriormente, y se utiliza una variable
13
llamada envío, de tipo cadena (String), con la cual se hace una petición al servidor en esa URL específica (IP+” /on” ;), En este caso “/on” es el comando que se le envía al robot, por medio del cual se le especifica la tarea que se requiere que inicie. El comando puede variar según el programa y su estructura será de la siguiente manera: “/Comando”.
Por ejemplo, hay actividades que permiten que la plataforma robótica realice una
tarea determinada al oprimir un botón, en este caso, el método visto anteriormente
debería ir asignado a dicho botón. Como se puede apreciar en las siguientes líneas
de código, se muestra que se utiliza el método con el fin de que, al oprimir el botón
izquierdo, se cumpla la tarea de enviar a la plataforma el comando “/izq”.
Por último, para navegar entre las diferentes actividades se utiliza el objeto Intent,
que proporciona un enlace de tiempo de ejecución entre componentes separados,
como dos actividades. En este caso el objeto intent en primera estancia es creado
y describe que va desde la actividad en la que se encuentra hacia la llamada menú
principal.
14
REFERENCIAS
[1] C. R. Vehicle, “RP6v2,” 2013.
[2] D. Robleado Fernández, “Desarrollo De Aplicaciones Para Android,” p. 49, 2014.
[3] S. Figure, “Tutoriales android.,” no. c, pp. 1–4.
[4] “INTRODUCCIÓN A LA PROGRAMACIÓN JAVApdf.crdownload.” .
[5] S. Weber, “Volley.”