Control de recorrida...Control de recorrida 2013 2 1. Resumen Este proyecto implementa un sistema basado en microcontroladores MSP430 que, utilizando un módulo de radiofrecuencia

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.


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


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).


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:


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


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.


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.


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.

http://www.ti.com/tool/simpliciti


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.


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.


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).


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


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[12] = hora

packet.frame[13] = minutos


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[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


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.


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


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.


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.


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


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ó.

Documents

Control de recorrida...Control de recorrida 2013 2 1. Resumen Este proyecto implementa un sistema basado en microcontroladores MSP430 que, utilizando un módulo de radiofrecuencia