Informe N°4

Monitores en Serie
Proyecto Integrador Arquitectura de Computadores
Seleccionando dos secuencias
El primer circuito creado para realizar las dos secuencias distintas con los pulsadores
fue el siguiente:

Circuito en Tinkercad: https://www.tinkercad.com/things/a9FcbHQRv2o-copy-of-

secuencias-2-pulsadores/editel?tenant=circuits
Video del circuito en acción:

El circuito consta de 2 pulsadores para las

2 secuencias planteadas en el problema y
de 4 leds, dispuestos en una disposición
cuadrangular para el posterior encendido
en sentido tanto horario como anti
horario, para esto, era necesario
programar los botones y sugerirles la
secuencia en cuestión para el respectivo
botón. En caso de pulsar el primer botón
(izquierda), los leds se encenderán en
sentido horario y, posteriormente se
apagarán en el mismo sentido, pulsando
el segundo botón (derecha) los leds
encenderán rápidamente 2 veces, pero
esta vez, en sentido anti horario.

PÁGINA 1
La programación de este circuito fue elaborado siguiendo un video tutorial de:
https://www.youtube.com/watch?v=lrkG_-CyENY, ya que, queríamos que la secuencia
cambie inmediatamente al pulsar el botón, esto se logró utilizando una técnica de
"multi-tasking" utilizando delay, cabe recalcar que es la técnica de multi-tasking más
"arcaica" o simple ya que existen otras utilizando distintas funciones como “milis()” o
“micros()” pero se optó por esta ya que viene más al caso y es lo que se ha mostrado y
utilizado en las actividades anteriores.

El multi tasking se lleva a cabo en función del tiempo que necesitemos para las
funcionalidades del circuito, partiendo de la base de un bajo delay que permitirá
ejecutar en seguida el siguiente ciclo del loop principal de Arduino, utilizando
contadores debemos tener en cuenta el tiempo que queremos para las funcionalidades
del ciclo, es decir, si queremos encender por 1 segundo el led y consideramos un delay
de 20 en un inicio, deberíamos hacer la acción en cuanto el contador llega a los 50 [50
x 20 = 1000], por lo que cada encendido se ejecutará cada 1000 milisegundos, pero, con
la ventaja de poder recibir siempre informacion cada los 20 milisegundos considerados
con el delay inicial.

Siguiendo esta lógica fueron programadas las secuencias

planteadas, únicamente agregando la particularidad de
utilizar una función que nuevamente fue sacada del video,
que sugiere el encedido y apagado de luces con la negación
del mismo, o sea, la primera vez que se ejecuta obtiene el
estado del led, el cual será LOW, después, lo enciende con
la negación utilizando digitalWrite(pin, !estadoLed) y
encenderá, para la siguiente ejecución pasara lo contrario:
el estado HIGH, lo negará y se convertirá en LOW, por
último los botones únicamente siguen la Resistencia Pull-
down, permitiendo que al pulsarlo pase la corriente y
cambiar el estado de la variable booleana que indica el
botón pulsado.

PÁGINA 2
Agregar el monitor serial no supuso
ninguna complicación ya que la
programación del botón permite
que al pulsar ocurra lo siguiente:

a) Cambiar el estado de la variable

del botón, llevando a un estado
verdadero, es decir, el botón fue
pulsado.

b) Dejar en falso el otro botón,

llevando a la secuencia correcta. En
este caso lo único necesario era
agregar que en cuanto se pulsara el
botón, se mostrara el texto de
"Botón X fue presionado".

COMPLICACIONES

Existieron muchas complicaciones respecto al primer circuito principalmente por el

malentendido del problema, ya que planteamos para solucionarlo la utilización de los
mismos 2 botones, pero, planteamos 4 secuencias distintas, las cuales costó llevar a
cabo porque desconocíamos cómo hacer el multi tasking, por lo que, las secuencias se
ejecutaban por mucho tiempo y el botón al ser pulsado no recibía la señal debido a que
el circuito se seguía ejecutando, únicamente cambiaba la secuencia cuando recibía la
señal en el final de la secuencia.

Otro problema a considerar fue que los tiempos de ejecución eran muy pequeños entre
un ciclo y otro del loop principal de Arduino, por lo que, al dejar pulsado el botón por
mucho tiempo se imprime múltiples veces el texto de "Botón X fue pulsado" lo cual
puede llegar a ser innecesario, pero a nuestro parecer, la inmediatez que permite los
pequeños tiempos de delay son mas pros que contras, ya que la secuencia se ejecuta
inmediatamente y termina la otra mostrando un flujo de circuito y programa bastante
atractivo.

