Autorizada la entrega del proyecto al alumno - IIT

Autorizada la entrega del
proyecto al alumno:
Jorge Nadal Muñoz
LOS DIRECTORES DEL PROYECTO
José Daniel Muñoz Frías
Guillermo Pallarés Castillo
Fdo:
Fecha:
Vº Bº del coordinador de proyectos
Álvaro Sánchez Miralles
Fdo:
Fecha:
UNIVERSIDAD PONTIFICIA
COMILLAS
ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA (ICAI)
INGENIERO INDUSTRIAL
PROYECTO FIN DE CARRERA
CUENTAKILÓMETROS CON
MEMORIA
AUTOR: Nadal Muñoz, Jorge
DIRECTORES: Muñoz Frías, José Daniel
Pallarés Castillo, Guillermo
MADRID, septiembre de 2008
Resumen
3
Resumen
En los últimos años, el desarrollo de la electrónica y la tecnología
ha sido enorme permitiendo un gran avance en el campo de la transmisión
inalámbrica. Hoy existen muchos sistemas distintos y muy eficientes de
transmisión inalámbrica, desde infrarrojos hasta bluetooth pasando por
tecnología Zigbee. Estos sistemas se han implantado en toda clase de
aparatos incluyendo, por supuesto, los cuentakilómetros. Hoy en día el
cable está desechándose dando lugar a la conexión inalámbrica. La
comodidad es una prioridad en nuestros días y un cable no lo es, ya que se
puede enredar y dificulta la colocación del cuentakilómetros. Por ese
motivo, un cuentakilómetros inalámbrico gusta y tiene una buena acogida
en el mercado a pesar de que en principio se pueda pensar que no tanto.
El objetivo del proyecto es realizar un cuentakilómetros que
muestre en el display los parámetros calculados a partir de la señal del
sensor, almacene los datos en una memoria EEPROM y tenga capacidad
de descargar los datos al ordenador. Para alcanzar este objetivo, se utilizan
dos tarjetas de desarrollo idénticas que se conectan a los periféricos. Las
tarjetas de desarrollo cuentan con un microcontrolador de ocho bits que
maneja toda la información, un transceiver (dispositivo encargado de
implementar el protocolo de comunicaciones) y una antena impresa por la
cual se realiza la transmisión inalámbrica. El dispositivo cuenta con un
sensor localizado en la rueda delantera de la bicicleta. Cuando la rueda da
una vuelta, el sensor genera una señal que interrumpe el programa
principal de la tarjeta emisora. En la tarjeta emisora, se calculan los
parámetros de distancia y velocidad y se transmiten a la tarjeta receptora a
través de la antena utilizando tecnología Zigbee. La tarjeta receptora,
recibe los datos que se envían a la memoria y al display. La mejor manera
de observar este sistema de transmisión es mediante un diagrama de
Resumen
4
bloques como el que se muestra en la figura 1, para ver como van
conectados todos los dispositivos del proyecto.
PC
Vía serie
Display
Sensor
Bus i2c
Entrada digital
Tarjeta
emisora
Tarjeta
SMAC
receptora
Bus i2c
Memoria
Figura 1: Esquema de conexiones
En primer lugar, se realiza el funcionamiento de la tarjeta
receptora. A ella van conectados el display y la memoria y es esta tarjeta la
que se comunica con el ordenador. La tarjeta receptora no se comunica con
sus periféricos de cualquier manera. Así como el sensor envía la señal a la
tarjeta emisora directamente a través de un par pines de entrada/salida,
con la tarjeta receptora no se pudo actuar de la misma manera debido a
que no se tenían suficientes pines disponibles. Por ello, se decidió adquirir
un display y una memoria que se comunican a través de un bus i2c, como
se puede observar en el diagrama de bloques de la figura 1, que tiene
como ventaja que sólo necesita dos pines para hacer la transmisión. Dicho
bus se configuró por software ya que la tarjeta no contaba con ninguno
libre para su uso. Por otro lado, para que el funcionamiento fuera correcto,
también
se
diseñaron
circuitos
electrónicos
para
establecer
la
Resumen
5
comunicación con el microcontrolador de acuerdo con la documentación
de los dispositivos.
En segundo lugar, se elabora la tarjeta emisora. En la tarjeta
emisora es donde se aloja el sensor. La señal que genera el sensor cuando
el imán pasa por su lado es la que se envía a la tarjeta emisora y se
procesa. Para que la señal generada por el sensor sea útil lo necesario es
realizar un circuito de acondicionamiento del sensor para eliminar los
rebotes y reducir la corriente que atraviesa el sensor. La señal generada
debe interrumpir al programa principal y calcular la distancia recorrida y
la velocidad. La distancia recorrida se calcula de manera muy sencilla,
sumando a una variable global el perímetro, ya que el sensor generará una
interrupción por teclado cada vez que la rueda dé una vuelta. Para
calcular la velocidad, se ha configurado un timer que esté continuamente
corriendo y cada vez que se reciba una interrupción se lea el tiempo
actual. A partir del tiempo actual, restándole el tiempo anterior, se calcula
el tiempo que ha tardado la rueda en dar una vuelta y, dividiendo el
perímetro por dicho tiempo, se obtiene la velocidad.
Una vez que se tienen ambas tarjetas trabajando por separado, se
deben conectar entre sí de forma inalámbrica como se muestra en el
diagrama de bloques de la figura 1 mediante una línea punteada. Para ello
se utiliza la antena que debe ser configurada a partir de un transceiver.
Este transceiver se configura con una segunda herramienta llamada
Freescale Beekit integrada en el entorno de desarrollo cuya función es
desarrollar un código intermedio que configura la transmisión y recepción
a través de la antena. Zigbee es la tecnología de transmisión inalámbrica
que se utiliza en el proyecto. La tecnología Zigbee es muy parecida al
Bluetooth sólo que tiene un menor ancho de banda y consume menos.
Éstos son los motivos principales por los cuales se utiliza esta tecnología
para el cuentakilómetros, ya que no necesita una transmisión muy rápida
Resumen
6
ni compleja y funciona a pilas, por lo que un menor consumo permitirá un
importante ahorro en baterías. El alcance utilizando la tecnología Zigbee
es pequeño, pero para un cuentakilómetros es más que suficiente, al ser la
distancia entre el sensor y la pantalla de tan sólo unos treinta centímetros.
El transceiver implementa la capa física de Zigbee, aunque en este
desarrollo se ha optado por una capa lógica más simple denominada
SMAC.
Como
resultado
del
proyecto,
se
ha
construido
un
cuentakilómetros que cumple todas las funciones anteriormente descritas
excepto la de comunicación con el PC mostrado en el diagrama de bloques
mediante una línea punteada, pero supone una buena base para poder
crear un cuentakilómetros completo para poder ser comercializado. A
través del puerto i2c o utilizando la comunicación inalámbrica se pueden
integrar más componentes, como por ejemplo un pulsómetro, de manera
sencilla. Para terminar, durante la construcción del cuentakilómetros se
hicieron varias pruebas con el sensor y el display resultando satisfactorias.
Las funciones de velocidad media y velocidad máxima no se implantaron,
por lo que el cuentakilómetros sólo mide velocidad instantánea y
distancia. La memoria finalmente tampoco se implantó junto con el resto
del proyecto pero las funciones de manejo de la memoria si se realizaron y
mediante un pequeño programa se comprobó su correcto funcionamiento.
Summary
7
Summary
During the past few years, the developments in electronics and
technology have been huge leading up to the great wireless transmission
field. At the present time, there are many different and very efficient
wireless transmission systems such as infrared, bluetooth or Zigbee
technology. These systems have been installed on every kind of items
including, of course, the speed meter. Nowadays wires are being dropped
to let the wireless connections in. Comfort is a priority in our lives today
and wires do not help, they get tangled up and they make installing a
speed meter harder. This is the reason why a wireless speed meter could
be successful in the market.
The aim of the project is to build a speed meter that shows in a
display the parameters calculated from the signal coming from the sensor,
saves the data in an EEPROM memory and has the capacity of
downloading the data to a computer. For achieving this objective, two
electronic boards are used connected with the devices. The electronic
boards include an eight bit microcontroller that manipulates all the
information, a transceiver (device in charge of implementing the
communications protocol) and a printed antenna by which the wireless
transmission is done. The device has a sensor located at the front wheel of
the bicycle. When the wheel turns once, the sensor generates a signal that
interrupts the main program of the emitter board. In the emitter board, the
distance and speed parameters are calculated and transmitted to the
receiver board with the antenna using Zigbee technology. The receiver
board receives the data that is sent to the memory and the display. The
best way to see the connections is by the diagram shown in figure 1.
Summary
8
PC
Series communication
Display
Sensor
I2c bus
Digital input
Emitter
board
Receiver
SMAC
board
I2c bus
Memory
Figure 1:Scheme of connections
In the first place it is necessary to make the receiver board work.
The display and the memory are both connected to it, and it is this board
that communicates with the computer. The receiver board doesn’t
communicate with the other devices randomly. The sensor sends the
signal to the receiver board through a couple of in and out pins, whilst it
was not possible to do the same with the receiver board since there were
not enough free pins. Because of this reason, the decision was taken to
communicate the memory and the display via an i2c bus, as shown in
figure 1, which only needs two pins to get the transmission done as a
major advantage. This bus was configured by software because the board
did not have a free one for its use. Be that as it may, in order for it to work
correctly electronic circuits were designed to establish the communication
with the microcontroller following the instructions in the devices’
datasheets.
Summary
9
Secondly, the emitter board is built. On the emitter board is where
the sensor is located. The signal generated by the sensor when the magnet
passes by is sent to the emitter board and is processed. It is necessary to
design a conditioning circuit for the sensor in order to make the signal
generated useful, for eliminating rebounds and reducing the current
through the sensor. The generated signal has to interrupt the main
program and calculate both, distance and speed. The distance is calculated
in a very easy way by adding the perimeter to a global variable as the
sensor generates a keyboard interrupt each time the wheel turns. For
calculating the speed, a timer was configured, which is running forever
and the time is read each time an interrupt occurs. The time the wheel
takes to turn once is obtained subtracting the last time to the actual time
and, dividing the perimeter by this time, we obtain the value of the speed.
Once you have both boards working separately, they must be
connected. For this purpose, the antenna which must be configured by a
second microcontroller is used and wireless connection is achieved as
shown with a dotted line in the diagram. This microcontroller is
configured by a second tool called Freescale Beekit, integrated in the
programming tool whose function is to develop an intermediate code
which configures the transmission and reception through the antenna.
Zigbee is the wireless transmission technology used in the project. The
Zigbee technology is very similar to Bluetooth, only that it has a smaller
bandwidth and consumes less. This are the most important reasons for
which this technology is used for the speed meter, given that it doesn’t
need a very quick nor complex transmission and it works with batteries,
which means that a smaller consume will allow an important save in
batteries. The range using the Zigbee technology is not much, but it’s more
than enough for a speed meter, given that the distance between the sensor
and the screen is of only about thirty centimetres. This second
Summary
10
microcontroller implements the physical Zigbee layer, even though in this
development an easier logic layer called SMAC is used.
As a result of the project, a speed meter was built which satisfies all
the functions described before except the communication with the PC, as
shown with a dotted line in the diagram before, but it is a solid basis for
being able to build a speed meter with all the functions and being able to
be commercialized. Also, through the i2c bus or using the wireless
communication, more components can be added to the device like, for
example, a pulse-meter very easily. Finally, during the building of the
speed meter a series of tests were made with the sensor and the display
with satisfactory results. The mean velocity and the maximum velocity
were not implemented in the end, leaving the speed meter measuring only
current speed and distance. The memory wasn’t either finally joined
together with the rest of the project, but the functions for manipulating the
memory were done and using a small program was proofed that it
worked correctly.
DOCUMENTO Nº1: MEMORIA
Índice
13
Resumen ............................................................................................................3
Parte I
Memoria.........................................................................................153
Capítulo 1 Introducción..................................................................................164
1
Estudio de los trabajos existentes / tecnologías existentes ..........175
2
Motivación del proyecto.......................................................................19
3
Objetivos ...............................................................................................220
4
Metodología / Solución desarrollada...............................................220
5
Recursos / herramientas empleadas .................................................231
Capítulo 2 Hardware: Componentes............................................................242
1
Introducción..........................................................................................242
2
Tarjeta de desarrollo ...........................................................................264
3
Display LCD .........................................................................................286
4
Memoria EEPROM ..............................................................................308
5
Sensor.....................................................................................................320
Capítulo 3 Software.........................................................................................353
1
Introducción..........................................................................................353
2
Comunicación inalámbrica ................................................................386
3
La tarjeta emisora.................................................................................408
4
La tarjeta receptora ................................................................................39
5
Programación final ..............................................................................464
Capítulo 4 Resultados/Experimentos...........................................................486
Capítulo 5 Conclusiones...................................................................................49
Índice
14
Capítulo 6 Futuros desarrollos ......................................................................520
Bibliografía .......................................................................................................542
Parte II
Estudio económico.......................................................................553
Parte III
Manual de usuario.......................................................................575
Parte IV
Código fuente ...............................................................................608
Parte V
Anexos............................................................................................708
Anexo A: el bus i2c ............................................................................................69
Parte I MEMORIA
Memoria. Introducción
16
Capítulo 1 INTRODUCCIÓN
“Cuentakilómetros con memoria” es un proyecto que se trata de
elaborar un cuentakilómetros o ciclocomputador de bicicleta sofisticado.
Como indica el título del proyecto, el cuentakilómetros contará con una
memoria no volátil en la que poder almacenar los datos de una jornada.
Además, el cuentakilómetros será inalámbrico (la transmisión se hará a
través de una antena impresa en las tarjetas electrónicas) y se podrá
conectar con el ordenador a través de un puerto serie para poder utilizar
en él los datos almacenados en la memoria.
El cuentakilómetros está formado por dos tarjetas de desarrollo
que cuentan con un micro de ocho bits, un display, una memoria y un
sensor convencional de bicicleta y el objetivo es juntarlo todo y hacer que
funcione como lo que pretende ser.
Este documento desarrolla todos los pasos que se han ido
ejecutando durante el proyecto hasta llegar al resultado final. En este
primer capítulo se introduce el proyecto, donde se explican los principales
aspectos del mismo sin entrar en detalle. En los siguientes capítulos es
donde se detallan los pasos que se han ido dando hasta conseguir el
cuentakilómetros.
El proyecto se ha dividido en dos partes diferentes pero muy
relacionadas entre sí. El capítulo dos trata sobre los distintos componentes
del hardware que se han utilizado para formar el cuentakilómetros. Da
todos los detalles de cada uno de ellos y explica los circuitos electrónicos
que se han tenido que montar para conseguir su correcto funcionamiento,
además de resaltar el porqué de haber escogido esos modelos y no otros.
A medida que los componentes del cuentakilómetros van estando
Memoria. Introducción
17
preparados para funcionar, se tienen que ir programando para comprobar
su funcionamiento, ya que los componentes por sí solos no se puede
utilizar para nada por muy bien que esté realizada la parte hardware. Esto
se explica en el capítulo tres, donde se detallan todos los pasos que ha ido
dando la programación del cuentakilómetros hasta su resultado final. Son
dos partes diferentes que se han tenido que desarrollar paralelamente para
ir dispositivo a dispositivo comprobando su correcto funcionamiento.
1 Estudio de los trabajos existentes / tecnologías existentes
Los cuentakilómetros en bicicletas son aparatos relativamente
nuevos que han aparecido gracias a los avances tecnológicos. Al principio,
hace quince o veinte años, los cuentakilómetros no medían nada más que
distancia y velocidad y el sensor estaba unido a la pantalla con un cable.
Desde casi el principio, todos los cuentakilómetros incluían una pequeña
memoria para almacenar el valor de la distancia total recorrida. El tamaño
nunca se ha excedido demasiado ya que desde un principio se sabía que
tenía que ir alojado en el manillar que es un suporte de tamaño reducido.
El precio era un inconveniente mayor para adquirir uno de éstos, pero la
evolución de la electrónica ha permitido reducir en gran medida los
precios de los cuentakilómetros. Estos cuentakilómetros aún se venden
hoy, pero a precios muy bajos al aparecer otros más sofisticados.
Hoy en día, el mundo de los cuentakilómetros para bicicleta está
muy estudiado y la tecnología existente está muy avanzada. Los
cuentakilómetros de hoy no sólo miden los parámetros relacionados con la
propia acción del ciclismo, como distancia y velocidad, sino que también
son capaces de medir el ritmo cardiaco y la cadencia de pedaleo e incluyen
reloj.
Unos años después aparecieron unos cuentakilómetros un poco
más sofisticados que transmitían la información de manera inalámbrica, lo
Memoria. Introducción
18
que permite evitar el cable que conecta el sensor con el display. Estos
cuentakilómetros son un poco más caros y se han extendido de manera
rápida debido al gran avance de la tecnología digital y la electrónica, que
han permitido poder diseñar estos cuentakilómetros a precios y tamaños
razonables. La mayoría de los cuentakilómetros que cuentan con
transmisión inalámbrica lo hacen de manera 100% digitalizada y
codificada ofreciendo una transmisión muy segura.
Finalmente, aparecieron en el mercado dispositivos aún más
especiales que incluyen la posibilidad de conectarse al ordenador y
utilizar en él los datos almacenados en la memoria del cuentakilómetros.
Hoy en día, hay pocos dispositivos que tengan esta función y los precios
se disparan.
En la tabla 1 se muestran tres modelos de cuentakilómetros, cada
uno con los desarrollos tecnológicos contados con anterioridad:
Marca
Funciones
Precio
Cateye
• Velocidad actual
14,99€
• Velocidad máxima
• Distancia recorrida
• Distancia total
• Reloj
Memoria. Introducción
19
Cateye
• Velocidad actual
45€
• Velocidad máxima
• Dos
velocidades
medias
• Dos
distancias
parciales
• Dos
tiempos
empleados
• Distancia total
• Reloj
• Transmisión
inalámbrica
Garmin
• Cadencia
de
pedaleo
• Ritmo cardiaco
• Velocidad
• Tiempo
• Calorías quemadas
• Altitud
240€
Memoria. Introducción
20
• Transmisión
inalámbrica
• Conexión con el
ordenador
software
con
Taining
Center
Tabla 1: Mercado cuentakilómetros
Otros menos comunes son capaces de medir altitud e inclinación y
tienen brújula y termómetro. Como se puede observar la tecnología de
estos dispositivos es muy sofisticada. Evidentemente, los dos últimos
cuentakilómetros disponibles en el mercado analizados necesitan un
dispositivo conectado al cuerpo del ciclista para medir parámetros como el
ritmo cardiaco. Los últimos cuentakilómetros tienen capacidad de medir
una gran variedad de cosas y almacenar en la memoria una gran cantidad
de parámetros en cada jornada, cuentan con conexión inalámbrica y el
último se puede conectar al ordenador. Existen distintas conexiones
posibles con el ordenador pero, por lo que se ha podido averiguar, los
cuentakilómetros actuales en el mercado se conectan por infrarrojos o a
través de un puerto USB. Sin embargo, seguro que existen hoy en día
cuentakilómetros que se comunican con el PC utilizando tecnología
bluetooth. Por tanto, hoy en día incluso la conexión entre el
cuentakilómetros con el ordenador puede ser inalámbrica. En nuestro
caso, la comunicación se realizará a través de un puerto serie.
El problema más serio que presentan estos dispositivos es el
precio. Como se puede ver en la tabla superior, el cuentakilómetros sin
comunicación con el ordenador cuesta 45€, mientras que el precio del que
cuenta con comunicación con el PC asciende hasta los 240€. Sin embargo,
este
proyecto,
aunque
cuenta
con
menos
funciones
que
los
Memoria. Introducción
21
cuentakilómetros disponibles en el mercado analizados y se comunica con
el ordenador de una manera un poco antigua, se puede llevar a cabo por
un precio menor que ese, consiguiendo cuentakilómetros sofisticados
asequibles para todo el mundo.
2 Motivación del proyecto
El ciclismo es un deporte muy extendido a nivel aficionado. Al
igual que todos los niños juegan al fútbol desde pequeños, también tienen
una bicicleta. Por ello, es un mercado interesante para las empresas el de
los cuentakilómetros para todas esas bicicletas. Además, hay mucha gente
adulta que le gusta practicar este deporte para mantener el estado de
forma y, especialmente a esa gente, le gusta ver sus progresos.
La motivación de este proyecto es poder ofrecer a los usuarios un
cuentakilómetros inalámbrico con una memoria no volátil para guardar
los datos de la jornada. Esto permitirá ahorrarse los cables que siempre
pueden dar problemas y no son nada cómodos. Además, el dispositivo se
podrá conectar al ordenador a través de un puerto serie para poder
descargarse los datos en él y poder hacer gráficas, lo que permitirá
observar los progresos realizados.
Observando el mercado de cuentakilómetros para bicicleta, se
puede ver como existen ya cuentakilómetros muy sofisticados que ofrecen
dispositivos inalámbricos con conexión al ordenador a través de un puerto
USB. Además, estos cuentakilómetros tienen muchas funciones distintas.
Sin embargo, el gran problema del mercado es el precio. Un
cuentakilómetros inalámbrico pero sin posibilidad de conexión al
ordenador cuesta 45€ y uno que incluye todo cuesta 240€. Por tanto una
motivación añadida es conseguir un cuentakilómetros simple y sofisticado
por un precio menor.
Memoria. Introducción
22
3 Objetivos
El objetivo principal del proyecto es diseñar un cuentakilómetros
inalámbrico con memoria. El sistema tendrá que, con un sensor de
bicicleta convencional, procesar la señal que le llegue a la tarjeta y calcular
ciertos parámetros como la velocidad y la distancia recorrida.
Posteriormente, la velocidad se enviará a través de una antena a una
segunda tarjeta donde se mostrará el valor de los parámetros en un
display y se archivará en una memoria EEPROM que es no volátil.
Finalmente, el sistema podrá comunicarse con un PC a través de un puerto
serie y descargar los datos para su posterior uso en el mismo como el
usuario quiera.
4 Metodología / Solución desarrollada
El proyecto se puede separar en dos partes diferentes pero muy
relacionadas entre sí. Estas dos partes son la parte hardware y la parte
software:
•
Hardware:
o
Investigar
el
funcionamiento
de
los
elementos
externos, tales como la memoria EEPROM, el display y el
sensor.
o
Se diseñará un circuito de acondicionamiento para el
sensor que se colocará en la tarjeta emisora.
o
Diseñar los circuitos necesarios para comunicar el
display y la memoria con la tarjeta receptora.
•
Software:
Memoria. Introducción
o
23
Estudiar o analizar toda la documentación de las
tarjetas de desarrollo que viene proporcionada en el CD.
o
Realizar la programación de la tarjeta emisora que
cuenta con una interrupción por teclado generada por la
señal producida por el sensor y todo el procesamiento de
dicha señal para calcular distancia y velocidad.
o
Diseñar la programación de la tarjeta receptora que
debe procesar los datos recibidos mostrándolos en el display
y almacenándolos en la memoria.
o
Realizar
la
programación
de
la
comunicación
inalámbrica utilizando protocolo Zigbee.
5 Recursos / herramientas empleadas
La gran ventaja del proyecto es que los recursos y herramientas
empleadas son sencillos y escasos. Simplemente, se necesitan dos tarjetas
de desarrollo que incluyen un micro de 8 bits, un sensor, un display LCD
y una memoria EEPROM de 64kbit.
En
cuanto
al
software
utilizado
para
elaborar
toda
la
programación, se utilizará el software de Freescale llamado CodeWarrior.
Memoria. Hardware: Componentes
24
Capítulo 2 HARDWARE: COMPONENTES
1 Introducción
Como ya se ha dicho con anterioridad, el proyecto tiene dos partes
diferenciadas pero estrechamente relacionadas. Para poder llevar a cabo la
elaboración del proyecto, primero se debe montar el hardware y luego
desarrollar el software que hará funcionar ese hardware. Este capítulo se
centra en explicar los distintos componentes que se han utilizado para la
elaboración del cuentakilómetros, desde el porqué de escoger ese modelo
y no otro hasta sus características pasando por toda la electrónica que
necesitan para funcionar.
La parte hardware del proyecto está constituida por varios
componentes y la mayoría de ellos se pueden averiguar de manera
intuitiva a partir del título del proyecto. Al ser el proyecto un
cuentakilómetros con memoria, se necesitará, en primer lugar, un display
donde mostrar la velocidad de la bicicleta, en segundo lugar, un sensor
que detecte el paso de la rueda y, en último lugar, una memoria no volátil
EEPROM donde poder guardar los datos de la jornada.
Obviamente, un display, un sensor y una memoria EEPROM por
si solos no pueden funcionar. Son necesarias unas tarjetas de desarrollo
que procesen las señales mediante un microcontrolador de 8 bits que
contienen. Las tarjetas y los microcontroladores son los elementos más
importantes del proyecto. Los componentes del proyecto irán conectados
de la siguiente manera:
•
Por un lado van conectados en la rueda delantera de la
bicicleta el sensor y una tarjeta de desarrollo.
Memoria. Hardware: Componentes
•
25
Por otro lado van conectados en el manillar de la
bicicleta otra tarjeta de desarrollo, el display y la memoria.
La tarjeta de desarrollo localizada en la rueda de la bicicleta
procesará la señal y enviará la información a través de una antena que
tiene impresa en ella a la segunda tarjeta de desarrollo. Ésta se ocupará de
almacenar los datos en la memoria y mostrarlos en el display de la manera
que se explicará más adelante en el capítulo tres. Toda esta disposición se
muestra en el diagrama que bloques de la figura 1 que clarifica mucho de
lo que se ha estado hablando hasta ahora:
PC
Display
Sensor
Entrada digital
Tarjeta
emisora
Bus i2c
Tarjeta
SMAC
receptora
Bus i2c
Memoria
Figura 1: Esquema de conexiones
A continuación, vamos a analizar todos los componentes uno a
uno y el trabajo realizado en cada uno de ellos.
Memoria. Hardware: Componentes
26
2 Tarjeta de desarrollo
La tarjeta de desarrollo utilizada se trata de la denominada
MC13192-SARD
de
Freescale
(Motorola)
que
cuenta
con
un
microcontrolador de 8 bits, el MC9S08GT60. El microcontrolador es la
parte más importante de la tarjeta ya que es el que controla todas las
funciones de la tarjeta electrónica. Aparte del microcontrolador, la tarjeta
cuenta con un transceiver denominado MC13192 que controla la
transmisión y la recepción de datos a través de la antena y los envía al
microcontrolador principal. La tarjeta se alimenta a una tensión de tres
voltios de continua y esos tres voltios se pueden conseguir de dos formas
diferentes: la primera es a través de la red eléctrica, es decir, conectando a
red una fuente de alimentación, y la segunda es a partir de una pila de
nueve voltios.
La tarjeta cuenta con otros elementos que pueden ser de mucha
utilidad. En primer lugar, la tarjeta electrónica cuenta con cuatro
pulsadores y cuatro diodos led. Estos elementos han servido para poder
entender el funcionamiento de la tarjeta ya que han permitido elaborar
pequeños y simples programas para ir dominando la tarjeta. Además,
pueden resultar muy útiles para el proyecto final al ser necesario que el
usuario cambie el dato que se ve en el display, ya que el cuentakilómetros
estará preparado para mostrar tanto distancia recorrida como velocidad
instantánea y esto se hará con los pulsadores. Los diodos se encenderán
intermitentemente para mostrar al usuario que las pilas no están agotadas.
Por ejemplo, esto es útil en el caso de que el display no se encienda, para
que se pueda observar que las pilas no son el problema. En segundo lugar,
la tarjeta de desarrollo cuenta con una salida de puerto serie por la cual se
va a comunicar la tarjeta con el ordenador. Finalmente, la tarjeta cuenta
también con una salida de tres voltios que se utilizará para la alimentación
de la memoria y el display y un puerto de pines por los cuales se van a
Memoria. Hardware: Componentes
27
comunicar los periféricos con el microcontrolador. Todos estos elementos
se pueden observar en la figura 2 y la conexión entre ellos se puede ver en
el esquema de la tarjeta de desarrollo que se muestra en el datasheet de la
tarjeta de desarrollo.
Figura 2: Tarjeta de desarrollo
Así pues, para hacerse una idea de la conexión empleada en el
proyecto de todos sus elementos, se puede observar por un lado el sensor
alimentado a partir de la salida de tres voltios de una de las tarjetas de
desarrollo y la señal que genera conectada a un pin de entrada al micro.
Por otro lado, se tiene una segunda tarjeta de desarrollo cuya salida de tres
voltios sirve para alimentar tanto el display como la memoria y
conectados a distintos pines las líneas SDA y SCL de ambos periféricos por
los cuales se realiza la transmisión de datos a través del bus i2c.
Memoria. Hardware: Componentes
28
3 Display LCD
El display utilizado se trata de un display LCD que se comunica a
través de un bus i2c. El display es de la marca Batron y el modelo es el
COG-BTHQ21605-09.
La elección del display ha sido en el proyecto una de las cosas más
importantes y delicadas. Lo primero que se decidió fue que el
cuentakilómetros tendría un alcance de 99,9km/h con una resolución de
décimas, lo cual es más que suficiente para una bicicleta dirigida por
cualquier ciclista, incluso uno profesional. Por ello, se pensó en un
principio que se podrían utilizar tres displays BCD de 7 segmentos pero
pronto se desechó la idea porque se necesitarían muchos pines y, al no
disponer de tantos, se decidió finalmente utilizar este display.
El problema que tiene este display es que se comunica con el
microcontrolador a través de un bus i2c. El microcontrolador dispone de
una salida con el bus i2c implementada por hardware. Sin embargo, esta
salida se utiliza en la comunicación con el transceiver, así que se tuvo que
recurrir a implantar el bus por software utilizando las entradas y salidas
convencionales disponibles como se cuenta en el próximo capítulo. Éste
fue un inconveniente añadido que hizo perder mucho tiempo ya que no se
contaba con una cosa así.
El display utilizado tiene seis pines: uno para alimentar la pantalla
del display, otro para alimentar la lógica del display, otro para conectar
Tierra, el cuarto es un reset y los dos últimos son las líneas SDA y SCL por
las cuales se realiza la transmisión a través del bus i2c. Estos pines no se
pueden conectar directamente, sino que se tiene que diseñar un circuito
electrónico para que el display funcione correctamente. El circuito a
realizar se muestra en la figura 3 e incluye dos condensadores para fijar las
tensiones de alimentación y dos resistencias conectadas a ambos pines de
Memoria. Hardware: Componentes
29
transmisión. Finalmente, se colocó un circuito RC al pin del reset con una
constante de tiempo lo suficientemente grande como para que no actúe y
resetee el display continuamente.
R1
1
2
10k
3V C3
1
2
Pin 16
100n
C3
1
1
2
0
2
10k
2
C2
1 1u
R1
1u
Pin 14
R1
1
2
10k
VLCD VSS VDD
SDA Reset SCL
Display
Figura 3: Circuito montado para display
El circuito diseñado quedó implementado como se muestra en la
figura 3. Los valores de las dos resistencias conectadas entre los pines SDA
y SCL y los tres voltios se fijaron según la documentación del dispositivo,
al igual que el valor de los condensadores de un micro faradio. El resto de
los componentes, como ya se ha dicho con anterioridad, se hallaron
fijando la constante del circuito RC en un milisegundo. Por tanto, se fijó la
resistencia a 10kΏ y se calculó el condensador necesario que resultó ser de
100nF.
Memoria. Hardware: Componentes
30
4 Memoria EEPROM
La memoria fue el último elemento en desarrollarse en el
ciclocomputador. La memoria tiene el cometido de almacenar los datos de
velocidad, distancia y tiempo de una jornada para su uso posterior. Para
ello, se utiliza una memoria EEPROM, que es no volátil, de manera que si
se apaga el cuentakilómetros los datos seguirán almacenados en la
memoria.
Una decisión que se debía tomar con respecto a la memoria es la
manera en la que se iba a comunicar con el microcontrolador. La decisión
no fue demasiado complicada ya que, como se usó un bus i2c para la
comunicación entre el display y el microcontrolador y se tuvo que invertir
tanto tiempo en la elaboración de este bus por software, se decidió
utilizarlo también para la memoria. Por tanto, la memoria se comunica con
el micro de la misma manera que el display, es decir, a través de un bus
i2c.
Obviamente, existen muchos tipos de memoria distintas y no sólo
varía la conexión o la marca. El parámetro que más hay que tener en
cuenta en la elección de la memoria es la capacidad que tiene dicha
memoria. El cuentakilómetros tiene que medir tanto distancia como
velocidad. Como ya se ha dicho, el cuentakilómetros tendrá un alcance de
99,9km/h en velocidad, pero en distancia el alcance es de 999,99km. Los
envíos se harán cada cierto tiempo que controlaremos con una
interrupción de timer fijada a, por ejemplo, un segundo. Por ello, se sabe
que todos los datos que se vayan archivando serán a intervalos de un
segundo y no se necesitará archivar el tiempo, sino la distancia y la
velocidad. La velocidad se codifica en 10 bits, ya que con 10 bits podemos
llegar hasta 1024 y necesitamos 999, y la distancia en 17 bits, con los que
llegamos hasta 131072 y necesitamos 99999. Otra posibilidad es almacenar
solamente la velocidad al ser la distancia calculable a partir del tiempo y la
Memoria. Hardware: Componentes
31
velocidad ya que la distancia es el área que se encuentra debajo de la
curva velocidad-tiempo. Independientemente de la opción utilizada, se
decidió colocar una memoria de 64kbits de capacidad para poder tener
una gran cantidad de datos en una jornada larga que podría durar en
torno a cinco o seis horas.
La memoria que se escogió finalmente es de la marca ST y se trata
del modelo M24C64. Tiene ocho pines, tres de los cuales son un “enable”
que sirven para direccionar la memoria y que desde el microcontrolador
se pueda referir a esa memoria utilizando ese código. Esto se hace así por
si se van a utilizar varias memorias, para que los distintos datos se
almacenen en las distintas memorias. En nuestro caso, como sólo se tiene
una memoria, se ponen los tres bits a cero sabiendo que la memoria a la
que tenemos que referirnos es la memoria ‘000’. Luego se tienen otros dos
pines para la alimentación, uno se coloca a tres voltios que se obtienen de
la salida de tres voltios de la tarjeta de desarrollo y el otro a Tierra.
Posteriormente, hay un pin que sirve simplemente para impedir la
escritura en la memoria. Como se desea tanto escribir en la memoria como
leer de ella, este bit se pone a cero. Finalmente, se tienen las dos líneas SCL
y SDA correspondientes a la transmisión de datos a través del bus i2c.
Como ya ocurría con el display, todos estos pines van conectados a la
tarjeta de desarrollo, pero no pueden ir conectados directamente a los
pines de entrada/salida y a los de alimentación, sino que tiene que
diseñarse un circuito electrónico a base de condensadores y resistencias.
En concreto, se actúo de manera similar a como se hizo con el display,
colocando condensadores para fijar la tensión de tres voltios y dos
resistencias a la línea de tensión de tres voltios a partir de los pines SCL y
SDA como se muestra en la documentación del dispositivo.
Memoria. Hardware: Componentes
32
3V
C1
1
Pin 8
R2
2
1
1u
2
10k
Pin 6
R1
1
E0
VCC
E1
WC
E2
VSS
Memoria
EEPROM
2
10k
0
SCL
SDA
0
Figura 4: Circuito montado para memoria
Al igual que ocurría con el display, se muestra en la figura 4 el
circuito electrónico diseñado para el funcionamiento de la memoria. De
nuevo, son necesarias dos resistencias de pull-up entre las líneas de
comunicación i2c y la tensión de 3V y un condensador entre la tensión de
3V y Tierra. Los valores se pueden calcular siguiendo el esquema de la
documentación de la memoria, pero finalmente se decidió usar los mismos
valores que se usaron anteriormente en el circuito diseñado para el
display.
5 Sensor
El sensor es un sensor convencional de bicicleta, es decir, un
dispositivo que se activa cuando pasa por su lado un imán. Lo primero
que se hizo fue investigar como funcionaba exactamente este sensor. Para
ello se montó un circuito de acondicionamiento del sensor que no era más
que una resistencia muy elevada en serie con el sensor y todo ello
alimentado a tres voltios. El motivo de colocar una resistencia en serie era
Memoria. Hardware: Componentes
33
para limitar la corriente que atravesara el sensor, ya que no se sabía como
de robusto era y se podía romper. La señal que generaba el sensor se pudo
observar en un osciloscopio. Lo que se observó fue que el sensor no era
más que un interruptor normalmente abierto, de manera que los tres
voltios caían en el sensor cuando no se detectaba el paso del imán y la
tensión caía a cero voltios cuando pasaba el imán, ya que la conexión se
cerraba al atraer el imán el interruptor. Así pues, se observó que la señal
que generaba el sensor era una caída de un uno lógico a un cero lógico
cuando la rueda daba una vuelta y el imán pasaba por encima del sensor.
El circuito del sensor va conectado a una de las tarjetas de
desarrollo. Por un lado está conectada la alimentación que se tiene
disponible de tres voltios y por otro va conectada la tensión que cae en el
sensor a un pin de entrada al micro.
Para comprobar el funcionamiento del sensor se realizó un
pequeño programa que encendía un diodo led cuando pasaba el imán por
encima del sensor, lo apagaba la siguiente vez y así sucesivamente. Dicho
programa no funcionaba como debía y el diodo se encendía y se apagaba
aleatoriamente. Por ello, se conectó de nuevo el osciloscopio a la señal
generada por el sensor y, al hacer zoom, se observó como el interruptor
tenía muchos rebotes y, por tanto, sólo funcionaba correctamente si el
número de rebotes era impar. Por tanto, se procedió a filtrar los rebotes
para
que
el
programa
funcionara
correctamente
colocando
un
condensador formando junto con la resistencia una red RC. El
condensador tenía que ser lo suficientemente grande como para filtrar
completamente los rebotes pero lo suficientemente pequeño para que el
microcontrolador no tardara demasiado en detectar el salto del uno lógico
al cero lógico.
Memoria. Hardware: Componentes
34
SENSOR
R1
1
U1
2
330k
C1
1
2
1n
3V
0
Figura 5: Acondicionamiento sensor
El circuito de acondicionamiento del sensor se muestra en la
figura 5. El valor de la resistencia se calculó de manera que la corriente
que atravesara el sensor fuera muy pequeña cuando se cerrara el circuito.
De esta manera, con una resistencia de 330kΏ, la corriente es de tan sólo
unos 10µA la cual es lo suficientemente baja como para no ser capaz de
afectar a ningún dispositivo por muy sensible que éste sea. El valor del
condensador se decidió mediante prueba y error. Se fue incrementando el
valor del condensador y se comprobaban cada vez los rebotes que tenía el
sensor. Dichos rebotes se iban reduciendo a medida que se iba
incrementando el valor del condensador hasta que se observó que con un
condensador de 1nF los rebotes quedaban totalmente filtrados y el
programa que utilizaba el sensor funcionaba correctamente.
Memoria. Software
35
Capítulo 3 SOFTWARE
1 Introducción
Una vez explicados todos los elementos electrónicos que forman el
hardware, el capítulo 3 de la memoria se centra en el software. Los
distintos dispositivos del cuentakilómetros no pueden funcionar por si
solos, hay que configurarlos y programarlos para que ellos hagan lo que se
quiere que hagan. El microcontrolador por si sólo tampoco sirve para
nada, sin embargo, otorga un gran número de posibilidades ya que se
puede programar para que haga cualquier cosa que se desee. Por ello, esta
parte es igual de importante o más que la parte hardware.
Para la programación se ha utilizado el entorno de desarrollo de
Freescale CodeWarrior. La programación ha sido sin duda ninguna la
parte más complicada del proyecto. Al principio, cuando se reciben los
dispositivos y se tienen que poner a funcionar, es la primera vez que se
ven y se usan. Por tanto, lo primero que hubo que hacer fue leer a
conciencia todas las hojas de datos (datasheets). La programación se trata
de una cosa que requiere paciencia y avanza lentamente.
En este capítulo se explica todo el software que se ha ido
desarrollando para controlar el hardware del cuentakilómetros. El
software tiene que ser capaz de procesar la señal que recibe el
microcontrolador del sensor, calcular los distintos parámetros de distancia
y velocidad, enviar la información a través de la antena y recibirla en la
segunda tarjeta, procesar la información recibida, mostrar los resultados
en el display y guardarlos en la memoria y, finalmente, enviarlos a través
de un puerto serie al PC.
Memoria. Software
36
Para llegar al resultado final se fue avanzando poco a poco
siguiendo un orden lógico de desarrollo. En primer lugar se trató de
entender todas las funciones que disponía la tarjeta de desarrollo. Después
de investigarlas leyendo varias veces la documentación de la tarjeta
MC13192-SARD, se llegó a la conclusión de que de todas las cosas que la
tarjeta disponía sólo se necesitaban: los cuatro diodos led, los cuatro
pulsadores, los timers, la antena, el puerto de pines entrada/salida, la
salida de tres voltios de tensión y el puerto serie. Para empezar a coger
soltura con la tarjeta de desarrollo, la parte principal del cuentakilómetros,
se realizaron una serie de pequeños programas utilizando la mayoría de
estos elementos. Especial mención merece la antena y, por tanto, la
comunicación inalámbrica que causaron muchos problemas y fue la parte
más delicada del proyecto.
Una vez que se había cogido la soltura suficiente con la tarjeta de
desarrollo como para poder trabajar con ella se pasó a configurar la
memoria y el display. Como ya se ha dicho con anterioridad, estos
dispositivos tenían el gran inconveniente de que se comunicaban a través
de un bus i2c y el microcontrolador no disponía ninguno para su uso, ya
que el único se utilizaba en la conexión entre el transceiver y el
microcontrolador. Por tanto, lo primero fue hacer que los pines estándar
de entrada/salida funcionaran como si de un bus i2c se tratara. Para ello,
se tuvo que configurar un programa que manejara los datos de la misma
manera que hace dicho bus, como se verá más adelante. Al mismo tiempo
que se realizaba esta tarea, se configuraban los drivers de control del
display y la memoria, que hacen uso del software que hace que los pines
se comporten como un bus i2c, para ir comprobando que ambos
dispositivos funcionaban correctamente. Por tanto, se realizaron dos
pequeños programas utilizando ambos dispositivos para comprobar que,
efectivamente, todo funcionaba como debiera.
Memoria. Software
Una
37
vez configurada la tarjeta receptora con todo lo
anteriormente explicado, se empezó a trabajar con la tarjeta emisora. La
tarjeta emisora fue mucho más sencilla ya que el único dispositivo
conectado a ella es el sensor que no escondía ninguna sorpresa. Lo único
que se tuvo que hacer fue configurar la tarjeta para que procesara la señal
que se obtenía del sensor.
Por fin, ambas tarjetas estaban preparadas para funcionar, pero
cada una por su lado. Así pues, llegaba el momento de conectarlas entre sí
y hacer que todo funcionara como un conjunto para obtener el
cuentakilómetros deseado. Para ello, se tuvo que realizar toda la
programación de los transceivers y la configuración de las antenas para
conseguir la comunicación inalámbrica.
En la figura 6 se puede observar como las distintas funciones se
relacionan entre sí, es decir, que funciones llaman a que funciones y con
que propósito.
Tarjeta receptora
Tarjeta emisora
init_display.c
Inicialización display
Programa principal
Programa principal
(remote_controller.c)
(lighting_demo_device.c)
Interrupción
sensor
Envío display
i2c_display.c
Figura 6: Diagrama bloques software
Memoria. Software
38
2 Comunicación inalámbrica
La comunicación inalámbrica a través de las dos antenas impresas
en ambas tarjetas electrónicas ha sido una de las cosas más complicadas de
todo el proyecto. Como ya se ha dicho con anterioridad, la antena era uno
de los elementos que interesaban de los que estaban incluidos en la tarjeta
y, por tanto, para dominarla, se quiso hacer un pequeño programa
incluyendo la configuración de la conexión inalámbrica adecuada. En
concreto, se quiso hacer un programa que encendiera y apagara los leds de
una tarjeta alternamente cada vez que se apretaran los pulsadores de la
segunda tarjeta.
Al principio, se pensaba que esta iba a ser una tarea sencilla pero
pronto se observó que no era así. Todo fue mucho más complicado porque
la antena estaba controlada por un transceiver llamado MC13192 que se
conectaba con el microcontrolador principal, el MC9S08GT60. Al contrario
que ocurría con el micro principal, la herramienta CodeWarrior no
generaba los códigos del interfaz MC13192-usuario y, por tanto, no se
podían utilizar las antenas. Este hecho provocó un retraso importante con
respecto al plan de trabajo inicial ya que se reservó muy poco tiempo para
este programa al pensar que era más simple.
Lo imprescindible para poder elaborar este pequeño programa y
conseguir la ansiada comunicación inalámbrica era encontrar los códigos
necesarios para la activación del transceiver. Después de buscar por
Internet, se encontró una segunda herramienta de Freescale, denominada
Beekit. El Beekit funciona de una manera muy sencilla, el tipo de
comunicación inalámbrica es configurable y se escoge una plantilla que la
herramienta sigue para generar los códigos necesarios. En este caso, se
selecciona SMAC ya que es la manera en la que se quiere transmitir y
recibir los datos por las antenas como se verá más adelante. Por ejemplo, si
se selecciona la plantilla acelerómetro, la herramienta creará un programa
Memoria. Software
39
que configure la tarjeta utilizando los acelerómetros pero siempre
incluyendo la configuración de los transceiver y de la comunicación
inalámbrica. Dos de estos códigos eran justamente uno que actuaba sobre
los interruptores de una tarjeta y otro sobre los leds de la segunda, por lo
que, por fin, se consiguió ese pequeño programa que se deseaba. Una vez
que se habían dado todos estos pasos se seleccionaba exportar solución y
los códigos quedaban listos para su uso. Finalmente, en el entorno de
desarrollo se seleccionaba importar proyecto, se buscaba la solución que se
acababa de exportar y aparecía el código que se había generado.
Este código incluía toda la programación relacionada con la
comunicación inalámbrica, por lo que este fue un paso importante de cara
a la consecución de la programación final, ya que toda ella pudo usarse
con pequeñas modificaciones para la transmisión final. La transmisión y
recepción inalámbricas se realizan utilizando el protocolo Zigbee. El
MC13192 se utiliza para implementar la capa física de Zigbee, aunque
luego se utiliza una capa lógica más simple denominada SMAC. El
protocolo Zigbee es parecido al bluetooth sólo que un poco menos
potente. Zigbee es un poco más lento, tiene un menor ancho de banda y
consume menos que bluetooth. Debido a la sencillez de los datos a enviar
a través de las antenas esta tecnología era la más adecuada ya que tiene la
suficiente rapidez y ancho de banda pero permite ahorrar un poco de
batería al consumir muy poco.
Finalmente, una vez conseguido el pequeño programa que
actuaba sobre los leds de una tarjeta a partir de los pulsadores de una
segunda tarjeta, se comprobó el alcance que tenía el dispositivo. Zigbee
tiene un alcance menor que otras tecnologías como por ejemplo la
tecnología bluetooth. Sin embargo, en una bicicleta convencional, el sensor
y la pantalla están relativamente cerca al ser la distancia entre ellos en
torno a los treinta centímetros. El resultado de la prueba no pudo ser más
satisfactorio cuando se comprobó que el dispositivo tenía un alcance de
Memoria. Software
40
unos quince metros, incluso teniendo que atravesar obstáculos, por lo que
la tecnología Zigbee tenía la potencia suficiente y era la más adecuada
para el proyecto.
3 La tarjeta emisora
La tarjeta emisora fue lo último que se desarrolló ya que no tenía
mucha complejidad y se prefirió hacer con antelación la parte más
complicada porque podía dar más problemas y así se tendría más tiempo
para resolverlos.
La tarjeta emisora tiene como único cometido recibir la señal del
sensor
y
procesarla.
El
sensor
con
su
circuito
electrónico
de
acondicionamiento se alimentan a tres voltios con la salida de la tarjeta y
la tensión que cae en el sensor se conecta a un pin de entrada de la tarjeta
de desarrollo. Como ya se pudo ver en el capítulo anterior, la señal que
genera el sensor es una caída de tensión de tres a cero voltios, es decir,
pasa de valer uno a cero cada vez que pasa el imán por su lado.
La programación necesaria para procesar la señal del sensor fue
muy sencilla. Lo único que se tuvo que hacer es configurar el pin al que
estaba conectado el sensor como entrada y hacer que el sensor generara
una interrupción por teclado cada vez que se detectara un flanco de
bajada. Una vez que se detectaba ese flanco, se calculan la distancia y la
velocidad. En primer lugar, la distancia se calcula sumando a una variable
global el perímetro de la rueda cada vez que se generaba la interrupción.
En segundo lugar, se lee el tiempo de un timer configurado con
anterioridad y que está corriendo continuamente cada vez que ocurre una
interrupción y se calcula el tiempo que ha tardado la rueda en dar un giro
completo restando este tiempo al tiempo anteriormente leído. A partir de
ahí, se calcula la velocidad dividiendo el perímetro entre el tiempo,
teniendo mucho cuidado de que no se genere overflow haciendo en todo
Memoria. Software
41
cálculo intermedio que el valor sea siempre representable con 16 bits. El
timer se configuró pensando en poder mostrar la menor velocidad posible
que coincide con el mayor tiempo posible. Por eso, se decidió que el valor
del prescalado fuera siete, el más grande posible. Este timer permite un
tiempo máximo de 2,1s y, por tanto, una velocidad mínima de 3,8km/h ya
que el reloj tiene una velocidad de 4MHz. Al principio, no se logró que la
velocidad se midiera bien ya que se topó con el límite de la tecnología que
provoca que la tarjeta entre en modo de bajo consumo cada vez que se
ejecute el bucle infinito para que el consumo sea mínimo. Esto provocaba
que el timer se parara y arruinaba el cálculo del tiempo transcurrido entre
una interrupción y la siguiente. Finalmente, se quitaron las instrucciones
que provocaban que la tarjeta hiciera un reset, se consiguió la medida de
velocidad y también se implementó la medida de la velocidad máxima. El
trozo de código correspondiente a los cálculos de los parámetros y a la
interrupción se muestra en el apartado código fuente.
Una vez que se tienen los parámetros calculados, se envían a
través de la antena a la segunda tarjeta de desarrollo. El problema que se
encontró en este paso fue que el dispositivo está preparado para enviar
únicamente datos de ocho bits y la distancia y la velocidad se codificaban
en 16 bits. Para resolverlo, se pensó en un principio en dividir ambas
variables en dos de ocho bits para enviar la parte alta y la parte baja por
separado, pero al final se optó por enviar la información separada en los
distintos caracteres en forma decimal.
4 La tarjeta receptora
La tarjeta receptora requirió sin lugar a dudas un trabajo mucho
mayor que el necesario para configurar la tarjeta emisora. A esta tarjeta se
conectan el display y la memoria, siendo el cometido del microcontrolador
de esta segunda tarjeta el enviar la información que recibe a través de la
antena al display y a la memoria y leer los datos almacenados en la
Memoria. Software
42
memoria. Además esta tarjeta se iba a conectar a través del puerto serie
con el PC pero finalmente esto no se llevó a cabo.
El cuentakilómetros debía de ser capaz de desarrollar cuatro
funciones: medir distancia, velocidad, velocidad máxima y velocidad
media. Por tanto, el usuario debía elegir que registro deseaba ver en cada
momento. Por ello, se configuraron los cuatro pulsadores para mostrar
cada uno de los cuatro parámetros. La configuración de los pulsadores ha
quedado implementada, pero de las cuatro funciones del ciclocomputador
sólo se han implantado la distancia y la velocidad instantánea ya que no
tenía ningún sentido implementar la velocidad máxima y la velocidad
media si la velocidad instantánea no se medía correctamente.
Como ya se ha citado un poco antes, el gran problema que
presentan los dispositivos conectados a la tarjeta receptora es que se
comunican a través de un bus i2c y el único con el que cuenta el
microcontrolador se utiliza para su comunicación con el transceiver. Este
problema se resolvió configurando los pines utilizados para comunicarse
con los periféricos para que funcionen como lo hace un bus i2c por
software. De este modo, se programaron unas funciones para enviar y
recibir simulando el comportamiento de un bus i2c. En el anexo A se
puede ver como funciona un bus i2c y, por tanto, como se comportan las
funciones
realizadas
y
algunos
detalles
sobre
las
funciones
implementadas. La recepción de datos y la escritura en el display se
muestra en el apartado código fuente.
Los dispositivos se implementaron por separado; en primer lugar
el display y, posteriormente, la memoria, por lo que lo mejor es que los
analicemos también por separado.
1. Display
Memoria. Software
43
El display necesita una configuración y una serie de funciones
para facilitar la comunicación con el microcontrolador. El objetivo de las
funciones de control del display es conseguir escribir en el display
enviando simplemente una cadena de caracteres desde el programa
principal.
Estas funciones se denominan drivers. Los drivers del display son
mucho más complejos que los drivers de la memoria. Por un lado, el
display necesita una inicialización para, por ejemplo, dar tensión a la
pantalla porque el display recibe tres voltios para alimentar la lógica que
tiene incorporada, pero la tensión que necesita la pantalla se implanta por
software. Por otro lado, se programan unas funciones que reciben una
cadena de caracteres y la codifican para escribir en el display o pasan
directamente a la primera o segunda línea del display. El display tiene que
recibir una serie de parámetros cada vez que se quiere escribir en él o
pasar de una línea del display a otra y se tiene que codificar la información
en código ASCII, por tanto, la idea fue realizar una función que permitiera
poner toda la secuencia de parámetros y codificación una vez y utilizarla
muchas veces. Todas estas funciones (PutsDisplay, DisplayGotoLinea0 y
DisplayGotoLinea1) se pueden observar en el apartado código fuente.
Dichas funciones se encuentran en el fichero init_display.c.
Como se puede observar en el código de las funciones localizado
en el apartado de código fuente, es necesario enviar un 0x76 al display
antes de realizar cualquier operación. Ésta es la dirección del display.
Luego, dependiendo de lo que se va a hacer se envían unos parámetros u
otros, cogidos todos ellos de la documentación del display.
Todo esto es un trabajo muy complicado, sin embargo no lo fue
tanto gracias al dispositivo escogido. La razón por la cual se escogió ese
display LCD fue porque el director del proyecto, Daniel Muñoz, utiliza
este mismo display en la asignatura que el imparte en la universidad y,
Memoria. Software
44
por tanto, se pudo aprovechar el driver que él había realizado permitiendo
un gran ahorro de tiempo. Aún así, se tuvo que modificar el driver para
que utilizara las funciones que se habían elaborado para que los pines
normales de entrada salida funcionaran como un bus i2c.
2. Memoria
Los drivers de la memoria se tuvieron que hacer desde el principio
pero su configuración fue mucho más corta y simple y más aún después
de realizar la configuración del display primero. La memoria no necesita
ningún tipo de inicialización, entonces lo que se hizo fue programar dos
funciones, una para escribir en la memoria y la otra para leer. La manera
que se utilizó para realizar estas dos funciones fue una copia de lo que
hace el display, por lo que la memoria recibe una cadena de caracteres y la
escribe y lee una cadena de caracteres y la transmite. Para clarificar un
poco de lo que se está hablando los códigos de las funciones desarrolladas
para el control de la memoria se muestran en el apartado código fuente.
Como se puede observar en el código de las funciones de control de
la memoria, al principio del envío y la lectura se mandan tres comandos:
0xA0, 0, 0. Estos comandos son el direccionamiento de la memoria
marcado por los pines enable y los dos siguientes son la dirección de
memoria por la cual va a comenzar el proceso de lectura o escritura.
También se puede ver como se ha copiado el paso a ASCII de los
comandos recibidos para simplificar, haciendo que funcione la memoria
de manera exacta al display.
En los códigos mostrados en el capítulo con título código fuente se
puede ver como las funciones de control de la memoria y el display hacen
llamadas a una serie de funciones que tienen que ver con el bus i2c. Éstas
son las funciones que se han tenido que programar para hacer que los
pines de entrada/salida funcionen de la misma manera que lo hace un bus
Memoria. Software
45
i2c. Para el display sólo fue necesaria una función cuyo código se
encuentra en el fichero i2c_display.c y se muestra en el apartado código
fuente. En ese código se muestran todos los pasos que tiene que hacer el
pin para transmitir la información como si se tratara de un bus i2c. Se
puede observar como la función da todos los pasos que se indica que da el
bus i2c en el anexo A. Primero se genera una condición de start, luego se
envían los datos bit a bit empezando por el más significativo y dando
pulsos en la línea SCL en cada envío, posteriormente se genera un pulso
ACK al final de cada byte enviado y, por último, se genera una condición
de stop. Cabe destacar la configuración del bit SDA como entrada después
de cada byte enviado, que es necesario porque el esclavo toma el control
de esa línea hasta que se da el pulso ACK, pero no es nada intuitivo.
En el caso de la memoria no fue tan sencillo y se tuvieron que
programar tres funciones para la comunicación a través del bus i2c. Una
de ellas es la que sirve para almacenar información en la memoria y es
muy similar a la del display. Las otras dos sirven para la lectura, ya que
para leer datos de la memoria, se necesita primero indicar la dirección por
la cual se va a empezar a leer y luego empezar a leer. Para enviar la
dirección de donde se va a empezar a leer no se puede utilizar la misma
función que para el envío normal porque no se puede generar una
condición de stop después de enviar la dirección de lectura. Esta
diferencia se puede observar en las figuras ocho (envío) y diez (lectura) de
la documentación de la memoria. También se pueden ver estas diferencias
en el código de las tres funciones programadas localizadas en el archivo
i2c_memory.c, que se muestran en el apartado código fuente.
Como se puede observar en esos códigos, la función de envío es
muy similar a la función de envío del display ya que el concepto es el
mismo. La función envia_lectura() no es más que la misma función de
envío sin generar una condición de stop. Esta función sirve para informar
Memoria. Software
46
al microcontrolador la dirección por la cual tiene que empezar el proceso
de lectura de la memoria y, por ello, no se puede generar una condición de
stop entre este envío y la lectura como se puede observar en la figura diez
de la documentación de la memoria. La función de lectura cumple todos
los pasos que se dice que tiene que cumplir en el anexo A sobre el bus i2c.
Es muy similar a la de envío con la única diferencia localizada en la
generación del pulso ACK.
5 Programación final
Una vez que se habían configurado todos los elementos del
cuentakilómetros por separado, llegaba el momento de juntar todo para
finalizar el dispositivo. Lo que se hizo fue partir de aquellos programas
que encendían los leds de una tarjeta al apretar los pulsadores de la otra.
El motivo fue que estos programas incluían toda la configuración del
transceiver que controla la antena.
La programación final se puede dividir en dos grandes partes: en
primer lugar, la programación del microcontrolador de la tarjeta emisora
y, en segundo lugar, la programación del microcontrolador de la tarjeta
receptora.
La tarjeta emisora cuenta con sólo un archivo denominado
remote_controller.c. Este archivo tiene por un lado toda la configuración del
transceiver y todas las funciones y variables necesarias para poder enviar
información a través de la antena y, por otro, la interrupción por teclado
que genera la señal del sensor. Ésta interrumpe el curso normal del
programa principal, modifica los valores de velocidad actual y distancia
recorrida y envía la información a través de la antena.
Memoria. Software
47
La tarjeta receptora cuenta con varios archivos distintos
localizados en el mismo proyecto. En primer lugar, la tarjeta tiene un
programa principal localizado en el archivo lighting_demo_device.c que
contiene todo el procesamiento de la información recibida a través de la
antena y la inicialización del microcontrolador y el display. El archivo
incluye todas las funciones y variables necesarias para la recepción de
datos a través de la antena. En segundo lugar, la tarjeta tiene que
comunicarse con el display y la memoria. Para ello, se utiliza la
programación implementada en los ficheros i2c_display.c e i2c_memory.c,
que incluyen las funciones de comunicación entre los periféricos y el
microcontrolador a través del bus i2c configurado por software de la
manera que se cuenta en el apartado cuarto de este mismo capítulo.
Memoria. Resultados/Experimentos
48
Capítulo 4 RESULTADOS/EXPERIMENTOS
Los resultados conseguidos han sido resultados parciales. El
resultado final del proyecto se muestra en las figuras 10 y 11, en las cuales
se puede observar el ciclocomputador funcionando y como ha quedado
montado. En la figura 10 se muestra el cuentakilómetros midiendo
distancia recorrida, en la figura 11 midiendo velocidad y en la figura 11b
midiendo velocidad máxima. En el caso de la velocidad el resultado no ha
sido totalmente satisfactorio ya que, a pesar de que se ha conseguido que
la tarjeta no entre en modo bajo consumo, la medida no es muy
convincente. Cuando va despacio si parece que funcione bien midiendo
velocidades en torno a los diez kilómetros por hora, pero cuando va
rápido la medida no es tan buena. Esto puede ser debido a que la
interrupción es un poco lenta y se pierden datos por el camino.
Figura 10: Demostración medida distancia
Memoria. Resultados/Experimentos
Figura 11: Demostración medida velocidad
Figura 11b: Demostración velocidad máx.
49
Memoria. Resultados/Experimentos
50
Como se puede observar, el display se enciende y muestra los
valores de velocidad y distancia. Estos valores se modifican cada vez que
el imán pasa por encima del sensor.
Memoria. Conclusiones
51
Capítulo 5 CONCLUSIONES
Una vez finalizado el proyecto, se hecha la vista atrás y se
compara lo que se tenía que hacer con lo que se ha hecho. La conclusión
que se obtiene es que el proyecto no ha llegado al punto que se deseaba en
una principio. Por un lado, todo el hardware ha quedado implementado y
funciona correctamente, pero no se ha obtenido el mismo resultado con el
software. El dispositivo mide sin ningún problema la distancia que se ha
recorrido a partir de la señal generada por el sensor y la muestra en el
display, sin embargo, no se ha conseguido lo mismo con la velocidad que
no la mide adecuadamente. El cuentakilómetros mide velocidad una vez
que se eliminó la entrada en modo de bajo consumo, pero los valores
cuando las interrupciones son rápidas no son muy convincentes. Como ya
se ha dicho con anterioridad, este problema puede estar relacionado con la
lentitud de la interrupción, ya que se observan valores muy pequeños de
la velocidad cuando la bicicleta va rápido.
Al igual que ocurre con la medida de velocidad, la implantación
de la memoria EEPROM sólo se ha conseguido a medias. Como se ha
podido ver con antelación, se programaron los drivers de la memoria y
mediante un sencillo programa que guardaba un dato en la memoria, lo
leía y lo mostraba en el display se demostró que funcionaba. Sin embargo,
nunca se llegó a implantar con el resto del cuentakilómetros por los
problemas que el resto de la programación dió y que dejó sin tiempo para
poder completar la implantación de la memoria.
Finalmente, la comunicación con el PC a través del puerto serie,
no se pudo llevar a cabo.
Memoria. Futuros desarrollos
52
Capítulo 6 FUTUROS DESARROLLOS
Con la llegada del siglo XXI, el cliente se ha vuelto mucho más
exigente y experto y a todo el mundo, pequeños y mayores, le gusta que
sus cosas sean lo más sofisticadas posibles. Es por esto que incluso un
elemento tan simple como un cuentakilómetros tenga buena acogida en el
mercado a pesar de su mayor precio si incluye elementos como una
memoria y la capacidad de poder descargarse los datos al ordenador. Esto
era impensable hace unos años pero hoy todo el mundo tiene un PC en
casa y tiene la curiosidad de poder comparar los datos de una jornada con
los del día anterior.
El cuentakilómetros confeccionado se puede desarrollar en el
futuro de muchas maneras distintas y poder llegar a conseguir un
cuentakilómetros realmente sofisticado utilizando la misma base que este,
que es bastante sólida y buena.
Un primer desarrollo posible tiene que ver con la comunicación
con el ordenador, que finalmente no se ha conseguido en este proyecto, y
que podría realizarse de una manera un poco más sofisticada a través de
un puerto USB o de manera inalámbrica utilizando tecnología bluetooth,
en vez de a través de un puerto serie que ya está en desuso.
Uno de los inconvenientes más grandes que tiene este
cuentakilómetros para competir en el mercado es el escaso número de
funciones que tiene. Por ello, se podría hacer que el cuentakilómetros
midiera otros parámetros como hacen los mejores del mercado, como el
ritmo cardiaco, la cadencia de pedaleo o las calorías quemadas. En el caso
del ritmo cardiaco, habría que añadir otro periférico y otra tarjeta de
Memoria. Futuros desarrollos
53
desarrollo que fueran conectados al ciclista. Esta tarjeta se podría
comunicar de la misma manera que las dos con las que ya cuenta el
proyecto. Este camino tendría una gran ventaja ya que la programación
para la comunicación entre las tarjetas está ya hecha y se podría reutilizar.
Finalmente, un último desarrollo que podría ser interesante es
cambiar la tecnología de la comunicación inalámbrica. De esta forma, se
podría utilizar tecnología bluetooth en vez de tecnología Zigbee ya que
ésta es una manera de transmisión mucho más potente. Incluso, se podría
omitir la tarjeta receptora y sustituirla por el teléfono móvil del usuario ya
que en la actualidad todos los teléfonos móviles incluyen tecnología
bluetooth. Se podría vender un CD junto con la tarjeta emisora que
contuviera un programa que configurara el móvil como tarjeta receptora.
La pantalla se usaría para representar los parámetros calculados, los
números podrían utilizarse como pulsadores para cambiar de parámetro
mostrado en la pantalla y los datos se podrían almacenar en la tarjeta de
memoria del móvil, ya que hoy en día todos los teléfonos móviles incluyen
una. Esto simplificaría además la conexión con el ordenador ya que
actualmente todos los móviles se pueden conectar al ordenador por USB y
se pueden descargar todos los datos que contengan. La desventaja más
importante de este sistema es que se requiere un móvil de esas
características, aunque cada vez es más habitual que los móviles incluyan
todas estas tecnologías. Otra desventaja es que se tendría que cambiar toda
la comunicación inalámbrica y pasar de utilizar Zigbee a bluetooth, lo cual
supondría empezar el proyecto casi desde cero ya que la transmisión
inalámbrica es la parte más delicada y complicada y la que más tiempo
requiere.
Memoria. Bibliografía
54
BIBLIOGRAFÍA
[1]
http://www.esacademy.com/faq/i2c/index.htm
[2]
http://www.freescale.com/
[3]
http://www.farnell.com/datasheets/72672.pdf
[4]
http://www.farnell.com/datasheets/76930.pdf
[5]
http://www.nxp.com/acrobat_download/datasheets/PC
F2119X_4.pdf
Parte II ESTUDIO ECONÓMICO
Estudio económico
56
El proyecto que se ha llevado a cabo es un cuentakilómetros de
comunicación inalámbrica y con memoria para almacenar los datos de una
jornada. Económicamente hablando, se trata de un proyecto con dudosa
viabilidad debido al elevado precio, pero tiene un gran interés debido a la
sencillez del manejo de este dispositivo. El diseño del cuentakilómetros es
muy robusto, por lo que la rentabilidad y la fiabilidad del dispositivo no
se pueden poner en duda.
El problema más grande que tiene el cuentakilómetros construido
es el tamaño, lo que puede afectar a la viabilidad de este proyecto. Ya de
por sí, las tarjetas de desarrollo son grandes, pero aún lo son más con los
periféricos conectados. La tarjeta receptora es un poco grande pero, al ir
alojada en el manillar de la bicicleta, se puede permitir. Sin embargo, la
tarjeta emisora que va alojada en la horquilla de la bicicleta es
inadmisiblemente grande. No obstante, no se utilizan muchas de las partes
que incluyen las tarjetas por lo que se podría reducir el tamaño añadiendo
al dispositivo final sólo los componentes estrictamente necesarios para la
elaboración del proyecto.
Parte III MANUAL DE USUARIO
Manual de usuario
58
Para poder utilizar el cuentakilómetros hay que seguir una serie
de pasos que se muestran en este manual. En primer lugar, ambas tarjetas
deben estar alimentadas mediante una pila de nueve voltios. Las tarjetas
de desarrollo cuentan con un interruptor de dos posiciones: en la primera
de ellas se activa la alimentación desde la pila y se desactiva la
alimentación desde red y en la segunda ocurre todo lo contrario. En este
caso, las tarjetas están apagadas cuando estos pulsadores están a la
derecha y encendidas cuando están a la izquierda. Por tanto, lo primero
que hay que hacer es encender ambas tarjetas. A continuación se
observará como se encienden los leds y según la manera en que se
enciendan se sabrá si se trata de la tarjeta emisora o receptora. En la tarjeta
emisora los leds se encienden todos a la vez un tiempo, y en la tarjeta
receptora van rotando uno a uno. Posteriormente, se enciende un led de
seguridad y en la tarjeta emisora se encienden durante un tiempo todos
los leds. En ese momento, la tarjeta está comprobando cual es el mejor
canal de los cuatro que tiene para enviar la información. Cuando acaba, se
muestra el led correspondiente al canal escogido. Ahora se tiene que
apretar el pulsador en la tarjeta receptora que selecciona el mismo canal
que en la tarjeta emisora y se encenderá el led correspondiente. Cabe
recordar que el pulsador S104 enciende el led 1, el S103 enciende el led 2,
el S102 enciende el led 3 y el S101 enciende el led 4 y hay que tener
cuidado de apretar el pulsador que haga que se encienda el mismo led que
se encendió en la tarjeta emisora. Por último, hay que direccionar la tarjeta
receptora que está configurada por defecto la dirección tres. Por tanto, hay
que apretar el pulsador S102 que enciende el tercer led. Este proceso hay
que repetirlo cada vez que se enciende el cuentakilómetros.
Ahora, las tarjetas están configuradas y listas para poder usarse y,
si pasa el imán por encima del sensor, empezarán a verse los valores de los
parámetros en el display. El display tiene tres estados: uno que mide
distancia, otro que mide velocidad y uno tercero en el que está apagado.
Manual de usuario
59
Todo esto se puede ver en el diagrama de estados que se muestra en la
figura 12.
Pulsador S102
Estado 1
Estado 2
Pulsador S101
Dar
alimentación
Mide distancia
Quitar
alimentación
Mide velocidad
Quitar
alimentación
Paro
Figura 12: Diagrama estados del display
Como se puede observar en la figura 12, cuando se da
alimentación se pasa directamente al estado dos donde se mide velocidad.
Una vez ahí, el display espera que el sensor genere una interrupción para
empezar a mostrar el valor de la velocidad instantánea. Para pasar del
estado dos al uno, se debe apretar el pulsador S101 y para pasar del uno al
dos, el pulsador S102. En el estado uno se mide la distancia recorrida.
Desde cualquiera de los dos estados si se quita alimentación, se pasa al
estado de parada.
Parte IV CÓDIGO FUENTE
Código fuente
61
En este apartado se muestra el código de las distintas funciones
programadas al las que se hacen referencia alguna vez en el texto de la
memoria. Son funciones cuyo código puede resultar muy ilustrativo para
saber de lo que se está hablando:
Drivers del display:
void PutsDisplay(byte *pcad)
{
byte i;
/* Initialize TX buffer structure */
i2c_tx_buffer.buf[0] = 0x76;
i2c_tx_buffer.buf[1] = 0x40; /* Primer
datos */
byte
de
control.
Direcciona
i = 2;
/* Copio la cadena en el buffer de TX */
while (*pcad != '\0'){
i2c_tx_buffer.buf[i] = *pcad | 0x80; /* El juego de caracteres
tiene el
ascii con el primer bit a 1 */
pcad++;
i++;
}
i2c_tx_buffer.length = i;
/* Se envían los datos por el I2C*/
envia_i2c_display(i2c_tx_buffer.buf,i2c_tx_buffer.length);
}
void DisplayGotoLinea0(void)
{
/* Se inicializa el buffer de transmisión */
i2c_tx_buffer.buf[0] = 0x76;
i2c_tx_buffer.buf[1] = 0x00; /* Primer byte de control */
i2c_tx_buffer.buf[2] = 0x02; /* Comando Return home */
i2c_tx_buffer.length = 3;
envia_i2c_display(i2c_tx_buffer.buf,i2c_tx_buffer.length);
}
void DisplayGotoLinea1(void)
{
/* Se inicializa el buffer de transmisión */
i2c_tx_buffer.buf[0] = 0x76;
i2c_tx_buffer.buf[1] = 0x00; /* Primer byte de control */
i2c_tx_buffer.buf[2] = 0xA9; /* Cursor a dirección 40 (Línea 1) */
i2c_tx_buffer.buf[3] = 0x14; /* Avanza el cursor 1 posición a
derecha */
i2c_tx_buffer.length = 4;
envia_i2c_display(i2c_tx_buffer.buf,i2c_tx_buffer.length);
}
la
Código fuente
62
Drivers de la memoria:
void PutsMemory(byte *pcad)
{
byte i;
/* Initialize TX buffer structure */
i2c_tx_buffer.buf[0] = 0xA0;
i2c_tx_buffer.buf[1] = 0;
i2c_tx_buffer.buf[2] = 0;
i = 3;
/* Copio la cadena en el buffer de TX */
while (*pcad != '\0'){
i2c_tx_buffer.buf[i] = *pcad;
pcad++;
i++;
}
i2c_tx_buffer.length = i;
/* Se envían los datos por el I2C*/
envia_i2c_memory(i2c_tx_buffer.buf,i2c_tx_buffer.length);
}
void ReadsMemory(void)
{
byte i;
/* Initialize TX buffer structure */
i2c_tx_buffer.buf[0] = 0xA0;
i2c_tx_buffer.buf[1] = 0;
i2c_tx_buffer.buf[2] = 0;
i = 3;
/* Copio la cadena en el buffer de TX */
i2c_tx_buffer.length = i;
/* Se envían los datos por el I2C*/
envia_lectura(i2c_tx_buffer.buf,i2c_tx_buffer.length);
i2c_tx_buffer.buf[0] = 0xA1;
envia_lectura(i2c_tx_buffer.buf,1);
lee_i2c_memory(4);
}
Configuración del envío a través del bus i2c para el display:
#include "MC9S08GT60.h"
#include "i2c_display.h"
#define SDA PTAD_PTAD6
#define SCL PTAD_PTAD7
// Pines del bus i2c por los cuales se
transmite la información al display
Código fuente
63
void envia_i2c_display(byte buff[],byte tam) {
byte
byte
byte
byte
car_env;
var=0;
j=0;
n=0;
SDA=1;
SCL=1;
PTADD=0xC0;
// Configuración de SCL (pin 7 del puerto A)
y SDA (pin 6 del puerto A) como salidas.
SDA=0;
// Start condition
var++;
var--;
// Delay
for(j=0;j<tam;j++) {
car_env=buff[j];
for(n=0;n<8;n++){
SCL = 0;
SDA=(car_env>>7)&1;
// MSB primero
SCL=1;
var++;
// Delay
car_env<<=1;
var--;
// Para evitar overflow
}
SCL = 0;
PTADD_PTADD6=0;
// Configuración de SDA como entrada para
que tome el control el slave.
SCL = 1;
SCL = 0;
// ACK pulse para volver a tomar el control
de la línea SDA.
PTADD_PTADD6=1;
// Configuración de SDA como salida.
}
SCL = 1;
SDA = 1;
// Stop condition
PTADD=0;
evitar cortocircuitos.
}
// Configuro el puerto como salida para
Configuración del envío y lectura a través del bus i2c para la memoria:
#include "MC9S08GT60.h"
#include "i2c_memory.h"
#define SDA PTBD_PTBD3
#define SCL PTBD_PTBD2
extern byte lee_buff[50];
void envia_i2c_memory(byte buff[],byte tam) {
Código fuente
byte
byte
byte
byte
64
car_env;
var=0;
j=0;
n=0;
SDA=1;
SCL=1;
PTBDD_PTBDD3 = 1;
PTBDD_PTBDD2 = 1;
// Configuración de SCL (pin 2 del puerto B)
y SDA (pin 3 del puerto B) como salidas.
SDA=0;
// Start condition
var++;
var--;
// Delay
for(j=0;j<tam;j++) {
car_env=buff[j];
for(n=0;n<8;n++){
SCL = 0;
SDA=(car_env>>7)&1;
// MSB primero
SCL=1;
var++;
// Delay
car_env<<=1;
var--;
// Para evitar overflow
}
SCL = 0;
PTBDD_PTBDD3=0;
// Configuración de SDA como entrada para
que tome el control el slave.
SCL = 1;
SCL = 0;
// ACK pulse para volver a tomar el control
de la línea SDA.
PTBDD_PTBDD3=1;
// Configuración de SDA como salida.
}
SCL = 1;
SDA = 1;
// Stop condition
PTBDD_PTBDD3 = 0;
PTBDD_PTBDD2 = 0;
evitar cortocircuitos.
}
// Configuro el puerto como entrada para
void lee_i2c_memory(byte longitud) {
byte
byte
byte
byte
byte
byte
lee_car=0;
v=0;
j=0;
n=0;
k=7;
copy;
//SDA=1;
//SCL=1;
Código fuente
65
//PTBDD|=0x0C;
//SDA=0;
PTBDD_PTBDD3 = 0;
PTBDD_PTBDD2 = 1;
como salida
// Start condition
// Configuración de SDA como entrada y SCL
v++;
v--;
for(j=0;j<longitud;j++) {
lee_car=0;
for(n=0;n<8;n++){
SCL=1;
copy=SDA;
SCL=0;
lee_car|=copy&1; // MSB first. Or made for
characters that have already been read.
//SCL=1;
v++;
if(n<7){
lee_car<<=1;
// Delay
}
v--;
// Para evitar overflow
}
lee_buff[j]=lee_car;
SCL=0;
PTBDD_PTBDD3 = 1;
SDA=0;
//PTBDD_PTBDD3=0;
if(j<(longitud-1)){
SCL=1;
SCL=0;
PTBDD_PTBDD3 = 0;
}
// ACK pulse
//PTBDD_PTBDD3=0;
}
//PTBDD_PTBDD3 = 1;
SCL=1;
SDA=1;
// Stop condition
//PTBDD_PTBDD3=0;
//PTBDD_PTBDD2=0;
}
void envia_lectura(byte buff[],byte tam) {
byte car_env;
not
errasing
the
Código fuente
66
byte var=0;
byte j=0;
byte n=0;
//SDA=1;
//SCL=1;
PTBDD_PTBDD3 = 1;
PTBDD_PTBDD2 = 1; // Configuración de SCL (pin 2 del puerto B) y SDA
(pin 3 del puerto B) como salidas.
SDA=1;
SCL=1;
SDA=0;
// Start condition
var++;
var--;
// Delay
for(j=0;j<tam;j++) {
car_env=buff[j];
for(n=0;n<8;n++){
SCL = 0;
SDA=(car_env>>7)&1;
// MSB primero
SCL=1;
var++;
// Delay
car_env<<=1;
var--;
// Para evitar overflow
}
SCL = 0;
PTBDD_PTBDD3=0;
// Configuración de SDA como entrada para
que tome el control el slave.
SCL = 1;
SCL = 0;
// ACK pulse para volver a tomar el control
de la línea SDA.
PTBDD_PTBDD3=1;
// Configuración de SDA como salida.
}
//PTBDD_PTBDD3 = 0;
//PTBDD_PTBDD2 = 0;
// Configuro el puerto como entrada para
evitar cortocircuitos.
}
Interrupción del sensor:
interrupt void KBD_ISR()
{
word t2;
word t;
word t1 = 0;
KBI1SC_KBACK = 1;
if(PTDD_PTDD0==0){
PTDD_PTDD0=1;
} else if(PTDD_PTDD0==1){
PTDD_PTDD0=0;
}
bandera = 1;
Código fuente
//
67
DisableInterrupts;
t2 = TPM2CNT;
if (t2>t1){
t = t2 - t1;
} else{
t = (65535 - t1)+t2;
}
t = (t/1000)*32;
//t en milisegundos.
t1 = t2;
vel = (PERIMETRO*10000)/t;
vel = (vel*36)/10;
//Cálculo de la velocidad
metro += PERIMETRO;
if(metro>=10){
metro = 0;
dec_metro++;
}
if(dec_metro>=10){
dec_metro = 0;
km++;
}
if(km>=10){
km = 0;
dec_km++;
}
if(dec_km>=10){
dec_km = 0;
cen_km++;
//Cálculo de la distancia y separación de los
caracteres decimales. Ej: Separar el número 125,73 en
el 1, el 2, el 5, el 7 y el 3.
}
}
Cálculo de velocidad máxima y separación en caracteres decimales de
velocidad y velocidad máxima:
DisableInterrupts;
vel_copy = vel;
EnableInterrupts;
if(vel_copy>vel_max){
vel_max=vel_copy;
vel_max_copy=vel_max;
cen_vel_max=0;
dec_vel_max=0;
un_vel_max=0;
while(vel_max_copy>=100){
vel_max_copy = vel_max_copy-100;
cen_vel_max++;
}
while(vel_max_copy>=10&&vel_max_copy<100){
vel_max_copy = vel_max_copy-10;
dec_vel_max++;
}
while(vel_max_copy>=1&&vel_max_copy<10){
vel_max_copy = vel_max_copy-1;
un_vel_max++;
}
}
Código fuente
68
while(vel_copy>=100){
vel_copy = vel_copy-100;
cen_vel++;
}
while(vel_copy>=10&&vel_copy<100){
vel_copy = vel_copy-10;
dec_vel++;
}
while(vel_copy>=1&&vel_copy<10){
vel_copy = vel_copy-1;
un_vel++;
}
DisableInterrupts;
metro_copy=metro;
dec_metro_copy=dec_metro;
km_copy=km;
dec_km_copy=dec_km;
cen_km_copy=cen_km;
EnableInterrupts;
Envío de los caracteres:
gauTxDataBuffer[0] = 0xE1; /* Code bytes non-ZigBee */
gauTxDataBuffer[1] = 0xCC;
gauTxDataBuffer[2] = SECURITY; /* Generic security number */
guTxDataBuffer[3] = u8DeviceLed; /* Target device */
gauTxDataBuffer[4] = metro_copy;
gauTxDataBuffer[5] = u8Dsn; /* Current data sequence number */
gauTxDataBuffer[6] = 0x00; /* Target device's receive u16Count */
gsTxPacket.u8DataLength = 18;
if (u8AppStatus == 2) /* u8Toggle */
{
gauTxDataBuffer[7] = TOGGLECMD;
u8AppStatus = 4; /* Waiting for the u8Toggle ack */
}
gauTxDataBuffer[8] = dec_metro_copy;
gauTxDataBuffer[9] = km_copy;
gauTxDataBuffer[10] = dec_km_copy;
gauTxDataBuffer[11] = cen_km_copy;
gauTxDataBuffer[12] = cen_vel;
gauTxDataBuffer[13] = dec_vel;
gauTxDataBuffer[14] = un_vel;
gauTxDataBuffer[15] = cen_vel_max;
gauTxDataBuffer[16] = dec_vel_max;
gauTxDataBuffer[17] = un_vel_max;
Se hacen copias de los parámetros para evitar que afecte la
interrupción justo en el momento del envío.
Recepción de datos y escritura en el display
if(estado==1){
DisplayGotoLinea0();
PutsDisplay("Distancia:
DisplayGotoLinea1();
");
cad[0] = (au8RxDataBuffer[11])+48;
cad[1] = (au8RxDataBuffer[10])+48;
cad[2] = ',';
//Se suma 48 para pasar a código
ASCII
Código fuente
cad[3] = (au8RxDataBuffer[9])+48;
cad[4] = (au8RxDataBuffer[8])+48;
cad[5] = (au8RxDataBuffer[4])+48;
cad[16] = '\0';
PutsDisplay(
cad
);
}
if(estado==2){
DisplayGotoLinea0();
PutsDisplay("Velocidad:
");
DisplayGotoLinea1();
cad[0] = (au8RxDataBuffer[12])+48;
cad[1] = (au8RxDataBuffer[13])+48;
cad[2] = ',';
cad[3] = (au8RxDataBuffer[14])+48;
cad[16] = '\0';
PutsDisplay(cad);
}
if(estado==3){
DisplayGotoLinea0();
PutsDisplay("Velocidad Media:");
DisplayGotoLinea1();
PutsDisplay("
");
}
if(estado==4){
DisplayGotoLinea0();
PutsDisplay("Velocidad Max.: ");
DisplayGotoLinea1();
cad[0] = (au8RxDataBuffer[15])+48;
cad[1] = (au8RxDataBuffer[16])+48;
cad[2] = ',';
cad[3] = (au8RxDataBuffer[17])+48;
cad[16] = '\0';
PutsDisplay(cad);
}
69
Parte V ANEXOS
Anexos
71
Anexo A: el bus i2c
El bus i2c es el método de transmisión y recepción de datos
utilizado por el display y la memoria. Como se ha dicho en el texto de la
memoria, se decidió adquirir este modelo de display con este método de
transmisión para utilizar un menor número de pines en la comunicación
entre el microcontrolador y el display, ya que para utilizar tres displays
BCD de siete segmentos se necesitaría hacer uso de doce pines, un número
demasiado elevado con el que el puerto de pines entrada/salida no
cuenta. La memoria EEPROM se decidió que se comunicara del mismo
modo para aprovechar el software programado para el display.
El problema que apareció es que el micro no contaba con ningún
bus de este tipo libre para poder usar. Por ello, se tuvieron que programar
los pines estándar de entrada/salida para que funcionaran como las líneas
de transmisión del bus i2c.
El bus i2c es un bus de comunicaciones serie diseñado por Philips.
Este bus tiene como principal característica que utiliza dos líneas para
transmitir la información: una para los datos (SDA) y otra para la señal de
reloj (SCL). Los dispositivos conectados al bus i2c se direccionan para que
luego desde el microcontrolador se envíe a un periférico determinado
diciéndole al microcontrolador la dirección a la que debe enviar los datos.
Al ser un bus, permite más de un periférico conectado a la misma línea,
por eso se deben direccionar los dispositivos conectados al bus. Sin
embargo, en esta ocasión, como el bus se va a programar, se ha preferido
conectar la memoria y el display a dos líneas diferentes para una mayor
sencillez.
Cuando se quiere transmitir un dato el proceso es similar pero no
es igual que cuando se quiere leer un dato a través de este bus. Sin
Anexos
72
embargo, el funcionamiento de las líneas SDA y SCL si que es igual para
ambas situaciones. Una vez que el periférico ocupa la línea de
transmisión/recepción del bus i2c se opera de la siguiente manera:
1.
Se pone la línea SDA a cero o a uno haciéndola coincidir con
el bit más significativo del dato que se quiere enviar. En caso de
querer leer algún dato, se lee el bit más significativo de dicho dato
poniendo la línea SDA al nivel de dicho bit.
2.
Se da un pulso de reloj poniendo la línea SCL a uno y,
seguidamente, a cero.
3.
El bit más significativo ya se ha enviado o recibido y se
procede a enviar o recibir el siguiente bit de la misma manera.
Como ya se ha comentado arriba, a pesar de que el proceso que
sigue el bus para enviar y recibir datos es el mismo, la manera de actuar es
distinta según si se quieren enviar o recibir datos. Por tanto, cuando se
quiere utilizar el bus para enviar datos se procede de la siguiente manera:
1.
El bus está libre cundo ambas líneas están a nivel alto.
2.
El dispositivo toma el control de las líneas de transmisión y
el maestro genera un “start condition” que no es más que poner
primero la línea SDA a cero y luego hacer lo propio con la línea
SCL.
3.
Se van enviando todos los bytes de los que se compone el
mensaje. El primer byte tiene que ser una dirección que coincida
con la del dispositivo al que se quiere enviar (“device select”),
siendo el último bit el que indica si se va a enviar (‘0’) o a recibir
(‘1’).
Anexos
73
4.
Después de enviar cada byte, el periférico toma el control de
la línea SDA. Por ello, se configura la línea SDA como entrada y se
da un pulso de reloj en la línea SCL. Este pulso se denomina pulso
ACK (“acknowledge”) que sirve para recuperar el control de la
línea de transmisión.
5.
Cuando se hayan enviado todos los bytes, se genera un “stop
condition” que es poner la línea SCL a nivel alto y, acto seguido,
hacer lo propio con la línea SDA, dejando libre el canal.
Un diagrama de tiempos clarifica mucho estos cinco pasos que se
tienen que dar antes cada vez que se envía información a través de un bus
i2c:
Figura 7: Diagrama de tiempos bus i2c
En el diagrama de tiempos que se puede observar en la figura 7,
no se muestra el cuarto paso, que es el de generar un pulso ACK, por
tanto, se muestra un segundo diagrama de tiempos en la figura 8 que hace
un zoom al final del envío y muestra como es este pulso ACK:
Figura 8: Pulso ACK en transmisión
Anexos
74
El diagrama de tiempos para la lectura es prácticamente igual que
para el envío por lo que no se va a añadir otro diagrama para la lectura.
Sin embargo, cuando se quiere utilizar el bus i2c para leer datos existen
algunas diferencias:
1.
El bus está libre cuando ambas líneas están a nivel alto.
2.
El dispositivo toma el control de las líneas de transmisión y
el maestro genera un “start condition”.
3.
Antes de leer todos los bytes de los que está compuesto el
mensaje se debe enviar un byte de dirección que tiene que coincidir
por la del dispositivo del cual se va a leer (“device select”),
poniendo el último bit a uno, indicando proceso de lectura.
4.
Como en el caso de la escritura, después de cada byte hay
que generar un pulso ACK excepto en el último donde no se tiene
que generar dicho pulso antes de realizar un “stop condition”.
El pulso ACK no tiene el mismo principio ahora que en el caso del
envío y esto es de gran importancia para poder programar el software del
bus i2c. Cuando se está utilizando el bus para transmitir, el maestro pone
la línea SCL a cero (1) e, inmediatamente después, hace lo propio el
esclavo con la línea SDA (2). En este momento, el maestro tiene que
generar el pulso ACK en la línea SCL (3) y el maestro recupera el control
sobre la línea SDA que se pone a uno para continuar con la transmisión
(4). Sin embargo, cuando se está utilizando el bus para leer datos, después
de leer el último bit del esclavo (1), el esclavo entrega el control sobre la
línea SDA al maestro que se pone a uno (2). El maestro entonces pone la
línea SDA a cero (3) y genera un pulso ACK en la línea SCL (4). Después
de este proceso, el esclavo recupera el control sobre la línea SDA (5) y
Anexos
75
continúa la lectura (6). El pulso ACK para la transmisión se muestra en la
figura 8 y en la figura 9 se muestra el pulso ACK para la lectura:
Figura 9: Pulso ACK en recepción
Como se puede observar, el bus i2c utiliza una manera de
transmisión y recepción muy simple para comunicar el micro con sus
periféricos enviando la información bit a bit separados por ciclos de reloj.
Sin embargo, la programación y su posterior adaptación a la memoria y al
display no han sido tan sencillas. Además, no se contaba con tener que
elaborar esta programación en el plan inicial de trabajo, por lo que supuso
un retraso importante en el proyecto.
DOCUMENTO Nº2:
PRESUPUESTO
Presupuesto
77
En este documento se va a calcular el presupuesto del
cuentakilómetros que se ha creado. El sistema está compuesto por un
sensor, un display, una memoria y dos tarjetas de desarrollo idénticas.
Todos ellos aportan una parte, ya sea pequeña o grande al presupuesto del
cuentakilómetros. Posteriormente, aparte del coste de los elementos
físicos, habrá que añadir un coste de mano de obra.
Display
El coste del display es directamente el coste del dispositivo cuyo
precio ascendía a los 21€.
Memoria
El coste de la memoria es mucho más reducido que el del display
y también en este caso es directamente el coste del dispositivo. El precio
de la memoria ascendía hasta los 6€.
Sensor
El sensor es muy simple y convencional por lo que su precio es
muy bajo y no se considera dentro del presupuesto.
Tarjetas de desarrollo
Las tarjetas de desarrollo son los dispositivos más caros de todo el
proyecto sin lugar a dudas. Éstas venían además con dos pilas de 9V, dos
fuentes de alimentación, el dispositivo necesario para volcar los
programas al microcontrolador y dos cables de conexión vía serie. El
precio de todo el paquete ascendía hasta los 200€.
Presupuesto
78
Mano de obra
Para realizar el cálculo de la mano de obra, se supondrá que el
coste de la hora de mano de obra de un ingeniero es de 55€/hora. Se
estima que para la elaboración del proyecto se han empleado unas 300
horas. Por tanto, el coste de la mano de obra total asciende hasta los
16.500€.
Es decir, que si se decidiera fabricar un único dispositivo, el precio
del mismo ascendería hasta los 16.727€, cifra absolutamente inaceptable.
Sin embargo, nunca se utilizarían 300 horas de mano de obra de un
ingeniero en fabricar una única unidad. Lo que se hace es llevar a cabo
una producción de muchas unidades, de manera que la mano de obra, que
es el coste más caro, se reparta entre todos ellos.
Por tanto, en esta ocasión se supone una producción de 1000
unidades del cuentakilómetros creado en este proyecto. Ahora se
necesitarían 2000 tarjetas de desarrollo, 1000 memorias, 1000 sensores y
1000 displays. De nuevo, la aportación de los sensores es tan ridícula que
se desprecia. El coste total, una vez sumada ya la aportación de la mano de
obra, es de 443.500€. Por tanto, el coste de una unidad creada a partir de
una serie de 1000 es de 443,5€.
Como se puede observar, el precio es ligeramente alto ya que más
de 400€ por un cuentakilómetros es un precio desorbitado, sobre todo
comparándolo con los de la competencia que cuestan menos de 300€ y son
bastante más sofisticados.