Control de recorrida...Control de recorrida 2013 2 1. Resumen Este proyecto implementa un sistema...
Transcript of Control de recorrida...Control de recorrida 2013 2 1. Resumen Este proyecto implementa un sistema...
Control de recorrida Sistemas embebidos para tiempo real 2013
Autores: Ignacio Camps, Martín Driedger, Rodrigo Espiga
Tutor: Pablo Mazzara
Control de recorrida
2013
2
1. Resumen Este proyecto implementa un sistema basado en microcontroladores MSP430 que, utilizando un
módulo de radiofrecuencia CC2500, se comunican entre sí para controlar el recorrido de un guardia de
seguridad en un predio amplio.
El sistema consta de tres tipos de nodos distintos: fijo, móvil y base. Los nodos fijos se ubican en
puntos de control del recorrido, el nodo móvil es portado por el guardia de seguridad y el nodo base
está conectado mediante un puerto USB a una PC y es utilizado para configurar el nodo móvil y
descargar los datos al finalizar la jornada.
Al comienzo de la jornada el guardia configura su nodo móvil mediante el nodo base, inicia su
recorrido y registra el pasaje por cada punto de control utilizando un pulsador. Al terminar el recorrido
descarga los datos al nodo base. Finalmente, se transfieren los datos a través del módulo UART a la PC y
se despliegan en pantalla.
Control de recorrida
2013
3
Tabla de Contenido 1. Resumen ............................................................................................................................................... 2
2. Introducción .......................................................................................................................................... 4
3. Objetivos ............................................................................................................................................... 4
4. Alcance .................................................................................................................................................. 4
5. Estudio Previo ....................................................................................................................................... 5
6. Diseño ................................................................................................................................................... 6
6.1 Hardware ...................................................................................................................................... 6
6.2 Software ........................................................................................................................................ 7
6.2.1 Nodo Fijo ............................................................................................................................... 7
6.2.2 Nodo móvil ............................................................................................................................ 8
6.2.3 Nodo base ............................................................................................................................. 9
7. Implementación .................................................................................................................................. 10
7.1 Implementación del nodo fijo ..................................................................................................... 10
7.2 Implementación del nodo móvil ................................................................................................. 11
7.2.1 Comunicación con nodo fijo ............................................................................................... 11
7.2.2 Comunicación con nodo base ............................................................................................. 11
7.2.3 Reloj .................................................................................................................................... 12
7.3 Implementación del nodo base .................................................................................................. 13
7.3.1 Inicialización de hora de un nodo móvil ............................................................................. 13
7.3.2 Descarga de datos de un nodo móvil .................................................................................. 13
7.3.3 Despliegue de datos ............................................................................................................ 14
8. Pruebas ............................................................................................................................................... 14
9. Conclusiones ....................................................................................................................................... 15
10. Anexo .............................................................................................................................................. 16
10.1 Conceptos aplicados ................................................................................................................... 16
10.2 Especificación del proyecto ........................................................................................................ 16
10.3 Planificación del proyecto ........................................................................................................... 18
Control de recorrida
2013
4
2. Introducción En empresas con predios grandes es necesario contar con un
sistema de seguridad confiable. Para ello, además de los sistemas de
alarma, se debe contar con guardias de seguridad y además poder
controlar que éstos cumplan con su labor. El proyecto se basa en esta
necesidad por lo que se desarrolló un sistema que, mediante
radiofrecuencia (RF) y el valor RSSI (Received Signal Strength Indicator)
para determinar la proximidad, permite controlar que un guardia realice
su recorrido según se espera.
En este trabajo se documenta el proceso mediante el cual se desarrolló el sistema descripto. Se
presentan las pruebas realizadas para el estudio del funcionamiento de los dispositivos, el diseño de la
solución y su im plementación. Finalmente se presentan las conclusiones y posibles mejoras a futuro.
3. Objetivos Realizar un proyecto de sistemas embebidos para aplicar los conceptos adquiridos durante el
curso y experimentar con diferentes funcionalidades de los microcontroladores.
A partir de una aplicación sencilla de comunicación entre dispositivos mediante RF, y estudiando
su comportamiento, se le realizaron mejoras y se le agregó complejidad, implementando distintos
protocolos de comunicación entre nodos, para lograr así el objetivo principal: lograr registrar la
recorrida de un guardia en un amplio recinto.
4. Alcance Lograr que se detecte la proximidad entre los nodos y que se registre el recorrido. No se
determinará la posición exacta del guardia. Se utilizó el botón existente en la placa utilizada para lograr
un control por parte del usuario, utilizando además los LEDs indicadores para indicar al guardia que se
registró su pasaje por cada punto de control y que se descargaron los datos al nodo base. Por lo tanto
no se utilizó hardware adicional en este proyecto.
Los datos se envían mediante comunicación serie a un terminal para su visualización, pudiéndose
mediante este último guardar en un archivo de texto (p. ej. Termite -> Settings -> Plug-in Log-File).
Se debe tener en cuenta que se trabajó bajo la hipótesis de que los nodos están suficientemente
separados como para que las posibles emisiones por radio de otros nodos no interfieran en la
comunicación, aunque se tomaron medidas para detectar y descartar respuestas de nodos alejados
mediante la lectura de la RSSI durante los mensajes. El sistema está diseñado para que una
comunicación sea exitosa si los nodos se encuentran a menos de un metro de distancia y se puedan
descartar señales provenientes de nodos que se encuentren a distancias mayores de 5 metros (según las
medidas realizadas).
Control de recorrida
2013
5
En la red implementada se utilizan enlaces de un solo salto, es decir, se utilizaron comunicaciones
punto a punto, en las cuales se evitan los problemas de interferencias por nodo oculto y nodo expuesto
mediante la limitación del alcance del enlace y la distribución de los nodos.
5. Estudio Previo Previo al diseño del sistema se realizó un estudio del funcionamiento de la radio, utilizando una
aplicación de prueba para estudiar el indicador RSSI y la pérdida de paquetes variando con la distancia y
la potencia de transmisión. Fue necesario estudiar el formato de los paquetes enviados, cómo variar la
potencia de transmisión. Además, como precaución, se realizó un cambio del canal de transmisión, dado
que el canal por el cual transmite por defecto coincide con el canal utilizado por señales de wi-fi, y otras
señales muy comunes, lo que puede provocar interferencias.
Se realizó el siguiente ensayo:
Enviar 29 paquetes desde uno de los dispositivos, recibirlos en otro dispositivo, calcular el
promedio del RSSI de estos paquetes y registrar las eventuales pérdidas.
Esta prueba se realizó variando la distancia (entre 1 y 7 metros) repitiendo el ensayo 3 veces
cada un metro, luego se repitió el proceso variando la potencia de transmisión (entre 1dBm y -
16dBm)
El siguiente gráfico muestra el resultado del ensayo para el indicador de RSSI:
Control de recorrida
2013
6
En la siguiente imagen se muestra la cantidad de paquetes perdidos durante el ensayo:
Observando las pérdidas de paquetes y los promedios de RSSI, como se quiere que la
comunicación sea exitosa a corta distancia, se eligió una potencia de transmisión de -4dBm y se tomó un
umbral para el indicador RSSI de 185 para considerar que los nodos están lo suficientemente cerca.
6. Diseño
6.1 Hardware Para la implementación de este proyecto se contó con la herramienta de desarrollo eZ430-RF2500
para MSP430 y CC2500 que incluye todo el hardware y software requerido para desarrollar un proyecto
completo de aplicación inalámbrica. La herramienta incluye un emulador alimentado por USB para
programar y depurar la aplicación. Además se utilizó la placa de expansión con baterías AAA.
Características generales:
MSP430F2274 (32KB Flash – 1KB RAM)
CC2500 – 2.4 GHz, ISM band multi-canal
2 LEDs
1 Botón
Módulo UART para comunicación con PC
Control de recorrida
2013
7
6.2 Software Para la implementación se utilizó el entorno de desarrollo IAR Embedded Workbench, utilizando
lenguaje de programación C y las funciones básicas del stack SimpliciTI, un protocolo para redes de
sensores.
El sistema cuenta con tres tipos de nodos: nodo fijo, nodo móvil y nodo base. La imagen siguiente
es un diagrama simple de la comunicación entre dichos nodos:
RF uC
Nodo fijo de control
RF uC
Nodo móvil
RF uC
Nodo base PC
RF RF USB
Cabe aclarar que en un principio se consideró la idea de realizar la descarga de datos conectando
el nodo móvil directamente al PC. Debido a que el nodo puede perder los datos guardados al cambiar su
fuente de alimentación (de las pilas al puerto USB) se decidió realizar la descarga de los datos en forma
inalámbrica mediante el uso del nodo base.
A continuación se presentará el funcionamiento de los diferentes nodos.
6.2.1 Nodo Fijo
Software del nodo
La arquitectura implementada es la conocida como Round Robin con interrupciones, por su
sencillez, y porque se adecúa correctamente a la aplicación.
Este nodo se compone de un módulo “moduloFijo” creado por nosotros, y de la capa MRFI del
stack SimpliciTI para manejo de la radio brindadas por el fabricante.
El nodo fijo recibe una secuencia de paquetes de un nodo móvil, en esta secuencia, el móvil se
identifica con un número. A partir de esta secuencia, el nodo fijo decide si el móvil está lo
suficientemente cerca utilizando el indicador RSSI de los paquetes, y en ese caso, responde de la misma
manera, envía una ráfaga de paquetes identificándose como nodo fijo y un número. En caso contrario,
ignora la comunicación.
Descripción de los módulos
moduloFijo:
Atiende las interrupciones de recepción de datos mediante la radio. Recibe ráfagas de paquetes
de tamaño fijo y utiliza una bandera que indica que llegó correctamente una secuencia
completa.
Se encarga de la transmisión de datos por la radio hacia un nodo móvil.
Control de recorrida
2013
8
mrfi:
Texas provee el protocolo propietario SimpliciTI (http://www.ti.com/tool/simpliciti) de bajo
consumo. En nuestro caso no se utilizó este protocolo completo sino solo la capa MRFI del
mismo, debido a que nuestra aplicación modifica la forma de autentificar los paquetes usando el
RSSI de los mismos
6.2.2 Nodo móvil
Software del nodo
En el nodo móvil se utilizó la arquitectura Round Robin con interrupciones. Este nodo implementa
un reloj para registrar la hora del paso por cada nodo fijo.
Este nodo se compone de los módulos “moduloMovil”, “moduloHora” y “colaDatos”,
desarrollados por nosotros, además de la capa de manejo de la radio ya descrita.
El nodo móvil es el portado por el guardia. Este nodo recibe desde el nodo base una hora para
inicializar su reloj. Luego el guardia inicia su recorrida. Al acercarse a un nodo fijo, pulsa el botón, el
nodo envía una ráfaga de paquetes identificándose como nodo móvil y un número, el fijo le responde
con su identificación, el nodo móvil recibe la identificación y guarda en una cola de datos qué número de
nodo fijo le respondió y la hora del suceso. Al finalizar la recorrida, el guardia se acerca al nodo base,
pulsa el botón y el móvil envía su identificación. El nodo base responde indicando que es una base, y el
móvil enciende un LED (5 segundos) esperando una nueva pulsación del botón como confirmación de
descarga de datos. El guardia vuelve a pulsar el botón, y el nodo móvil envía su cola de datos mediante
la radio hacia el nodo base.
Descripción de los módulos
moduloMovil:
Atiende las interrupciones de recepción de datos mediante la radio. Recibe ráfagas de un
tamaño definido de paquetes y utiliza una bandera que indica que llegó correctamente una
secuencia completa.
Atención a interrupciones del botón.
Se encarga de la transmisión de datos por la radio hacia un nodo fijo o un nodo base.
Registra la información de cada nodo fijo y la hora correspondiente.
moduloHora:
Configura el timer que genera interrupciones (tick) para el incremento del reloj
Contiene las funciones de manejo del reloj del sistema, tales como inicialización, obtener hora y
atención a interrupción del tick del timer.
Control de recorrida
2013
9
colaDatos:
Implementa las funciones de manejo de una cola circular donde se guardan los datos (número
de nodo fijo con su correspondiente hora).
6.2.3 Nodo base
Software del nodo
En este nodo también se utilizó la arquitectura Round Robin con interrupciones. Además, utiliza el
módulo de comunicación UART para transmitir datos a la PC.
Está compuesto por los módulos ”moduloBase”, “moduloUART”, “colaBase”, “cola_char”. El
funcionamiento del nodo es el siguiente:
Mediante el módulo UART (utilizando un terminal en la PC) recibe la instrucción de inicializar la
hora en un móvil, tras recibir la instrucción envía por radio una secuencia de paquetes
identificados como paquetes de inicialización de hora, y con los valores recibidos por UART para
que el móvil inicialice su hora.
Si un nodo móvil le envía su identificación, el nodo base se identifica mediante una secuencia de
paquetes indicando que es una base, tras lo cual enciende un LED (5 segundos) esperando
recibir datos. Recibe los datos del móvil y los guarda en una cola circular (colaDatos).
Luego de descargados los datos desde un móvil, se le indica mediante comandos a través del
terminal que se desean ver los datos, y envía los datos guardados en la cola a través de la UART
desplegándose en pantalla.
Descripción de los módulos
moduloBase:
Atiende las interrupciones de recepción de datos mediante la radio. Recibe ráfagas de un
tamaño definido de paquetes y utiliza una bandera que indica que llegó correctamente una
secuencia completa.
Maneja los comandos recibidos por la UART.
Se encarga de la transmisión de datos por la radio hacia un nodo móvil (inicialización de hora o
su identificación como nodo base).
Guarda los datos que le envió un móvil a través de la radio.
Se encarga de manejar la transmisión de los datos a través de la UART hacia el terminal para
desplegar los datos.
moduloUART:
Contiene las funciones de atención a interrupción del módulo UART, tanto las de recepción
como las de transmisión.
Control de recorrida
2013
10
colaBase:
Implementa las funciones de manejo de una cola circular donde se guardan los datos recibidos
por radio desde un nodo móvil. Registra número de nodo móvil y cada nodo fijo por el que pasó,
con la hora correspondiente.
cola_char:
Implementa las funciones de manejo de colas de caracteres, las cuales se utilizan para enviar y
recibir datos de la UART.
7. Implementación
7.1 Implementación del nodo fijo El nodo fijo se encuentra en loop verificando la bandera fin_secuencia que indica que se recibió
una secuencia de paquetes completa.
Los paquetes recibidos tienen dos campos, frame y rxMetrics. La estructura es la siguiente:
packet.frame
Largo (1 byte) Origen (4 bytes) Destino (4 bytes) Payload (Largo – 8 bytes)
packet.rxMetrics
RSSI ( 1 byte) CRC (1 bit) LQI (7 bytes)
Los paquetes que son enviados de un nodo móvil a un nodo fijo tienen el siguiente contenido:
packet.frame[9] = ‘M’ indicando que es un móvil
packet.frame[10] = número de nodo
packet.frame[11] = nº de secuencia del paquete
El nodo fijo espera recibir una secuencia de una cantidad predefinida de paquetes (MAX_PKTS) los
cuales se guardan en un arreglo de ese tamaño.
Al recibir un paquete se genera una interrupción de recepción de la radio. Conforme se reciben
los paquetes, se verifica si el número de secuencia se corresponde con el índice del próximo lugar libre
en el arreglo, de ser así, se guarda este paquete en el arreglo y se obtiene su valor de RSSI. Si el índice no
coincide con el número de secuencia del paquete, se descarta y se espera que se inicie una secuencia
nueva (se espera un paquete con número de secuencia 0).
Control de recorrida
2013
11
Si se detecta que llegó toda la secuencia, se calcula el promedio de los RSSI, se pone en uno la
bandera fin_secuencia. El programa principal, al detectar esta bandera, comprueba que el valor RSSI
promedio sea mayor al umbral definido para detectar si el móvil está lo suficientemente cerca. En ese
caso, le contesta con una secuencia de paquetes de la siguiente forma:
packet.frame[9] = ‘F’ indicando que es un fijo
packet.frame[10] = número de nodo
packet.frame[11] = nº de secuencia del paquete
En caso que el promedio de RSSI no alcance el umbral, se ignora la comunicación y no se envía el
reconocimiento al nodo móvil, por lo cual el guardia deberá iniciar otra comunicación. Este proceso se
repetirá hasta obtener el reconocimiento. Finalizada la transmisión, el nodo fijo queda a la espera de
una nueva secuencia.
NOTA: Una posible mejora del sistema, sería que el nodo fijo guardara un log de los intentos
fallidos.
7.2 Implementación del nodo móvil
7.2.1 Comunicación con nodo fijo
El usuario, portando el nodo móvil, al acercarse a un nodo fijo, pulsa el botón. Esto genera una
interrupción que transmite una ráfaga de paquetes con el formato indicado en la sección 7.1 de este
documento.
Al igual que el nodo fijo, se encuentra en loop verificando la bandera fin_secuencia que indica que
se recibió una secuencia de paquetes completa. En este caso, si lo que recibe en packet.frame[9] es ‘F’
(indicando que es un fijo quien respondió) obtiene su hora actual, genera un dato (estructura que
contiene número de nodo fijo registrado, hora y minutos a la que se registró) y lo guarda en una cola
(colaDatos).
7.2.2 Comunicación con nodo base
Inicialización de hora y cola de datos
Al inicio de su jornada, el nodo se inicializa (reset) por lo cual se le debe inicializar la hora. La
orden llega desde el nodo base, como se pasa a describir.
Si lo que recibe en packet.frame[9] es ‘H’, significa que un nodo base le está enviando los valores
con los cuales debe inicializar su hora. Los paquetes recibidos tienen el siguiente contenido:
packet.frame[9] = ‘H’ indicando que es un paquete de inicialización de hora
packet.frame[10] = número de base
packet.frame[11] = nº de secuencia del paquete
packet.frame[12] = hora
packet.frame[13] = minutos
Control de recorrida
2013
12
packet.frame[14] = segundos
En este caso se inicializa la hora con estos valores, y se inicializa la cola de datos, ya que se está
comenzando una nueva jornada.
Descarga de datos
Cuando el usuario termina el recorrido, se aproxima al nodo base y pulsa el botón del nodo móvil.
Se genera una interrupción que transmite una ráfaga de paquetes con el formato indicado en la sección
7.1 de este documento. Si lo que recibe en packet.frame[9] es ‘B’, significa que quien respondió es un
nodo base, ante lo cual se inicia un contador de tiempo, durante el cual se enciende el LED rojo y se
espera a que el usuario pulse nuevamente el botón para confirmar que quiere descargar los datos. Si en
ese tiempo no se pulsa el botón, el sistema vuelve a quedar inactivo. Si el botón es pulsado, se apaga el
LED y se transfieren los datos guardados en la cola mediante una secuencia de paquetes con el
siguiente formato:
packet.frame[9] = ‘D’ indicando que se envían datos
packet.frame[10] = número de móvil
packet.frame[11] = nº de secuencia del paquete
packet.frame[12] = nodo fijo registrado
packet.frame[13] = hora registrada
packet.frame[14] = minutos registrados
7.2.3 Reloj
El reloj implementado utiliza un timer con tick (TIMER B del MSP430), configurado para
interrumpir cada 500 ms, utilizando el VLO (Very-Low power Oscillator, 12 kHz) como fuente de reloj.
NOTA: Se utilizó esta fuente para el reloj, y no el cristal de la radio como se había hecho en los
laboratorios del curso, debido a que la radio utiliza los pines de salida de dicho reloj para otros fines.
Además por la forma de conexionado del módulo RF2500, la configuración de estos pines impide el uso
de un cristal externo. No se comprobó la precisión de este reloj, pero esto no sería una limitante para
este sistema ya que no se miden intervalos de tiempo mayores a 12hs.
La hora se guarda en una estructura de datos que tiene los campos:
horas
minutos
segundos
milisegundos
Control de recorrida
2013
13
7.3 Implementación del nodo base El nodo base, a diferencia del móvil y el fijo, se utiliza conectado a la PC mediante puerto USB para
interactuar con el terminal a través de la UART. La recepción y transmisión de caracteres por la UART
funcionan de la siguiente manera:
Recepción: Cada vez que la UART recibe un carácter, la ISR asociada lo guarda en un buffer
circular RxBuff. Cuando se recibe el carácter de fin de mensaje ('\r' ó '\n') se le indica a la aplicación que
el buffer de recepción contiene un mensaje completo mediante la bandera datoRecibido.
Transmisión: Para iniciar una transmisión por el módulo UART, se utiliza la bandera enviarDato, la
cual es leída en el loop principal. Para transmitir un mensaje se utiliza una función que guarda los datos
en un buffer circular TxBuff, envía el primer carácter y habilita las interrupciones de registro vacío.
Luego, cuando se finaliza la transmisión de un carácter, se vacía el mencionado registro y se ejecuta la
ISR correspondiente, la cual obtiene de TxBuff un nuevo carácter a trasmitir. Cuando se envía el último
carácter, completando la transmisión de los datos, se deshabilita la interrupción de registro vacío.
La rutina de manejo de transmisión hace uso de una bandera flagTx, la cual indica si se debe
enviar “OK” (flagTx = 0) o los datos guardados (flagTx = 1).
7.3.1 Inicialización de hora de un nodo móvil
Para inicializar la hora en un nodo móvil, se ingresa el comando PHhhmmss, donde hh indica las
horas, mm los minutos y ss los segundos, y se presiona la tecla enter. La ISR de recepción por UART
detecta fin de mensaje y activa la bandera datoRecibido, lo cual se detecta en el loop del Round Robin y
se llama a la función que maneja la recepción de comandos. Si el comando recibido es el de programar
hora (PHhhmmss) se guardan los valores de la hora a utilizar y se envían a través de la radio en el
formato ya descripto en la sección 7.2.2.
Además, pone un uno en la bandera enviarDato que se utiliza en el loop principal para indicar que
hay que transmitir un dato por la UART, y un cero en la bandera flagTx, indicando que se debe enviar un
OK por el módulo UART, y se envía, mediante el procedimiento indicado al inicio de la sección 7.3,
desplegando el mensaje en el terminal.
7.3.2 Descarga de datos de un nodo móvil
Cuando se recibe una ráfaga de paquetes provenientes de un nodo móvil, con el formato
especificado en la sección 7.1. De la misma manera que los nodos anteriores, se detecta que el móvil se
encuentra lo suficientemente cerca como para aceptar la comunicación, se responde con identificación
de base. Se inicia un contador de tiempo (de 5 segundos), donde se activa un flag Rx_Datos, indicando
que lo que se va a recibir son datos, y se enciende el LED rojo. Si en ese tiempo se reciben los datos, se
guardan en una cola circular colaBase, y se apaga el LED, de no ser así, al expirar el timer, se apaga el
LED y se vuelve al estado inactivo.
El formato en el que se reciben los datos por parte del nodo móvil es como el detallado en la
sección 7.2.2.
Control de recorrida
2013
14
7.3.3 Despliegue de datos
Cuando se desea ver los datos que se guardaron en el nodo base, se ingresa en el terminal el
comando MD (mostrar datos) y digitar enter. Mediante el método ya descripto al inicio de la sección 7.3,
el manejador de recepción de la UART identifica la instrucción, activa el flag enviarDato indicando que
hay que enviar un mensaje por la UART, y pone en 1 flagTx, indicando que el mensaje que hay que
enviar son los datos guardados en la cola de datos. El manejador de transmisión obtiene la información
de cada uno de los datos, los guarda en el buffer de transmisión y los envía por la UART, desplegándose
así en pantalla, de la forma:
Nodo móvil – Nodo fijo registrado – Hora correspondiente
8. Pruebas Para probar el funcionamiento del sistema se utilizaron tres dispositivos. Se programó un nodo
fijo, uno móvil y uno base (los dos primeros se usaron con pilas y el último conectado al PC) y se realizó
la siguiente prueba:
Ingresar el comando de puesta en hora (PHhhmmss) en el terminal.
Verificar que el LED verde del nodo móvil se enciende indicando que se realizó la comunicación.
Acercar el nodo móvil al fijo y presionar el botón.
Verificar que el LED verde del nodo móvil se enciende indicando que se realizó la comunicación.
Repetir los dos pasos anteriores (para guardar más datos).
Acercar el nodo móvil al base y presionar el botón, ver que en ambos nodos se encienda el LED
rojo (indicando la espera de confirmación de descarga de datos).
Volver a presionar el botón y observar que ambos LEDs rojos se apagan.
Ingresar el comando de mostrar datos (MD) en el terminal del PC y verificar que se despliegan
los datos correctamente.
El resultado de la prueba se muestra en la siguiente captura del terminal, se ve el comando de
programar la hora y el comando de mostrar datos con sus respectivas respuestas. Los datos se muestran
en el formato:
Nodo móvil – Nodo fijo registrado – Hora correspondiente
Control de recorrida
2013
15
Captura de terminal usado en la prueba
9. Conclusiones Se concluye que se cumplió satisfactoriamente con los objetivos planteados previamente. Se logró
realizar un proyecto completo de sistemas embebidos para aplicar los conceptos adquiridos durante el
curso y experimentar con diferentes funcionalidades de los microcontroladores.
Además se agregaron funciones que no se habían propuesto al inicio del proyecto. Se creó un
sistema completo a partir de una aplicación sencilla de comunicación entre dispositivos mediante RF
que permite controlar el recorrido de un guardia de seguridad y obtener los datos de forma correcta.
Como no se utilizaron los campos origen y destino de los paquetes, el sistema creado permite ser
mejorado, por ejemplo, creando una red de sensores inalámbricos entre los nodos fijos para la
transferencia de datos o verificación en tiempo real de que el recorrido sea correcto. Otra posible
mejora podría ser implementar un software para el manejo de los datos sin tener que utilizar un
terminal.
Control de recorrida
2013
16
10. Anexo
10.1 Conceptos aplicados Como conceptos aplicados del curso, se destaca el aprendizaje de programación en lenguaje C. Se
profundizó bastante en el uso del IAR como entorno de desarrollo y como debugger del sistema.
La aplicación desarrollada se basa fuertemente en la arquitectura Round Robin con interrupciones
impartida durante el curso, ya que fue una solución muy adecuada para resolver el problema, por su
sencillez, y el hecho de no sobrecargar de funcionalidades a las rutinas de atención a interrupciones.
Esta estructura también le da claridad al código de programa.
Por otro lado, nos enfrentamos al estudio del hardware utilizado (uso de manuales, tutoriales,
códigos de ejemplo), lo que nos introduce al estudio de dispositivos, en cuanto a funcionalidades,
limitaciones, etc., aplicable en un futuro al realizar tareas similares o de mayor complejidad.
10.2 Especificación del proyecto Nombre del proyecto: Control de recorrida.
Integrantes: Ignacio Camps, Martín Driedger, Rodrigo Espiga.
Tutor: Pablo Mazzara.
1. Descripción del problema a ser resuelto: Registrar que un guardia de seguridad cumpla con su
recorrido utilizando señales de radiofrecuencia.
2. Antecedentes: Proyecto Localizador (2009), localizadores por RF en general.
3. Objetivos del proyecto: Se pretende lograr un sistema capaz de controlar la recorrida de un guardia
de seguridad. El guardia contará con un módulo y deberá pasar por puntos de control donde se
detectará su presencia mediante el enlace creado entre los módulos (RSSI/LQI e identificación de
los nodos). El nodo fijo transmite un número que lo identifica y el nodo móvil guarda este dato y
registra la hora. Se agregarán funcionalidades conforme se vayan cumpliendo los objetivos
principales.
4. Alcance del proyecto: Lograr que se detecte la proximidad entre los módulos y que se registre el
recorrido. No se determinará la posición exacta del guardia. Se podrá incluir un botón para hacer un
control por parte del usuario utilizando además los leds indicadores para indicar al guardia que se
registró su pasaje por el punto de control. Además, al final de la jornada se deberá tener guardada la
información en un ordenador, es decir, se implementará una forma de pasar la información que
recabó el nodo móvil a una PC.
5. Descripción del sistema:
1. Descripción funcional: El sistema constará de al menos tres nodos. Uno móvil, portado por
el guardia, otro fijo de puesto de control y otro también fijo usado como base. El nodo
móvil al acercarse al del puesto de control será detectado y verificado mediante algún
método que se definirá. Una vez detectado se dará una indicación mediante un led y
quedará registrada la hora y la información del nodo fijo en el nodo móvil. Una vez
finalizada la recorrida el guardia descargará los datos guardados en el nodo base.
Control de recorrida
2013
17
2. Diagrama de bloques:
RF uC
Nodo fijo de control
RF uC
Nodo móvil
RF uC
Nodo base PC
Punto a Punto Punto a Punto USB
6. Requerimientos y restricciones del sistema:
1. Procesamiento y memoria: El MSP430 cuenta con 32KB de flash y 1KB de RAM, mientras
que el procesador es de 16MHz.
2. Tiempos de respuesta: Se pretende que el sistema responda lo suficientemente rápido
como para no interferir con la labor del guardia.
7. Diseño preliminar:
1. Plataforma de hardware: El hardware a utilizar será el ez430-RF2500. Eventualmente se le
agregará un botón para confirmación por parte del guardia.
2. Arquitectura de software: Se utilizará Round Robin con interrupciones (para el nodo que
está en la base) y una cola de datos para guardar la información en el nodo móvil.
8. Planificación:
1. Actividades
Semana 1:
- Estudiar el funcionamiento de la radio (forma de comunicación, configuración de los
registros, configuración de la potencia y sensibilidad del receptor).
- Estudiar los protocolos de comunicación punto a punto proporcionado por Texas
Instruments.
- Estudiar la colocación de un botón.
Semanas 2, 3 y 4:
- Codificar
Semana 5:
- Elaborar informe y preparar defensa
2. Pruebas a realizar:
- Probar la comunicación entre los nodos, los protocolos, la distancia, la determinación
de RSSI, la potencia a utilizar.
3. Hito intermedios: Presentación de avance: comunicación punto a punto entre módulo fijo y
móvil, determinación del RSSI en función de la distancia.
4. Cronograma:
- Semana 1: Estudio
- Semanas 2, 3 y 4: Codificación
- Semana 5: Documentación
Control de recorrida
2013
18
10.3 Planificación del proyecto En cuanto a la planificación, hay que destacar que si bien no se había detallado con exactitud qué
se iba a programar cada semana se logró cumplir satisfactoriamente con los tiempos requeridos. Es
importante mencionar que la cantidad de horas dedicadas al proyecto fue muy superior a lo que en un
principio se estimó.