PÁGINA 3
Encendiendo a través del Monitor en Serie
Esta parte del informe comenzó probando el código dado de ejemplo y estudiándolo
para entender cómo funciona la lectura a través del Monitor en Serie (escrito en código
como “Serial.read()”) . Lo destacable de este ejemplo es el uso de la variable “char”, o
carácter en español, lo cual significa que el monitor serial sólo leerá un carácter o letra,
siendo inútil el ingreso de cualquier “String”, “Integer”, “Float”, etc.

A la hora de realizar nuestro propio circuito y código nos planteamos la idea de leer
variables tipo “String” en lugar de “char”, lo cual nos generó una gran cantidad
problemas. Primeramente, se intentó definir la variable “char[]” llamada “leer” la cual
recibiría una secuencia de “chars” a través del monitor serial y luego ésta se compararía
con la secuencia esperada de “char[]”, para la lectura utilizamos “Serial.read()”.
Teniendo definida esta parte del código intentamos aplicarlo al Arduino y nos
resultaba en errores, intentamos cambiando la secuencia de lugar dentro del código e
intentar convertir “Integers” a “String” pues este era el error que nos entregaba el
Arduino IDE, ambas soluciones resultaron sin éxito.

No fue hasta que investigamos acerca de la correcta implementación de los “String” en

Arduino que nos dimos cuenta de que simplemente la variable “String” se define igual
que cualquier otra, colocándola al inicio de la línea, asociándole un nombre y un valor,
aunque cabe destacar que ésta debe ir fuera del “void loop()”, debido a problemas que
resultan en este circuito en específico. El valor asociado fue un espacio vacío pues éste
se reemplazará por lo leído a través del Monitor Serial y su nombre fue definido como
“leer”. Como es habitual definimos los pines a utilizar en los pines 8, 9, 10 y 11 como
“outputs”.

Una vez solucionadas las complicaciones

comenzamos a implementar el código, éste
funcionará leyendo a través del Monitor Serial y
esperará hasta que se le asigne una orden. Estas
órdenes están definidas como “start” el cuál iniciará
una secuencia de encendidos y apagados de los leds
11 hasta el 8, en orden de izquierda a derecha y a
una velocidad de 500 milisegundos. La segunda
orden definida es “fast” el cuál encenderá y apagará
los leds de la misma forma que el “start” pero con la
diferencia de que el delay será de 100 milisegundos.
La tercera orden definida es “reverse”, la cual posee
el mismo delay que la orden “start”,
diferenciándose en su orden de encendidos y
apagados, la cual está inversa: de los pins 8 hasta 11
y de derecha a izquierda. La última orden es
“random” la cuál como su nombre indica,
encenderá y apagará los leds en un orden aleatorio
y con un delay de 300 milisegundos.

PÁGINA 4
Nos ayudamos en una variable entera contador
para controlar la cantidad de veces que se repetirá
cada condicional, empezando esta variable en cero
y sumándosele uno cada vez que termine un ciclo.
Esta variable luego será evaluada por un pequeño
condicional “if”, el cual determinará que, si
contador es mayor que 2, “leer” volverá a estar
vacía, de forma que vuelva a entrar al primer ciclo
“if”, defina contador como cero y espere órdenes
del teclado nuevamente.

La última complicación enfrentada fue la lectura

del “String” entregado, pues igualábamos la
variable leer a “start” cuando ésta debía ser
igualada a “start\n” y de la misma forma con las
demás condicionales “else if”.

Circuito en Tinkercad: https://www.tinkercad.com/things/0kOpjBJKSeO-smooth-crift-

allis/editel?sharecode=wtqf9QPgzwSabF0elA4rqxAkCQzI9nJ0eRhv8-LJtzY
Video del circuito en acción:

PÁGINA 5
Conclusión
A modo de conclusión es muy importante conocer la técnica empleada para realizar
“multi tasking” en Arduino ya que permite una fluidez en la ejecución del circuito y
nos deja lograr con toda la efectividad el propósito del mismo, sin depender de la
suerte o del conocimiento del código para efectuar bien la transición entre los distintos
estados del dispositivo.

Por un lado comprendimos por completo el correcto uso de Strings a base de fallo y
error, como también la definición de variables en su lugar correspondido, pues no da
igual ubicarlas en el void setup(), void loop() como fuera de ambos. Por otro,
aprendimos las distintas funcionalidades básicas del “Serial” las cuales nos abren las
puertas a muchas más ideas de circuitos las cuáles no hubieramos pensado de otra
forma.

Por otra parte mencionar lo interesante de la interacción que se realiza en este

momento con el usuario al utilizar los dispositivos de entrada como el teclado (a través
del Serial.read), como también permitiéndonos reflejar lo introducido por pantalla (a
través del Serial.print), además, esta interacción con el usuario nos hace ver lo
desconocido que es Arduino para nosotros y que aún existen muchas más
funcionalidades por explorar y realizar en futuras actividades o proyectos.

PÁGINA 6