Informe - Escuela de Ingeniería Eléctrica

Universidad de Costa Rica
Facultad de Ingeniería
Escuela de Ingeniería Eléctrica
IE – 0502 Proyecto Eléctrico
Diseño e Implementación de una pantalla de agua
de 9 válvulas, controlada por una placa de
desarrollo Arduino (ATMega328P-Duemilanove)
Por:
Luis Roberto Castro Silva
Ciudad Universitaria Rodrigo Facio
12 del 2010
Diseño e Implementación de una pantalla de agua
de 9 válvulas, controlada por una placa de
desarrollo Arduino (ATMega328P-Duemilanove)
Por:
Luis Roberto Castro Silva
Sometido a la Escuela de Ingeniería Eléctrica
de la Facultad de Ingeniería
de la Universidad de Costa Rica
como requisito parcial para optar por el grado de:
BACHILLER EN INGENIERÍA ELÉCTRICA
Aprobado por el Tribunal:
_________________________________
Ing. Lucky Lochi Yu Lo
Profesor Guía
_________________________________
Ing. Esteban Ortiz Cubero
Profesor lector
_________________________________
Ing. Roberto A. Herrera Matamoros
Profesor lector
ii
DEDICATORIA
A mi abuela Yolanda Montero Cascante a quién le agradezco por su apoyo y
reconocimiento. Descansa en paz.
ii
RECONOCIMIENTOS
Por el aporte al desarrollo de este trabajo por medio de recomendaciones generales
y consejos académicos al Ing. Roberto Herrera, Ing. y tutor Lochi Yu e Ing. Esteban Ortiz.
Por la ayuda como consultor en temas de mecánica y fluídos, recomendaciones y
facilidad en la búsqueda y selección de algunos materiales a mi padre José Roberto Castro
Montero.
iv
ÍNDICE GENERAL
DEDICATORIA .............................................................................iii
RECONOCIMIENTOS .................................................................iv
ÍNDICE DE FIGURAS .................................................................vii
ÍNDICE DE TABLAS ..................................................................viii
NOMENCLATURA .......................................................................ix
RESUMEN .......................................................................................x
CAPÍTULO 1: Introducción ..........................................................1
1.1 Objetivos............................................................................................3
1.1.1 Objetivo general...............................................................................................3
1.1.2 Objetivos específicos........................................................................................3
1.2 Metodología...........................................................................................4
CAPÍTULO 2: Marco teórico ........................................................5
2.1 Fluídos.....................................................................................................5
2.2 Principio de Bernoulli............................................................................6
2.3 Transistores de efecto de campo...........................................................6
2.4 Electroválvulas.....................................................................................10
2.5 Electrónica de control de electroválvulas..........................................12
2.6 Microcontrolador.................................................................................14
2.7 Placa de desarrollo Arduino................................................................15
CAPÍTULO 3: Construcción y programación ...........................18
3.1 Selección de Componentes..................................................................18
3.2 Pruebas con el prototipo armado......................................................21
3.3 Programación......................................................................................24
3.3.1 Módulo Serial.................................................................................................25
v
CAPÍTULO 4: Conclusiones y recomendaciones .......................31
4.1 Conclusiones........................................................................................31
4.2 Recomendaciones................................................................................32
BIBLIOGRAFÍA ...........................................................................34
APÉNDICES ..................................................................................35
Código del Arduino................................................................................................35
Código de transmisión serial (Python).................................................................45
ANEXOS ........................................................................................52
vi
ÍNDICE DE FIGURAS
Figura Nº 1.1 Diagrama completo de la pantalla................................................................ 1
Figura Nº 1.2 Componentes básicos del proyecto...............................................................2
Figura Nº 2.1 Construcción del Transistor JFET.[1].......................................................... 7
Figura Nº 2.2 Construcción del Transistor MOSFET.[2].................................................. 9
Figura Nº 2.3 Flujo del campo magnético en un solenoide.[4]........................................10
Figura Nº 2.4 Diagrama de funcionamiento del electromagneto.[6]............................... 11
Figura Nº 2.5 Electroválvula cerrada y abierta.[3]............................................................12
Figura Nº 2.6 Componente ULN2803 (Anexo 1).[7].......................................................13
Figura Nº 2.7 Diagrama eléctrico del control................................................................... 14
Figura Nº 2.8 Arduino Duemilanove ensamblado.[5].......................................................15
Figura Nº 2.9 Software de programación del Arduino.[5]................................................16
Figura Nº 3.1 Distribución de (6) válvulas para dibujar letra H...................................... 19
Figura Nº 3.2 Captura de la Interfaz de la pantalla de agua.............................................29
vi
ÍNDICE DE TABLAS
Tabla 3.1 Componentes Iniciales...................................................................................... 18
Tabla 3.2 Componentes finales........................................................................................21
Tabla 3.3 Codificación de las figuras según ASCII.........................................................26
vi
NOMENCLATURA
P = Presión en el punto
ρ = Densidad del fluido en kilogramos por metro cúbico
gn = Aceleración de la gravedad = 9.81 metros por segundo, por segundo
v = Velocidad media de flujo en metros por minuto
H = Altura total expresada en metros de columna del fluido
z = Altura o elevación potencial sobre el nivel de referencia en metros
ms = Mili segundos
m = Metros
V = Voltios
mA = Miliamperios
ix
RESUMEN
El presente proyecto consiste en el diseño, implementación y construcción de una
pantalla de agua que puede formar figuras en el aire con chorros de agua que se dejan caer
en forma controlada por medio de electroválvulas manejadas por medio de salidas digitales
de un microcontrolador. Además de desarrollar el sistema electrónico y de control se
programa una interfaz para computadora amigable al usuario para que sea fácil de formar
las figuras.
El propósito principal es formar letras y figuras geométricas básicas para
poder pasar mensajes por la pantalla. El método seguido y disponible en este documento
contempla las etapas de diseño, selección de componentes, construcción y pruebas para la
creación de un prototipo que sea completamente funcional pero de dimensión pequeña. Si
bien este proyecto requiere en gran parte conocimiento profundo en mecánica de fluídos,
el planeamiento y desarrollo del prototipo se basa en el control electrónico, mientras la
parte mecánica se menciona y explica de manera superficial. En su mayoría las decisiones
correspondientes a mecánica de fluídos se fundamentan en experimentos empíricos y
también estrechamente ligados al presupuesto disponible.
El prototipo al final del proyecto es completamente funcional según los objetivos
iniciales, sin embargo la cantidad de válvulas y su tiempo de reacción no son suficientes
para que las figuras sean fácilmente distinguibles. Se llega a la conclusión de que con una
mayor cantidad de válvulas y aumentando la altura inicial de caída del chorro se pueden
obtener mejores resultados.
x
1
CAPÍTULO 1: Introducción
El presente proyecto tiene la intención de realizar un diseño de una pantalla de agua
con propósito publicitario, que podría reemplazar las pantallas LED en ciertas ubicaciones
y contextos donde se busque una relación con la naturaleza. Es por esto que también se
consideró utilizar un sistema de realimentación del agua por medio de una pequeña bomba
sumergida. Por efectos de costo y orientación del proyecto a ofertas publicitarias pequeñas
se decidió utilizar entre ocho y diez válvulas para la pantalla, las cuáles pretenden ser
suficientes para al menos poder mostrar texto desplazándose (ver Figura 1.1).
Figura Nº 1.1 Diagrama completo de la pantalla.
2
Además del producto funcional es muy importante la interfaz de usuario que
permite la utilización de este. Es por eso que como parte de este proyecto se desea realizar
una interfaz amigable con el usuario final que haga a la pantalla más fácil de usar.
Para la producción de un producto como este se debe dividir en diferentes etapas.
Para empezar se tiene la de diseño; donde se debe tomar en cuenta todos los factores
mecánicos y eléctricos para realizar planos y decidir cuáles son los componentes con los
que se piensa trabajar (ver Figura 1.2). Una vez realizada esta etapa se procede a la
implementación de los planos, que muy probablemente no van a ser los definitivos. Dado
que además de cambios durante el proceso de implementación también puede haber
cálculos o estimaciones durante la etapa de diseño que sean variables a la hora de hacer la
implementación. Lo anterior llevaría a un ciclo entre estas dos etapas que conlleva
correcciones para poder tener un producto finalizado y funcional. Dentro de la
implementación se podrían dividir sub etapas de construcción y pruebas.
Figura Nº 1.2 Componentes básicos del proyecto.
3
1.1
Objetivos
1.1.1
Objetivo general
Diseñar e implementar el control para crear una pantalla de agua que funcione con
presión proporcionada por un una bomba eléctrica sumergida que posea una interfaz de
entrada amigable para el usuario, para que la pantalla muestre patrones dibujados o escritos
fácilmente.
1.1.2
Objetivos específicos
•
Implementar la electrónica de control de las válvulas
•
Implementar dos diseños diferentes para mostrar con la pantalla de agua
•
Agregar efectos de luces a la pantalla de agua
4
1.2
Metodología
Para dar inicio al proyecto se debe hacer una selección de componentes mecánicos e
hidráulicos a utilizar en el diseño de acuerdo al presupuesto, sin dejar de lado las variables
físicas como presión y diámetro de tuberías. Si esta etapa se realiza con el suficiente
cuidado puede representar un ahorro significativo durante el desarrollo del proyecto, ya que
puede evitar gastos innecesarios en componentes innecesarios. Sin embargo no es fácil
tomar todas las decisiones correctas desde el principio, y siempre se dan algunos gastos
debido a aspectos que pasan por alto.
A continuación, se adquieren muestras de los componentes seleccionados, por
ejemplo comprar solo una de las nueve válvulas. Sin embargo existirán algunos como la
bomba que solo se necesita uno, entonces se debe adquirir con la mayor prudencia posible.
El proceso de pruebas de los componentes seleccionados se hace para que se pueda cambiar
componentes que no funcionan como se esperaba.
Luego se procede con la construcción del prototipo diseñado con los componentes
seleccionados y probados.
Una vez listo el prototipo se realizan las primeras pruebas con todos los
componentes funcionando al mismo tiempo, y en caso de haber problemas se repiten los
pasos 3 y 4 hasta que el prototipo funcione como se espera.
CAPÍTULO 2: Marco teórico
2.1
Fluídos
Un fluido se define como una sustancia que cambia su forma continuamente
siempre que esté sometida a un esfuerzo cortante, sin importar qué tan pequeño sea. En
contraste un sólido experimenta un desplazamiento definido (o se rompe completamente)
cuando se somete a un esfuerzo cortante.
Al considerar varios tipos de fluídos en condiciones estáticas, algunos presentan
cambios muy pequeños en su densidad a pesar de estar sometidos a grandes presiones.
Invariablemente, estos fluídos se encuentran en estado líquido cuando presentan este
comportamiento. En tales circunstancias, el fluido se denomina incompresible y se supone
que su densidad es constante para los cálculos. El estudio de fluídos incompresibles en
condiciones estáticas se conoce como hidrostática. Cuando la densidad no puede
considerarse constante bajo condiciones estáticas como en un gas, el fluido se denomina
compresible y, algunas veces, se utiliza el término aerostática para identificar esta clase de
problemas.
Los fluídos están compuestos por moléculas con movimientos y colisiones
constantes. Para ser exacto en un análisis, debería tenerse en cuenta la acción de cada
molécula o grupo de moléculas en un flujo. Tales procedimientos se adoptan en la teoría
cinética de los gases y en la mecánica estadística pero son, en general, demasiado
complejos para utilizarlos en aplicaciones de ingeniería. En la mayor parte de los cálculos
de ingeniería, el interés se centra en manifestaciones promedio medibles de muchas
moléculas, como, por ejemplo, densidad, presión y temperatura. Estas manifestaciones
pueden suponerse convenientemente como el resultado de una distribución continua
hipotética de materia, conocida como el continuo, en lugar del conglomerado real complejo
de las moléculas discretas. El concepto de continuo permite una gran simplificación en el
análisis y se han utilizado ya en cursos anteriores de mecánica los conceptos de un cuerpo
rígido o cuerpo perfectamente elástico.
5
6
2.2
Principio de Bernoulli
El teorema de Bernoulli es una forma de expresión de la aplicación de la ley de la
conservación de la energía al flujo de fluídos en una tubería. La energía total en un punto
cualquiera por encima de un plano horizontal arbitrario fijado como referencia, es igual a la
suma de la altura geométrica, la altura debida a la presión y la altura debida a la velocidad,
es decir:
P
v2
z−

=H
 g n 2gn
(2.2 – 1)
144P v 2
 =H

2g
(2.2 - 2)
z
Si las pérdidas por rozamiento se desprecian y no se aporta o se toma ninguna
energía del sistema de tuberías (bombas o turbinas), la altura total en la ecuación anterior
permanecerá constante para cualquier punto del fluido. Sin embargo, en la realidad existen
pérdidas o incrementos de energía que deben incluirse en la ecuación de Bernoulli. Por lo
tanto, el balance de energía puede escribirse para dos puntos del fluido. Todas las fórmulas
prácticas para el flujo de fluídos se derivan del teorema de Bernoulli, con modificaciones
para tener en cuenta las pérdidas debidas al rozamiento.
2.3
Transistores de efecto de campo
El transistor FET es un dispositivo de tres terminales que a diferencia del transistor
BJT que se controla por corriente, el FET es controlado por tensión eléctrica. Existen tanto
en combinación NPN como en PNP, a continuación se hace referencia a los transistores
tipo NPN únicamente. Este dispositivo es unipolar, por lo que depende únicamente de la
conducción de electrones (canal-n) o de huecos (canal-p). En el caso del transistor FET, se
establece un campo eléctrico mediante las cargas presentes, que controlará la trayectoria de
conducción del circuito de salida, sin la necesidad de un contacto directo entre las
cantidades controladoras y controladas.
7
Una de las características de estos transistores es que posee una gran impedancia de
entrada, con un nivel de uno y hasta varios cientos de megaohms, además de ser más
pequeños que los BJT.
JFET
El transistor JFET (Transistor de Efecto de Campo de Unión) tiene tres terminales,
donde una es capaz de controlar la corriente entre las otras dos. La construcción básica del
JFET se muestra en la figura 2.1 .
Figura Nº 2.1 Construcción del Transistor JFET.[1]
La mayor parte de la estructura de este transistor en tipo-n, que forma el canal entre
los las capas integradas tipo-p. La parte superior del canal tipo-n se encuentra conectada
por medio de un contacto óhmico a una terminal referida como drenaje (D), mientras que el
extremo inferior del mismo material se conecta por medio de un contacto óhmico a una
terminal referida como fuente (S). Los dos materiales de tipo p se encuentran conectados
entre sí y también con la terminal de compuerta (G). Por tanto, el drenaje y la fuente se
encuentran conectados a los extremos del canal tipo n y la compuerta a las dos capas de
material tipo p. En ausencia de potencial alguno aplicado, el JFET cuenta con dos uniones
p-n bajo condiciones sin polarización. El resultado es una región de agotamiento en cada
8
unión, la cual se asemeja a la misma región de un diodo bajo condiciones sin polarización.
Hay que recordar que una región de agotamiento es aquella región que no presenta
portadores libres y es incapaz de soportar la conducción a través de ella.
El nivel de tensión entre G y S que resulta cuando la corriente en D es cero, se
encuentra definido por VGS = VP, siendo VP una tensión negativa para los dispositivos de
canal tipo-n y una tensión
positiva para los JFET de canal tipo-p. En resumen el
funcionamiento es análogo al de una llave de paso en una tubería de agua. Donde la fuente
de la presión del agua es equivalente a la tensión aplicada del drenaje a la fuente, el cual
establecerá un flujo de agua (electrones), proveniente de la llave de paso (fuente). La
compuerta o válvula, mediante una señal aplicada (potencial), controlará el flujo de agua
(carga) hacia el drenaje.
MOSFET
Los transistores MOSFET (transistor de efecto de campo meta-óxidosemiconductor) se clasifican según el modo básico de operación en tipo incrementales y
decrementales, pero a continuación se refiere solo a los decrementales. La construcción
básica del MOSFET de tipo decremental de canal tipo-n se puede apreciar en la figura 2.2.
Un bloque de material tipo-p está formado a partir de una base de silicio a la que se le
conoce como sustrato, y es la base sobre la que se construye el dispositivo. En algunos
casos el sustrato se encuentra conectado internamente con la terminal de la fuente, aunque
muchos dispositivos discretos ofrecen una terminal adicional etiquetada como ”SS” que es
la conexión directa al sustrato, lo que da por resultado un dispositivo de cuatro terminales.
Las terminales de fuente y compuerta están conectadas por medio de contactos metálicos a
las regiones dopadas-n unidas por una canal-n. La compuerta se encuentra también
conectada a una superficie de contacto metálico, pero permanece aislada del canal-n por
medio de una capa muy delgada de dióxido de Silicio (SiO2). El SiO2 es un tipo particular
de aislante conocido como dieléctrico que genera campos eléctricos opuestos dentro del
dieléctrico cuando éste se expone a un campo aplicado externamente. Al ser esta capa
aislante no existe conexión eléctrica entre la terminal de la compuerta y el canal de un
9
MOSFET. Además es debido a la capa aislante del SiO2 en la construcción del MOSFET
que se explica la muy deseable alta impedancia de entrada del dispositivo.
Figura Nº 2.2 Construcción del Transistor MOSFET.[2]
La impedancia tan alta de entrada apoya el hecho de que la corriente de la
compuerta es esencialmente cero amperios para las configuraciones de polarización de
corriente directa.
Si la tensión de la compuerta a la fuente (V GS) se establece en cero mediante la
conexión directa de una terminal a la otra, y se aplica una tensión de drenaje a la fuente
(VDS) a través de las terminales de drenaje y fuente, el resultado es una atracción del
potencial positivo en el drenaje por los electrones libres del canal-n, y una corriente similar
a la establecida a través del canal del JFET. Con un potencial negativo en la compuerta
tiende a presionar a los electrones hacia el sustrato de tipo-p y a atraer huecos del sustrato
tipo-p. Según la magnitud de la polarización negativa establecida por V GS, ocurrirá un nivel
de recombinación entre los electrones y los huecos que reducirá el número de electrones
libres en el canal-n disponibles para la conducción, mientras que para valores positivos de
VGS, la compuerta positiva atraerá electrones adicionales desde el sustrato de tipo-p debido
a la corriente de fuga inversa, y establecerá nuevos portadores mediante las colisiones
10
resultantes entre las partículas en aceleración. A medida que siga aumentando la tensión la
corriente de drenaje se incrementará de manera acelerada.
2.4
Electroválvulas
Una electroválvula es una válvula electromecánica diseñada para controlar el flujo
de un fluido a través de un conducto como puede ser una tubería. Ésta válvula está
controlada por una corriente eléctrica a través de una bobina solenoidal. Una electroválvula
tiene dos partes fundamentales: el solenoide y la válvula.
Un solenoide es una bobina tridimensional (ver figura 2.3). Este término se refiere a
un arrollado de alambre usualmente enrollado alrededor de un núcleo metálico que produce
un campo magnético cuando una corriente eléctrica pasa a través de este. De esta manera
permite producir un campo magnético controladamente, función principal de un
electromagneto. El campo magnético está dado por la ecuación 2.4-1 y la dirección de las
líneas de flujo en la figura 2.3.
B=0 n I =0
NI
h
Figura Nº 2.3 Flujo del campo magnético en un solenoide.[4]
(2.4 – 1)
11
La válvula es la parte mecánica que se encarga de dejar pasar o detener el flujo del
líquido que se trata de hacer pasar por ella. Normalmente consta de un pistón metálico que
es atraído por el campo magnético y un resorte que lo impulsa a su posición inicial cuando
la bobina no está encendida (ver Figura 2.4). En la figura 2.5 se puede apreciar como es el
funcionamiento de la electroválvula donde A es la entrada, B el diafragma, C la cámara de
presión, D el conducto de vaciado de presión, E el solenoide y F la salida.
Figura Nº 2.4 Diagrama de funcionamiento del electromagneto.[6]
12
Figura Nº 2.5 Electroválvula cerrada y abierta.[3]
2.5
Electrónica de control de electroválvulas
Circuito Par Darlington
La configuración del circuito par Darlington normalmente consiste de dos
transistores, aunque puede contener más. El emisor del transistor de entrada se conecta
directamente a la base del segundo y ambos colectores se conectan en un mismo nodo, de
esta manera la corriente de base del primer transistor entra a la base del segundo. Esto
resulta en un alto nivel de ganancia en la corriente que es dada por la multiplicación de la
ganancia de ambos transistores. Por ejemplo dos transistores con una ganancia de corriente
de 50 cada uno, tendrían una ganancia de corriente de 2500.
13
Dado el tipo de válvulas a utilizar en este proyecto, es conveniente usar un conjunto
de transistores Darlington de alta tensión para activar y desactivarlas. Cada válvula puede
requerir un máximo de 450 mA con 12 V para activar la bobina, lo que hace que el
conjunto de Darlington NPN ULN2803 con capacidad de un amperio sea suficiente. ( ver
figura 2.6 )
Figura Nº 2.6 Componente ULN2803 (Anexo 1).[7]
Este componente deja pasar corriente entre el emisor y colector del transistor al ser
energizado con 5V en la base del transistor, entonces para energizar la válvula solo se
necesita energizar la base del transistor. Bajo este principio de funcionamiento al conectar
la patilla de base de cada transistor a una salida digital del microcontrolador, la apertura de
las válvulas es fácilmente controlable por un programa que ejecuta el AtMega168. En la
figura 2.7 se puede ver el diagrama de conexión para una válvula (bobina), el cual es
análogo para todas las válvulas restantes.
14
Figura Nº 2.7 Diagrama eléctrico del control.
2.6
Microcontrolador
Un microcontrolador es un circuito integrado de alta escala de integración que
incorpora la mayor parte de los elementos que configuran un controlador. Entre ellos se
pueden mencionar un procesador (CPU), buses, memoria RAM para los datos, memoria
ROM para el programa, periféricos y puertos de entrada y salida. Aunque inicialmente
todos los microcontroladores adoptaron la arquitectura clásica de Von Newmann, en el
momento presente se impone la arquitectura Harvard.
La arquitectura de Von Neumann se caracteriza por disponer de una sola memoria
principal donde se almacenan datos e instrucciones de forma indistinta. A dicha memoria se
accede a través de un sistema de buses único (direcciones, datos y control).
La arquitectura Harvard dispone de dos memorias independientes, una que contiene
sólo instrucciones y otra sólo de datos. Ambas disponen de sus respectivos sistemas de
buses de acceso y es posible realizar operaciones de acceso simultáneamente en ambas
memorias.
15
Este tipo de controladores operan de una manera cíclica, de manera que va
ejecutando las instrucciones del programa del usuario y al llegar al final del programa
vuelve a ejecutarlo nuevamente. Esta es característica importante durante el desarrollo del
programa a realizar debido a que el tiempo para ejecutar todo el programa debe ser
considerado.
2.7
Placa de desarrollo Arduino
Arduino es una plataforma prototipo de hardware libre. El Arduino puede sensar el
ambiente recibiendo de entrada una variedad de sensores y variar las salidas para controlar
actuadores. El microcontrolador es programado usando un lenguaje de programación
independiente (basado en el lenguaje de programación Wiring). La placa puede ser
construida a mano o comprarse ya ensamblada (ver figura 2.8).
Figura Nº 2.8 Arduino Duemilanove ensamblado.[5]
Esta placa también tiene una conexión Serial a USB comúnmente utilizada para
poder subir los programas al microcontrolador desde una computadora haciendo uso del
software de desarrollo para Arduino (ver figura 2.9). Este software consta de un editor de
texto para escribir el código, un área de mensaje, una consola de texto, una barra de botones
16
con funciones comunes y una serie de menús. Además el Arduino se puede programar para
comunicarse con los programas, y así analizar los datos enviados gracias al monitor serial
integrado.
Figura Nº 2.9 Software de programación del Arduino.[5]
Un programa normal siempre se rige por tres secciones principales, la
configuración, el desarrollo del programa dentro de un ciclo repetitivo y las funciones
personalizables del usuario. La etapa de la configuración es de gran importancia, dado que
al encender el microcontrolador es lo primero que ejecuta. Normalmente se utiliza para
decirle al microcontrolador como va a operar, porque muchos microcontroladores tienen
varias patillas compartidas para diferentes elementos proporcionados, de manera que una
patilla puede servir como entrada/salida o bien como entrada de un comparador. Además si
es configurado como entrada/salida debe elegirse si actuará solo como entrada o solo como
17
salida. Otro ejemplo es cuando se necesita que el microcontrolador se comunique por el
puerto serial, que este debe configurarse con el mismo protocolo que va a utilizar el
dispositivo con el que se va a comunicar.
Una vez configurado el microcontrolador continúa con el ciclo repetitivo que
contiene el programa del usuario. Debido al comportamiento repetitivo se debe tomar en
cuenta el tiempo que se tarda en cada ciclo, el cual puede ser variable. Es por esto que en
esta sección se utilizan mucho los temporizadores y contadores, para poder realizar la
función requerida en el tiempo necesario. También es donde se suele variar el estado de las
salidas que comúnmente buscan realizar un cambio o una acción por medio de un actuador.
Finalmente, está la sección de funciones personalizadas que es opcional, pero muy
útil para rutinas que sean grandes y repetitivas. Principalmente es para comodidad del
programador de no tener que escribir tantas veces el mismo código, pero si el compilador es
lo suficientemente inteligente el hacer uso de estas funciones permite ahorrar espacio en la
memoria ya que tiene solo una copia de la rutina en vez de guardarse todas las veces que se
utiliza.
18
CAPÍTULO 3: Construcción y programación
3.1 Selección de Componentes
Para empezar la construcción del prototipo de la pantalla de agua se deben elegir las
especificaciones de todas las partes que se van a adquirir. Para comenzar se eligen los
componentes de la tabla 3.1, la selección principalmente es por el presupuesto disponible y
el costo de las partes.
Tabla 3.1 Componentes Iniciales
Cantidad
Descripción
Costo individual
9
Electroválvula de solenoide 12V
8500 ₡
1
Bomba de Gasolina 12V para automóvil 3 BAR
(aprox. 40 psi) NPPN-011 DiForza
11000 ₡
1 de 3 metros
Tubo CPVC ½” de presión
3000 ₡
8
Unión “T” CPVC
450 ₡
9
Reducción CPVC
150 ₡
24
Gaza metálica sin-fin
140 ₡
1
Fuente ATX 12V para PC
12500 ₡
15 metros
Cable 14 AWG
700 / m ₡
1
Placa desarrollo Arduino
20000 ₡
2
Arreglo de Par Darlington ULN2803
3000 ₡
2 metros
Manguera de construcción transparente
400 ₡ / m
Las especificaciones de las electroválvulas que estaban disponibles soportan una
presión de hasta 149 psi y funcionan con 12V, pero no muestran información específica
respecto a los tiempos de respuesta, sin embargo dado el costo y la poca disponibilidad de
opciones se compran tres electroválvulas para comenzar a hacer pruebas de velocidad. Las
pruebas de tiempo de reacción de las válvulas mostraron resultados muy inexactos pero
19
parecen suficientes para continuar con el proyecto. Para estas pruebas se puso a conmutar
una válvula a una razón de 10 mili segundos cada segundo. Durante la prueba se nota que la
válvula puede abrir rápidamente, sin embargo es más lenta para cerrar y no parece haber
diferencia entre cerrar la válvula después de 10 mili segundos y 15 mili segundos. Tras
analizar los resultados se decide adquirir los válvulas restantes debido a que el tiempo de
reacción puede ser suficiente para crear figuras y letras, aunque de un tamaño mayor al
pensado inicialmente. El número de válvulas es elegido considerando el presupuesto y la
forma en la que se van a formar las figuras con el agua que cae en el aire. En un principio
se piensa en seis válvulas para tratar de formar letras con tres líneas verticales del mismo
ancho, de manera que cada dos válvulas conformen una línea, como se puede apreciar en la
figura 3.1 . Después, se decide añadir 3 válvulas más para darle un mayor tamaño a la letra
que podría no ser distinguida fácilmente.
Figura Nº 3.1 Distribución de (6) válvulas para dibujar letra H
Por otra parte, la tubería CPVC se prefiere sobre la PVC dado que las uniones en
forma de T son más pequeñas y permiten unir más las válvulas a pesar de ser ligeramente
más caras, sin embargo después de tener la tubería de distribución armada se observa que
en CPVC no existen conexiones para la manguera que se debe usar con la conexión de las
válvulas, por lo que se necesitaban comprar muchas reducciones de cobre con un costo muy
20
elevado . Por esta razón se sustituye la tubería de CPVC por una de cobre además de que
tenía las conexiones del tamaño debido para conectar la manguera, previene la turbulencia
que podía causar la tubería de CPVC, al tener diferentes diámetros internos entre el tubo y
las uniones. Para prevenir otro posible conflicto relacionado con la distribución equitativa
de la presión en cada válvula, antes de mandar a soldar la tubería se coloca una una
bifurcación en la entrada de agua para que no solo se alimente el tubo principal por un lado
sino que también tenga otra entrada en la mitad de la tubería.
Con la tubería de cobre y todas las válvulas en su lugar, se procede a conectar todos
los componentes para hacer pruebas con el sistema completo. Al iniciar con las pruebas se
notan fugas en las conexiones que estaban hechas con manguera transparente para
construcción, a pesar de estar reforzadas con gazas metálicas. Por tanto, con el fin de
eliminar estas fugas y evitar el aumento de presión que se daba por la elasticidad tan alta de
la manguera de construcción se procede a cambiarlas por manguera de alta presión
reforzada con forro de nylon. Una vez conectado el sistema con esta manguera se soluciona
por completo el problema de fugas y aumento de presión.
Finalmente, tras realizar todos los cambios mencionados anteriormente se procede a
armar el prototipo con los componentes de la tabla 3.2 .
21
Tabla 3.2 Componentes finales
Cantidad
Descripción
Costo individual
9
Electroválvula de solenoide 12V
8500 ₡
1
Bomba de Gasolina 12V para automóvil 3 BAR
(aprox. 40 psi) NPPN-011 DiForza
11000 ₡
1
Tubería de cobre con soldadura de aluminio
35000 ₡
24
Gaza metálica sin-fin
140 ₡
1
Fuente ATX 12V para PC
12500 ₡
15 metros
Cable 14 AWG
700 ₡ / m
1
Placa desarrollo Arduino
20000 ₡
3
Arreglo de Par Darlington ULN2803
3000 ₡
6 metros
Manguera de alta presión reforzada con nylon
2800 ₡ / m
3.2 Pruebas con el prototipo armado
Una vez con todo el sistema listo, se realizan pruebas de la parte programada, que
abriría y cerraría las electroválvulas de manera controlada para crear figuras y letras con el
agua. Tras varias pruebas con diferentes medidas de tiempo (5ms,10ms,20ms,30ms-...) se
nota que las letras o figuras pueden necesitar diferentes tiempos de apertura, y que los
tiempos de prueba que se obtuvieron con una sola válvula varían mucho cuando están todas
funcionando, esto repercute en una variación del tiempo mínimo de apertura y cerrado para
que se pueda notar una diferencia en el agua al caer.
Para elegir un tiempo mínimo de apertura o cerrado de la válvula que permita crear
una franja de agua más controlada se procede a realizar una nueva prueba con todas las
válvulas al mismo tiempo. En esta prueba se programa el microcontrolador para que deje
22
salir chorros de agua en cada válvula con un tiempo diferente de apertura, de manera que la
primera válvula abra y cierre con un frecuencia fija con período de 50 ms, la segunda con la
mitad de la frecuencia de la primera, la tercera con la mitad de la frecuencia de la segunda,
y así sucesivamente. Una vez configuradas todas las válvulas se hace una grabación de
video con una cámara que permita modificar la velocidad de apertura y así tomar más fotos
en una cantidad de tiempo. Con el tiempo elegido se tendrá una mejor visibilidad de las
figuras que se formen con el agua. Sin embargo siempre son necesarios pequeños cambios
en los valores como ajustes menores, esto se debe principalmente a la variación en la
presión del agua para cada válvula.
Después de analizar estas pruebas se observó un nuevo problema con las válvulas.
Si estas se mantenían cerradas por algún tiempo mientras no se estaba formando alguna
figura, después no se podían volver a abrir, al parecer porque la presión seguía aumentando.
Al finalizar todo el ciclo de pruebas se manifestaron aspectos muy críticos del
proyecto que ya no eran fáciles de reparar en la etapa que se encontraba. Por ejemplo:
•
Las letras no son visibles a distancias cortas, y aunque al incrementar la
distancia se vuelven más notorias, no son fácilmente distinguibles. La principal
causa de este problema es la cantidad de válvulas (ancho de la pantalla), y el
fondo detrás de la pantalla. Una posible solución es subir todo el mecanismo
completo a una mayor altura y poner otra bomba extra a bombear el agua al
23
tanque de captación que está más alto, además de agregar un colorante al agua
para que sea más visible frente a una pantalla blanca detrás de la cortina.
•
Aunque se hicieron modificaciones para tratar de distribuir de mejor manera la
presión en todas las válvulas, no está distribuida por igual en cada válvula. Esto
genera un problema muy notorio a la hora de abrir o cerrar varias válvulas al
mismo tiempo porque a pesar de que la velocidad del microcontrolador es
suficiente para hacerlo, la diferencia en la presión hace que el chorro de agua
salga más rápido por donde hay más presión dando como resultado que no se
logre formar una línea recta horizontal en las figuras. Otro problema con esto, es
que no siempre se ven afectadas las mismas válvulas y si se trata de poner un
retraso de tiempo a las válvulas con mayor presión este va a afectar a las otras
por la naturaleza secuencial. Para este problema no se encuentra una solución
barata y rápida, por lo que se tendría que rediseñar la tubería que distribuye el
agua a las válvulas.
•
Agregar efectos de luces al prototipo pasa a ser un objetivo de menor
importancia, dado que se tuvieron muchos gastos imprevistos
con las partes
más importantes del prototipo que dejan de lado esta característica que se
consideraba como un agregado. Sin embargo, debido al problema con el
contraste de las figuras con respecto al fondo se agrega una lámpara
24
incandescente de manera manual para facilitar la tarea de distinguir las figuras
formadas por los chorros de agua.
3.3 Programación
Para la programación del microcontrolador se utiliza el método cíclico inherente
del microcontrolador que se menciona el marco teórico. Durante la etapa de pruebas no se
tiene un controlador serial que reciba las señales provenientes de la computadora para
elegir qué figura dibujar, por lo que se declararon los retrasos y activaciones de los pines en
el programa principal. Sin embargo, por razones de eficiencia y prevenir tener que
reescribir código al implementarse el controlador serial se crean subrutinas para cada figura
desde el principio. En cada subrutina se utilizan retrasos de tiempo para abrir y cerrar las
válvulas, que son más fáciles de modificar si se declaran variables globales de los tiempos
para cada subrutina o figura. Además escribir de manera individual el cambio del estado de
cada pin se vuelve una tarea muy ineficiente y tediosa, entonces se crean pequeñas
subrutinas para abrir y cerrar los pines por grupos de tres, dividiéndose en izquierda, centro
y derecha. Por ejemplo en la siguiente porción de código se tiene la función de apertura y
cerrado de las válvulas del lado izquierdo.
void close_L() {
digitalWrite (valvePinL1,LOW);
digitalWrite (valvePinL2,LOW);
digitalWrite (valvePinL3,LOW);
}
void open_L() {
digitalWrite (valvePinL1,HIGH);
digitalWrite (valvePinL2,HIGH);
digitalWrite (valvePinL3,HIGH);
}
25
Análogamente se tienen estas mismas funciones para los otros dos grupos (centro,
derecha) y para cerrar y abrir todas las válvulas al mismo tiempo (close_all, open_all). Ya
con estas funciones no se gasta memoria innecesariamente ya que en lugar de guardar en
memoria lo mismo varias veces se tienen estas subrutinas una sola vez.
Un aspecto muy importante a tomar en cuenta cuando se está haciendo la función
para dibujar figuras es que ésta se debe dibujar de abajo hacia arriba debido a la naturaleza
de la caída del agua. La manera ideal sería que se activen todas las válvulas requeridas en
paralelo y al mismo tiempo, pero por la naturaleza del microcontrolador siempre se va a
activar una válvula después que la otra; aunque la velocidad del microcontrolador permite
que esta diferencia de tiempo sea despreciable.
3.3.1
Módulo Serial
Uno de los objetivos del proyecto era hacer una interfaz intuitiva para poder utilizar
la pantalla de agua de una manera fácil. Una manera de lograrlo es conectar el
microcontrolador a una computadora en donde se tiene un programa que le envía ordenes o
comandos por medio del puerto serial. Para poder comunicar la computadora con el
microcontrolador se usa la librería pyserial de Python. La razón para usar Python es por la
versatilidad y porque existe gran cantidad de librerías disponibles para uso con licencia
GPL, que permiten hacer cambios a la librería sin ningún problema de acceso al código.
La librería pyserial ofrece una interfaz de usuario muy fácil e intuitiva para
establecer una comunicación serial por cable USB o bien por RS-232. Por ejemplo, para
iniciar la comunicación solo necesita crear un objeto serial con los datos de descripción del
canal de comunicación, como lo son el tiempo de timeout, puerto, la velocidad de
transmisión en baudios y el xonxoff que es para habilitar el control de flujo por software tal
y como se muestra en la siguiente porción de código:
26
ser = serial.Serial(usbport, 9600, timeout=2, xonxoff=1)
Luego una vez preparada y activa la conexión serial, se procede a seleccionar la
codificación con la que se va a transmitir, para que el microcontrolador entienda que
significa cada símbolo. Debido a que se van a dibujar letras, la codificación ASCII parece
ser la más natural para transmitir, y también como se tienen algunas pocas figuras que no se
representan en ASCII se les asigna el código ASCII de los números del cero al diez. Como
se puede apreciar en la tabla 3.3.
Tabla 3.3 Codificación de las figuras según ASCII
Figura
Código
Figura
Código
A
97
S
115
B
98
T
116
C
99
U
117
D
100
V
118
E
101
X
119
F
102
Y
120
G
103
Z
121
H
104
0
48
I
105
1
49
J
106
2
50
K
107
3
51
L
108
4
52
M
109
5
53
N
110
6
54
27
O
111
7
55
P
112
8
56
Q
113
9
57
R
114
Con todos los códigos identificados, el paso siguiente es identificar cuando se pulsa
una tecla del teclado en la computadora y mandar el código por el puerto serial
seleccionado. Para poder identificar cuando una tecla es pulsada se utiliza otra librería de
Python llamada pygame. Esta librería fue creada con el propósito de tener una API sencilla
para hacer juegos con Python, por lo que no solo ofrece funciones para reconocer eventos
del teclado y controles de otro tipo, sino que también para crear ventanas y pantallas con
edición de imágenes. Ambas propiedades de la librería van a ser útiles para la interfaz de
usuario de la pantalla de agua, ya que también hay que mostrar que figura va a dibujar la
pantalla.
Para identificar cual tecla del teclado fue pulsada se debe crear un objeto de la clase
pygame y esperar dentro de un bucle por un evento “KEYDOWN” que es cuando se
presiona una tecla, luego se pregunta a ese evento cual fue la tecla presionada como se
puede apreciar en la siguiente porción de código que pregunta por la tecla “A”:
done=false
while not done:
for event in pygame.event.get():
if(event.type == KEYDOWN)
if (event.key == K_a):
print “A se presionó\n”
ser.write(chr(255))
ser.write(chr(97))
28
ser.write(chr(255))
Esta sección de código se repite para cada letra y figura que se quiera enviar al
microcontrolador, y para mandar el código se utiliza la función ser.write de la última línea.
Con el fin de evitar errores de transmisión y que el programa pueda entrar en estados no
conocidos se envía un 255 antes y después del código que se va a enviar.
Hasta ahora se tiene un programa que reconoce cuando se presiona una tecla y manda un
código por el puerto serial, pero no se tiene algo que nos muestre que se recibió el dato al
presionar la tecla más que la misma pantalla, entonces para dar retro alimentación se crea
una ventana con información del proyecto y que muestra cual tecla fue presionada y
enviada al microcontrolador. Esto se puede apreciar en la figura 3.2 .
Figura Nº 3.2 Captura de la Interfaz de la pantalla de agua
29
La manera más fácil para dibujar en la pantalla es cargar una imagen, por esto se
crea una imagen de fondo para la interfaz en un editor de imágenes que contenga una figura
representativa del proyecto e información del proyecto. Una vez lista la imagen se crea una
ventana con el método display de pygame que requiere el tamaño en pixéles de la ventana,
como en la siguiente porción de código:
screen = pygame.display.set_mode((640,480))
back = pygame.image.load('<path de imagen>')
screen.blit(back,(0,0))
pygame.display.flip()
Después se guarda en una variable la imagen que se quiere cargar con el método
image.load que requiere solo la dirección de la imagen. Ya una vez que la imagen está
cargada en memoria hay que especificar en la posición de la ventana en la que se va a
dibujar la imagen con la función blit y finalmente actualizar la capa principal de la ventana
con display.flip. Tras estos pasos se tiene una ventana con un fondo de una manera muy
sencilla.
El procedimiento para escribir en la ventana y así mostrar cuál tecla fue presionada
es muy similar a poner una imagen, porque lo que se tiene es una función integrada
(myfont.render) que recibe el texto que se quiere dibujar y la fuente a utilizar para que se
cargue en una variable como si fuera una imagen, y luego se procede a refrescar la ventana.
A continuación se puede ver el código para escribir en la ventana:
myfont = pygame.font.SysFont("Comic Sans MS", 30)
label = myfont.render(“8”, 1, yellow)
30
screen.blit(back,(0,0))
pygame.display.flip()
De esta manera se puede escribir pero al volver a escribir en el mismo lugar no se
borra la imagen anterior, por lo que se tiene que idear borrar la sección de la ventana en la
que se va a mostrar texto. Para esto se dibuja un rectángulo del color del fondo encima de la
zona de texto como se puede apreciar a continuación:
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
screen.blit(back,(0,0))
pygame.display.flip()
El uso de este lenguaje y las librerías disponibles facilita mucho la programación de
una interfaz para manejar el prototipo de pantalla de agua, demostrado por el poco código
necesario para crear una interfaz gráfica. Otra ventaja de Python es que es un lenguaje de
programación que no necesita paréntesis o llaves para encerrar bloques de código, sino que
para separar bloques se basa en sangrías y espacios, obligando al programador a ser más
ordenado.
31
CAPÍTULO 4: Conclusiones y recomendaciones
4.1 Conclusiones
•
La resolución que ofrecen nueve válvulas es muy pobre a la vista. Esto
porque al contar con tan pocas válvulas se ve muy poco contraste entre las
figuras realizadas y el alrededor.
•
La altura utilizada (2 m) para la caída del agua no es suficiente para que se
puedan apreciar las figuras y letras formadas. Esta altura no al limitar el
tamaño también requiere de válvulas más rápidas.
•
Las válvulas utilizadas para el prototipo no fueron una buena elección, el
principal problema fue que no cumplían con las especificaciones del
fabricante, ya que dicen soportar hasta 150 psi, pero al dejarlas cerradas con
solo 40 psi ya no lograban abrir de nuevo. Esto es la causa por la que las
figuras se forman por medio de contornos.
•
Para un funcionamiento óptimo de la pantalla se debe usar en condiciones
con muy poco viento, ya que provoca grandes perturbaciones en el recorrido
del chorro de agua y destruye la figura que se planea formar. Se recomienda
el uso en cuartos cerrados o con flujo de aire controlado.
•
La interfaz de comunicación serial permite que el control sea configurable,
ya que en un futuro se puede cambiar el comportamiento de las funciones
implementadas en el microcontrolador programándose por el puerto serial.
32
•
El diseño es modular y permite hacerle mejoras al prototipo, tal como
agregarle una interfaz inalámbrica en el puerto serial para poder ser
controlado de manera remota. Otra posible mejora es agregar un arreglo de
transistores que soporte mayor potencia para controlar también el encendido
y apagado de la bomba de agua.
•
El sistema de tuberías para distribución de presión en las válvulas no fue
efectivo, siempre había diferencias de presión en las válvulas y además estas
diferencias variaban según la figura que se había formado antes, por ende
lograr una línea horizontal era muy difícil.
4.2
•
Recomendaciones
Para apreciar fácilmente las figuras de la pantalla de agua se recomienda utilizar al
menos veinte válvulas para dibujar una sola letra. Además el uso de más válvulas
permite crear figuras más grandes y con mayor resolución. Para poder controlar más
válvulas con las mismas salidas digitales se recomienda hacer uso de un multiplexor
y asignarle un código a cada válvula, ya que aunque no es posible activar todas las
válvulas al mismo tiempo la velocidad del microcontrolador permite que le
diferencia de tiempo para activar la válvula siguiente sea despreciable. En caso de
33
que la cantidad de válvulas sea demasiado grande, existe la opción de buscar otro
microcontrolador que trabaje a una mayor velocidad.
•
Preferiblemente se deben colocar las válvulas desde una altura mayor a los dos
metros, para darle mayor tamaño a las figuras y no estar tan limitado a la velocidad
de apertura y cerrado de las válvulas. Si se aumenta la altura también se aumenta el
tiempo durante el cual el chorro de agua permanece en el aire, lo que también
representa la dificultad de mantener un chorro de agua uniforme durante la mayor
parte de la caída.
•
Se recomienda usar presión producida por gravedad, con un tanque de agua
construido de manera que ejerza la misma presión en cada salida de cada válvula y
utilizar una bomba solo para reutilizar el agua. Esta manera resulta más sencilla para
distribuir la presión eficazmente, pero exige mucho cuidado en la construcción del
tanque y el posicionamiento de las válvulas. Si se realiza este cambio las válvulas
seleccionadas podrían funcionar correctamente.
34
BIBLIOGRAFÍA
Libros:
1. H. Shames, I. ”Mecánica de Fluídos”, 3 edición, McGraw-Hill, Colombia, 1995.
2. División de Ingeniería de Crane, “Flujo de Fluídos en Válvulas, Accesorios y
Tuberías”, MacGraw-Hill.
3. Boylestad R. y Nashelsky L. “Electrónica: Teoría de circuitos y dispositivos
electrónicos”, 8 edición, Pearson, México, 2003.
Páginas web:
1. “Esquema interno del transistor JFET”.
http://commons.wikimedia.org/wiki/File:Esquema_interno_del_transistor_JFET.svg
(consultada en octubre del 2010)
2. “MOSFET”. http://www.zdnet.com/topics/mosfet (consultada en octubre del 2010)
3. “Electroválvulas”.
http://es.wikipedia.org/wiki/Electrovalvula
(consultada
en
octubre del 2010)
4. “Sources of magnetic Fields”.
http://www.sparknotes.com/physics/magneticforcesandfields/sourcesofmagneticfiel
ds/section3.rhtml (consultada en octubre del 2010)
5. ¨Arduino¨. http://www.arduino.cc/ (consultada en octubre del 2010)
6. ¨Solenoids¨. http://www.cvel.clemson.edu/auto/actuators/solenoids.html (consultada
en octubre del 2010)
7. “Breadboard redux”. http://karmalaboratory.com/petridish/2005/04/working_progres_5.html (consultada en octubre
del 2010)
35
APÉNDICES
Código del Arduino
// Por: Luis Roberto Castro Silva
// Proyecto de graduación Ingeniería Eléctrica
// Universidad de Costa Rica
// Pantalla de agua
//
////////////////////////////////////////////////////////////
#define timesquare 200 // tiempo de espera para
funcion print_square
#define minimo 100 // Minimo tiempo de apertura
para que sea visible
#define restest 50 // Minimo tiempo de apertura para
que sea visible
#define valvePinL1 10 // pin de control para valvula int data,data2,data3;
izq 1
#define valvePinL2 11 // pin de control para valvula void setup() {
izq 2
//definir pines de salida
#define valvePinL3 2 // pin de control para valvula
pinMode(valvePinL1, OUTPUT);
izq 3
pinMode(valvePinL2, OUTPUT);
#define valvePinC1 3 // pin de control para valvula
pinMode(valvePinL3, OUTPUT);
central 1
pinMode(valvePinC1, OUTPUT);
#define valvePinC2 4 // pin de control para valvula
pinMode(valvePinC2, OUTPUT);
central 2
pinMode(valvePinC3, OUTPUT);
#define valvePinC3 5 // pin de control para valvula
pinMode(valvePinR1, OUTPUT);
central 3
pinMode(valvePinR2, OUTPUT);
#define valvePinR1 6 // pin de control para valvula
pinMode(valvePinR3, OUTPUT);
der 1
Serial.begin(9600);
#define valvePinR2 7 // pin de control para valvula
}
der 2
#define valvePinR3 8 // pin de control para valvula
void loop() {
der 3
open_all();
#define h1 100
//3 define la altura del segmento
de arriba y abajo
if (Serial.available() > 2) {
#define h2 50
//15 define la altura de las lineas
// read the incoming byte:
centrales
data2 = Serial.read();
#define h2h 180
//12 define la diferencia de las
data = Serial.read();
alturas anteriores
data3 = Serial.read();
#define time1 150 // tiempo de espera para funcion
if(data2 == 255 && data3==255){
test
#define time2 100 // tiempo de espera para funcion
print_circle
if(data == 97){ //A
#define timearrow 50 // tiempo de espera para funcion print_A();
print_arrow
}
#define timetriangle 50 // tiempo de espera para
else if(data == 98){ //B
funcion print_triangle
print_B();
36
}
else if(data == 99){ //C
print_C();
}
else if(data == 100){ //D
print_D();
}
if(data == 101){ //E
print_E();
}
else if(data == 102){ //F
print_F();
}
else if(data == 103){ //G
print_G();
}
else if(data == 104){ //H
print_H();
}
else if(data == 105){ //I
print_I();
}
else if(data == 106){ //J
print_J();
}
else if(data == 107){ //K
print_K();
}
else if(data == 108){ //L
print_L();
}
else if(data == 109){ //M
print_M();
}
else if(data == 110){ //N
print_N();
}
else if(data == 111){ //O
print_O();
}
else if(data == 112){ //P
print_P();
}
else if(data == 113){ //Q
print_Q();
}
else if(data == 114){ //R
print_R();
}
else if(data == 115){ //S
print_S();
}
else if(data == 116){ //T
print_T();
}
else if(data == 117){ //U
print_U();
}
else if(data == 118){ //V
print_V();
}
else if(data == 119){ //w
print_W();
}
else if(data == 120){ //X
print_X();
}
else if(data == 121){ //Y
print_Y();
}
else if(data == 122){ //Z
print_Z();
}
else if(data == 49){ //1
test();
}
else if(data == 50){ //2
print_sin();
print_sin();
print_sin();
print_sin();
print_sin();
print_sin();
print_sin();
print_sin();
print_sin();
}
else if(data == 51){ //3
print_circle();
}
else if(data == 52){ //4
print_triangle();
}
else if(data == 53){ //5
37
print_square();
}
else if(data == 54){ //6
print_arrow();
}
else if(data == 55){ //7
print_test_res();
print_test_res();
print_test_res();
print_test_res();
print_test_res();
print_test_res();
print_test_res();
print_test_res();
print_test_res();
print_test_res();
print_test_res();
print_test_res();
print_test_res();
print_test_res();
print_test_res();
print_test_res();
}
else if(data == 56){ //8
print_del50();
print_del50();
print_del50();
print_del50();
print_del50();
print_del50();
print_del50();
print_del50();
print_del50();
}
else if(data == 48){ //0
print_abc();
}
} // if de 255
delay(1000);
open_all();
}
open_all();
} //loop
void print_del50() {
delay(restest);
close_all();
delay(restest);
open_all();
delay(restest);
close_all();
delay(restest);
open_all();
delay(restest);
close_all();
delay(restest);
open_all();
delay(restest);
close_all();
delay(restest);
open_all();
}
void close_L() {
//digitalWrite (valvePinL1,LOW);
digitalWrite (valvePinL2,LOW);
digitalWrite (valvePinL3,LOW);
}
void open_L() {
digitalWrite (valvePinL1,HIGH);
digitalWrite (valvePinL2,HIGH);
digitalWrite (valvePinL3,HIGH);
}
void close_C() {
digitalWrite (valvePinC1,LOW);
digitalWrite (valvePinC2,LOW);
digitalWrite (valvePinC3,LOW);
}
void open_C() {
digitalWrite (valvePinC1,HIGH);
digitalWrite (valvePinC2,HIGH);
digitalWrite (valvePinC3,HIGH);
}
void close_R() {
digitalWrite (valvePinR2,LOW);
digitalWrite (valvePinR1,LOW);
//digitalWrite (valvePinR3,LOW);
}
void open_R() {
digitalWrite (valvePinR1,HIGH);
digitalWrite (valvePinR2,HIGH);
digitalWrite (valvePinR3,HIGH);
}
38
void open_all() { //orden variado para diferencia de
tiempo al abrir para cada válvula
digitalWrite (valvePinL1,HIGH);
digitalWrite (valvePinC3,HIGH);
digitalWrite (valvePinR2,HIGH);
digitalWrite (valvePinR1,HIGH);
digitalWrite (valvePinR3,HIGH);
digitalWrite (valvePinC1,HIGH);
digitalWrite (valvePinC2,HIGH);
digitalWrite (valvePinL3,HIGH);
digitalWrite (valvePinL2,HIGH);
}
void close_all() {
close_L();
close_C();
close_R();
}
void close_all_full() {
digitalWrite (valvePinL1,LOW);
digitalWrite (valvePinL2,LOW);
digitalWrite (valvePinL3,LOW);
digitalWrite (valvePinC1,LOW);
digitalWrite (valvePinC2,LOW);
digitalWrite (valvePinC3,LOW);
digitalWrite (valvePinR1,LOW);
digitalWrite (valvePinR2,LOW);
digitalWrite (valvePinR3,LOW);
}
void test(){
open_all();
digitalWrite (valvePinL1,LOW);
delay(time1);
digitalWrite (valvePinL2,LOW);
digitalWrite (valvePinL1,HIGH);
delay(time1);
digitalWrite (valvePinL3,LOW);
digitalWrite (valvePinL2,HIGH);
delay(time1);
digitalWrite (valvePinC1,LOW);
digitalWrite (valvePinL3,HIGH);
delay(time1);
digitalWrite (valvePinC2,LOW);
digitalWrite (valvePinC1,HIGH);
delay(time1);
digitalWrite (valvePinC3,LOW);
digitalWrite (valvePinC2,HIGH);
delay(time1);
digitalWrite (valvePinR1,LOW);
digitalWrite (valvePinC3,HIGH);
delay(time1);
digitalWrite (valvePinR2,LOW);
digitalWrite (valvePinR1,HIGH);
delay(time1);
digitalWrite (valvePinR3,LOW);
digitalWrite (valvePinR2,HIGH);
delay(time1);
digitalWrite (valvePinR2,LOW);
digitalWrite (valvePinR3,HIGH);
delay(time1);
digitalWrite (valvePinC3,LOW);
digitalWrite (valvePinR1,HIGH);
delay(time1);
digitalWrite (valvePinC2,LOW);
digitalWrite (valvePinC3,HIGH);
delay(time1);
digitalWrite (valvePinC1,LOW);
digitalWrite (valvePinC2,HIGH);
delay(time1);
digitalWrite (valvePinL3,LOW);
digitalWrite (valvePinC1,HIGH);
delay(time1);
digitalWrite (valvePinL2,LOW);
digitalWrite (valvePinL3,HIGH);
delay(time1);
digitalWrite (valvePinL1,LOW);
digitalWrite (valvePinL2,HIGH);
delay(time1);
digitalWrite (valvePinL1,HIGH);
delay(time1);
open_all();
}
void print_arrow() {
open_all();
digitalWrite (valvePinC2,LOW);
delay(timearrow);
digitalWrite (valvePinC1,LOW);
digitalWrite (valvePinC3,LOW);
delay(timearrow);
digitalWrite (valvePinL3,LOW);
digitalWrite (valvePinR1,LOW);
delay(timearrow);
digitalWrite (valvePinL2,LOW);
39
digitalWrite (valvePinR2,LOW);
delay(timearrow);
open_L();
digitalWrite (valvePinC1,HIGH);
digitalWrite (valvePinC3,HIGH);
open_R();
delay(timearrow*6);
open_all();
}
void print_abc() {
open_all();
print_A();
delay(1000);
print_B();
delay(1000);
print_C();
delay(1000);
print_D();
delay(1000);
print_E();
delay(1000);
print_F();
delay(1000);
print_G();
delay(1000);
print_H();
delay(1000);
print_I();
delay(1000);
print_J();
delay(1000);
print_K();
delay(1000);
print_L();
delay(1000);
print_M();
delay(1000);
print_N();
delay(1000);
print_O();
delay(1000);
print_P();
delay(1000);
print_Q();
delay(1000);
print_R();
delay(1000);
print_S();
delay(1000);
print_T();
delay(1000);
print_U();
delay(1000);
print_V();
delay(1000);
print_W();
delay(1000);
print_X();
delay(1000);
print_Y();
delay(1000);
print_Z();
}
void print_sin() {
digitalWrite (valvePinL1,LOW);
delay(minimo);
digitalWrite (valvePinL1,HIGH);
digitalWrite (valvePinL2,LOW);
delay(minimo);
digitalWrite (valvePinL2,HIGH);
digitalWrite (valvePinL3,LOW);
delay(minimo);
digitalWrite (valvePinL3,HIGH);
digitalWrite (valvePinC1,LOW);
delay(minimo);
digitalWrite (valvePinC1,HIGH);
digitalWrite (valvePinC2,LOW);
delay(minimo);
digitalWrite (valvePinC2,HIGH);
digitalWrite (valvePinC3,LOW);
delay(minimo);
digitalWrite (valvePinC3,HIGH);
digitalWrite (valvePinR1,LOW);
delay(minimo);
digitalWrite (valvePinR1,HIGH);
digitalWrite (valvePinR2,LOW);
delay(minimo);
digitalWrite (valvePinR2,HIGH);
digitalWrite (valvePinR3,LOW);
delay(minimo);
digitalWrite (valvePinR3,HIGH);
digitalWrite (valvePinR2,LOW);
delay(minimo);
40
digitalWrite (valvePinR2,HIGH);
digitalWrite (valvePinR1,LOW);
delay(minimo);
digitalWrite (valvePinR1,HIGH);
digitalWrite (valvePinC3,LOW);
delay(minimo);
digitalWrite (valvePinC3,HIGH);
digitalWrite (valvePinC2,LOW);
delay(minimo);
digitalWrite (valvePinC2,HIGH);
digitalWrite (valvePinC1,LOW);
delay(minimo);
digitalWrite (valvePinC1,HIGH);
digitalWrite (valvePinL3,LOW);
delay(minimo);
digitalWrite (valvePinL3,HIGH);
digitalWrite (valvePinL2,LOW);
delay(minimo);
digitalWrite (valvePinL2,HIGH);
digitalWrite (valvePinL1,LOW);
delay(minimo);
digitalWrite (valvePinL1,HIGH);
}
void print_test_res() {
digitalWrite (valvePinL1,LOW);
digitalWrite (valvePinL2,LOW);
digitalWrite (valvePinL3,LOW);
digitalWrite (valvePinC1,LOW);
delay(restest);
digitalWrite (valvePinL1,HIGH);
delay(restest);
digitalWrite (valvePinL1,LOW);
digitalWrite (valvePinL2,HIGH);
delay(restest);
digitalWrite (valvePinL1,HIGH);
delay(restest);
digitalWrite (valvePinL1,LOW);
digitalWrite (valvePinL2,LOW);
digitalWrite (valvePinL3,HIGH);
delay(restest);
digitalWrite (valvePinL1,HIGH);
delay(restest);
digitalWrite (valvePinL1,LOW);
digitalWrite (valvePinL2,HIGH);
delay(restest);
digitalWrite (valvePinL1,HIGH);
delay(restest);
digitalWrite (valvePinL1,LOW);
digitalWrite (valvePinL2,LOW);
digitalWrite (valvePinL3,LOW);
digitalWrite (valvePinC1,HIGH);
delay(restest);
digitalWrite (valvePinL1,HIGH);
delay(restest);
digitalWrite (valvePinL1,LOW);
digitalWrite (valvePinL2,HIGH);
delay(restest);
digitalWrite (valvePinL1,HIGH);
delay(restest);
digitalWrite (valvePinL1,LOW);
digitalWrite (valvePinL2,LOW);
digitalWrite (valvePinL3,HIGH);
delay(restest);
digitalWrite (valvePinL1,HIGH);
delay(restest);
digitalWrite (valvePinL1,LOW);
digitalWrite (valvePinL2,HIGH);
delay(restest);
digitalWrite (valvePinL1,HIGH);
delay(restest);
digitalWrite (valvePinL1,LOW);
digitalWrite (valvePinL2,LOW);
digitalWrite (valvePinL3,LOW);
digitalWrite (valvePinC1,LOW);
}
void print_circle() { //falta depurar
//close_all_full();
digitalWrite (valvePinC2,LOW);
delay(50);
digitalWrite (valvePinC1,LOW);
digitalWrite (valvePinC3,LOW);
delay(50);
digitalWrite (valvePinR1,LOW);
digitalWrite (valvePinL3,LOW);
delay(50);
digitalWrite (valvePinR2,LOW);
digitalWrite (valvePinL2,LOW);
delay(50);
digitalWrite (valvePinR3,LOW);
digitalWrite (valvePinL1,LOW);
delay(20);
41
digitalWrite (valvePinR3,HIGH);
digitalWrite (valvePinL1,HIGH);
delay(50);
digitalWrite (valvePinR2,HIGH);
digitalWrite (valvePinL2,HIGH);
delay(50);
digitalWrite (valvePinR1,HIGH);
digitalWrite (valvePinL3,HIGH);
delay(50);
digitalWrite (valvePinC1,HIGH);
digitalWrite (valvePinC3,HIGH);
delay(50);
digitalWrite (valvePinC2,HIGH);
delay(50);
open_all();
}
void print_triangle() {
close_all();
delay(timetriangle);
digitalWrite (valvePinL2,HIGH);
digitalWrite (valvePinR2,HIGH);
delay(timetriangle);
digitalWrite (valvePinL3,HIGH);
digitalWrite (valvePinR1,HIGH);
delay(timetriangle);
digitalWrite (valvePinC3,HIGH);
digitalWrite (valvePinC1,HIGH);
delay(timetriangle);
digitalWrite (valvePinC2,HIGH);
open_all();
}
void print_square() {
close_all();
delay(timesquare);
open_all();
}
//Funciones para las letras, Abecedario
void print_A() { //funcion para imprimir letra A
close_L();
close_R();
delay(h2);
delay(h1);
close_C();
delay(h2);
open_C();
delay(h1);
close_all();
delay(h2);
open_all();
}
void print_B () {
close_all();
delay (h2);
open_C();
delay (h1);
close_C();
delay (h2);
open_C();
delay(h1);
close_C();
delay (h2);
open_all();
}
void print_C() {
close_all();
delay(h2);
open_C();
open_R();
delay(h1);
delay(h2);
delay(h1);
close_C();
close_R();
delay(h2);
open_all();
}
void print_D() {
close_all();
delay(h2);
open_C();
delay(h1);
delay(h2);
delay(h1);
close_C();
delay(h2);
open_all();
}
void print_E() {
open_all();
close_L();
close_C();
close_R();
delay(h2);
open_C();
42
open_R();
delay(h1);
close_C();
close_R();
delay(h2);
open_C();
open_R();
delay(h1);
close_C();
close_R();
delay(h2);
open_all();
}
void print_F() {
close_L();
delay(h2);
delay(h1);
close_C();
close_R();
delay(h2);
open_C();
open_R();
delay(h1);
close_C();
close_R();
delay(h2);
open_all();
}
void print_G() {
close_all();
delay(h2);
open_C();
delay(h1);
close_C();
delay(h2);
open_C();
open_R();
delay(h1);
close_all();
delay(h2);
open_all();
}
void print_H() {
close_L();
close_R();
delay(h2);
delay(h1);
close_C();
delay(h2);
open_C();
delay(h1);
delay(h2);
open_all();
}
void print_I() {
close_all();
delay(h2);
open_L();
open_R();
delay(h1);
delay(h2);
delay(h1);
close_all();
delay(h2);
open_all();
}
void print_J() {
close_all();
delay(h2);
open_L();
open_C();
delay(h1);
delay(h2);
delay(h1);
close_C();
delay(h2);
open_all();
}
void print_K() {
close_L();
close_R();
delay(h1);
close_C();
delay(h2);
open_C();
delay(h1);
open_all();
}
void print_L() {
close_all();
delay(h2);
open_C();
open_R();
delay(h1);
43
delay(h2);
delay(h1);
delay(h2);
open_all();
}
void print_M() {
close_L();
close_R();
delay(2*h2);
close_C();
delay(h1);
open_C();
delay(2*h2);
close_C();
open_all();
}
void print_N() {
close_L();
close_R();
delay(h2);
delay(h1);
close_C();
delay(h2);
open_C();
delay(h1);
open_all();
}
void print_O() {
close_all();
delay(h2);
open_C();
delay(h1);
delay(h2);
delay(h1);
close_C();
delay(h2);
open_all();
}
void print_P() {
close_L();
delay(h2);
delay(h1);
close_C();
close_R();
delay(h2);
open_C();
delay(h1);
close_C();
delay(h2);
open_all();
}
void print_Q() {
close_all();
delay(h2);
open_C();
delay(h1);
delay(h2);
delay(h1);
close_C();
delay(h2);
open_all();
}
void print_R() {
close_L();
close_R();
delay(h2);
delay(h1);
close_C();
delay(h2);
open_C();
delay(h1);
close_all();
delay(h2);
open_all();
}
void print_S(){
close_all();
delay(h2);
open_L();
open_C();
delay(h1);
close_all();
delay(h2);
open_R();
open_C();
delay(h1);
close_all();
delay(h2);
open_all();
}
void print_T() {
close_C();
delay(h2);
delay(h1);
44
delay(h2);
delay(h1);
close_all();
delay(h2);
open_all();
}
void print_U() {
close_all();
delay(h2);
open_C();
delay(h1);
delay(h2);
delay(h1);
delay(h2);
open_all();
}
void print_V() {
close_C();
delay(2*h2);
open_C();
close_L();
close_R();
delay(h1);
delay(h2);
delay(h1);
delay(h2);
open_all();
}
void print_W() {
close_L();
close_R();
delay(2*h2);
close_C();
delay(2*h2);
open_C();
delay(h1);
delay(2*h2);
open_all();
}
void print_X() {
close_L();
close_R();
delay(h2);
delay(h1);
close_C();
delay(h2);
open_C();
delay(h1);
open_all();
}
void print_Y() {
close_C();
delay(h2);
delay(h1);
close_L();
close_R();
delay(h2);
open_C();
delay(h1);
delay(h2);
open_all();
}
void print_Z(){
close_all();
delay(h2);
open_R();
open_C();
delay(h1);
close_all();
delay(h2);
open_L();
open_C();
delay(h1);
close_all();
delay(h2);
open_all();
}
45
Código de transmisión serial (Python)
#!/usr/bin/env python
import pygame
import serial
from pygame.locals import *
pygame.init()
yellow = (255, 255, 0)
black = (0, 0, 0)
screen = pygame.display.set_mode((640, 480))
pygame.display.set_caption('Pygame Caption')
back = pygame.image.load('/home/rcs/arduino/sketches/pantalla_agua/pantalla.png')
screen.blit(back, (0, 0))
pygame.display.flip()
pygame.display.set_caption("Pantalla de Agua")
myfont = pygame.font.SysFont("Comic Sans MS", 30)
label = myfont.render("Pantalla de agua lista...", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
pygame.mouse.set_visible(1)
##Esta parte inicializa la comunicacion serial
usbport = '/dev/ttyUSB0'
ser = serial.Serial(usbport, 9600, timeout=2, xonxoff=1)
done = False
while not done:
for event in pygame.event.get():
if (event.type == KEYDOWN):
if (event.key == K_a):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("A", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(97))
ser.write(chr(255))
elif (event.key == K_b):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("B", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
46
ser.write(chr(255))
ser.write(chr(98))
ser.write(chr(255))
elif (event.key == K_c):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("C", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(99))
ser.write(chr(255))
elif (event.key == K_d):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("D", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(100))
ser.write(chr(255))
elif (event.key == K_e):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("E", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(101))
ser.write(chr(255))
elif (event.key == K_f):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("F", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(102))
ser.write(chr(255))
elif (event.key == K_g):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("G", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(103))
47
ser.write(chr(255))
elif (event.key == K_h):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("H", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(104))
ser.write(chr(255))
elif (event.key == K_i):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("I", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(105))
ser.write(chr(255))
elif (event.key == K_j):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("J", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(106))
ser.write(chr(255))
elif (event.key == K_k):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("K", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(107))
ser.write(chr(255))
elif (event.key == K_l):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("L", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
48
ser.write(chr(108))
ser.write(chr(255))
elif (event.key == K_m):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("M", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(109))
ser.write(chr(255))
elif (event.key == K_n):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("N", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(110))
ser.write(chr(255))
elif (event.key == K_o):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("O", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(111))
ser.write(chr(255))
elif (event.key == K_p):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("P", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(112))
ser.write(chr(255))
elif (event.key == K_q):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("Q", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(113))
ser.write(chr(255))
49
elif (event.key == K_r):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("R", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(114))
ser.write(chr(255))
elif (event.key == K_s):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("S", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(115))
ser.write(chr(255))
elif (event.key == K_t):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("T", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(116))
ser.write(chr(255))
elif (event.key == K_u):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("U", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(117))
ser.write(chr(255))
elif (event.key == K_v):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("V", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(118))
ser.write(chr(255))
elif (event.key == K_w):
50
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("W", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(119))
ser.write(chr(255))
elif (event.key == K_x):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("X", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(120))
ser.write(chr(255))
elif (event.key == K_y):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("Y", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(121))
ser.write(chr(255))
elif (event.key == K_z):
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("Z", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(122))
ser.write(chr(255))
elif (event.key == K_0):
print "0\n"
pygame.draw.rect(screen, black, (10, 400, 10000, 100), 0)
label = myfont.render("0", 1, yellow)
screen.blit(label, (10, 400))
pygame.display.flip()
ser.write(chr(255))
ser.write(chr(48))
ser.write(chr(255))
elif (event.key == K_1):
print "1\n"
ser.write(chr(255))
ser.write(chr(49))
51
ser.write(chr(255))
elif (event.key == K_2):
print "2\n"
ser.write(chr(255))
ser.write(chr(50))
ser.write(chr(255))
elif (event.key == K_3):
print "3\n"
ser.write(chr(255))
ser.write(chr(51))
ser.write(chr(255))
elif (event.key == K_4):
print "4\n"
ser.write(chr(255))
ser.write(chr(52))
ser.write(chr(255))
elif (event.key == K_5):
print "5\n"
ser.write(chr(255))
ser.write(chr(53))
ser.write(chr(255))
elif (event.key == K_6):
print "6\n"
ser.write(chr(255))
ser.write(chr(54))
ser.write(chr(255))
elif (event.key == K_7):
print "7\n"
ser.write(chr(255))
ser.write(chr(55))
ser.write(chr(255))
elif (event.key == K_8):
print "8\n"
ser.write(chr(255))
ser.write(chr(56))
ser.write(chr(255))
elif (event.key == K_9):
print "9\n"
ser.write(chr(255))
ser.write(chr(57))
ser.write(chr(255))
elif (event.key == K_ESCAPE):
done = True
52
ANEXOS
Ver archivos digitales adjuntos.