Descripción:
Un elemento importante para la programación es decidir que acciones tomar en diferentes situaciones y para esto se hace uso de condicionales y operadores logicos, estos condicionales deciden el flujo de las acciones a tomar.
En este ejercicio veremos el uso de condicionales para controlar el flujo de acciones determinado por condiciones sencillas de operadores lógicos.
Contenido/Competencias:
- Programa aplicaciones para sistemas automatizados.
- CE9 Diseña modelos o prototipos para resolver problemas, satisfacer necesidades o
demostrar principios científicos - CG6.1 Elige las fuentes de información más relevantes para un propósito específico y
discrimina entre ellas de acuerdo a su relevancia y confiabilidad - OM1 Actualizarse respecto a las mejores prácticas en su especialidad o área de
trabajo
El Plan:
Para poder tomar decisiones con los condicionales debemos analizar:
- Operadores lógicos
- NOT
- AND
- OR
- Comparadores
Hardware:
| Descripción | Cantidad | Notas |
|---|---|---|
| Arduino UNO | 1 | Compatible |
| Resistencia | 1 | 330 Ohms |
| Boton de presion | 1 | |
| Interruptor | 2 | Compatible |
| LED | 1 | Cualquier color |
| Cables | Varios |
Software:
- Arduino IDE o Editor de preferencia
- Arduino UNO o Simulador (Proteus VSM, TinkerCAD)
Recursos:
- http://www.tinkercad.com
- Archivo Proteus (Opcional)
Diagrama:
Desarrollo Teórico
Operadores logicos
Los operadores lógicos nos van a ayudar a relacionar condiciones y el resultado solo puede tomar uno de dos valores, Verdadero (1 o 5v) o Falso (0 o 0v). se pueden relacionar de dos o mas condiciones para construir una ecuación mas detallada.
Not (!)
El operador NOT es el único de los operadores que veremos que solo usa una condición y la invierte, es decir, si la condición es Verdadera, el resultado es Falso, y si la condición es Falsa el resultado es Verdadero. Se utiliza con el símbolo !.
Si la variable de la condicion es A tendriamos (1 es Verdadero, 0 es Falso):
| A | !A |
|---|---|
| 0 | 1 |
| 1 | 0 |
En el caso de usar INPUT_PULLUP, cuando el botón esta sin presionar el valor es Verdadero, y cuando lo presionas cambia a Falso. La manera de arreglar ese problema es negando con un NOT la lectura.
int Resultado = !digitalRead(x);o se niega el resultado obtenido al usarse.
int Resultado = digitalRead(x);
digitalWrite(y, !Resultado);tu decides cual usar.
AND (&&)
El operador AND funciona comparando dos o más entradas relacionando con un condicional con la siguiente tabla:
| A | B | A&&B |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
En esta tabla, tenemos 2 variables, A y B, cuando una de ellas es verdadero y la otra es falso, el resultado es siempre falso, solo cuando A y B son verdadero el resultado es verdadero.
OR (||)
El operador logico OR compara dos o mas variables usando la siguiente tabla:
| A | B | A | B | |
|---|---|---|---|---|
| 0 | 0 | 0 | ||
| 0 | 1 | 1 | ||
| 1 | 0 | 1 | ||
| 1 | 1 | 1 |
aqui vemos que cuando al menos una de las variables es verdadero el resultado es verdadero, el resultado siempre es verdadero cuando A o B son verdadero.
Comparadores
| Comparador | Descripcion |
|---|---|
| A == B | A es igual a B |
| A !=B | A no es igual a B |
| A > B | A mayor que B |
| A < B | A menor que B |
| A >= B | A mayor o igual que B |
| A <= B | A menor o igual que B |
Desarrollo:
Una vez armado el circuito se vería similar a esto:
con este diagrama construido vamos a realizar varios ejercicios de los temas expuestos.
El código base es este:
// Variables Globales
int led_rojo=13;
int boton_1=6;
int interruptor_1=3;
int interruptor_2=2;
void setup()
{ // Inicializacion de puertos
pinMode(led_rojo, OUTPUT);
pinMode(boton_1,INPUT_PULLUP);
pinMode(interruptor_1,INPUT_PULLUP);
pinMode(interruptor_2,INPUT_PULLUP);
}
void loop()
{
// El codigo de prueba va en esta seccion
}en la sección de Variables Globales declaramos una variable mas amigable para cada puerto que vamos a utilizar, por ejemplo, el puerto 13 lo usaremos con el led rojo y por eso se le asigna un nombre relacionado o fácil de deducir. igual para los demás puertos.
en la sección de setup() configuramos los puertos como entradas o salidas dependiendo el caso.
Los interruptores y botones los configuramos con una resistencia interna de PULLUP. quiere decir que cuando el interruptor este activo o presionado el valor de lectura será falso.
El resto del código lo trabajamos en la sección de loop().
Lectura de entradas
Para poder apreciar mejor la captura de las entradas y como usar la configuración PULLUP interna de Arduino vamos a usar el botón y el led para observar cómo trabajan.
Vamos a capturar las acciones del botón y reflejarlas en el led. Para esto usaremos la función digitalRead()que va a leer el estado del botón y este resultado lo asignaremos a la variable captura.
Cuando tengamos este valor lo pondremos en el led con la función digitalWrite(). El código completo se vera así:
// Variables Globales
int led_rojo=13;
int boton_1=6;
int interruptor_1=3;
int interruptor_2=2;
void setup()
{ // Inicializacion de puertos
pinMode(led_rojo, OUTPUT);
pinMode(boton_1,INPUT_PULLUP);
pinMode(interruptor_1,INPUT_PULLUP);
pinMode(interruptor_2,INPUT_PULLUP);
}
void loop()
{
int lectura=digitalRead(boton_1);
digitalWrite(led_rojo,lectura);
}Cuando prendes el circuito el led se va a encender por que la lectura del botón esta en verdadero, ya que la resistencia interna PULLUP la tiene así hasta que presiones el botón, por eso cuando presionas el botón el led se apaga. Quiere decir que la lógica que usamos para el botón esta inversa, hay que hacer algo al respecto. Empecemos a usar los operadores lógicos para corregir esto.
Nota: Prueba con los interruptores 1 y 2 por tu cuenta y descubre que resultados tendríamos al leer los estados. ¿Dónde prende y donde apaga?
void loop()
{
int lectura=digitalRead(interruptor_1);
digitalWrite(led_rojo,lectura);
}Operadores sencillos
Los operadores lógicos y de comparación nos pueden ayudar en armar una lógica de eventos y ayudarnos para tomar decisiones para el flujo de nuestro programa.
Not
Un detalle con la lógica del botón es que tiene una lógica inversa; si el botón esta sin presionar leemos un verdadero y cuando lo presionamos leemos un falso.
Para solucionar esto podemos usar el operador NOT, con esto hacemos la conversión de un verdadero por un falso y viceversa.
Tenemos dos opciones para usarlo. Se hace la negación en la captura o en el uso de esa captura.
En captura solo agregamos el operador en la asignación de la captura:
void loop()
{
int lectura=!digitalRead(interruptor_1);
digitalWrite(led_rojo,lectura);
}Si queremos negar la captura solamente cuando la usamos (Solo ahí) se cambia:
void loop()
{
int lectura=digitalRead(interruptor_1);
digitalWrite(led_rojo,!lectura);
}Nota: solo agregamos el operador ! donde vamos a negar el valor.
AND
Para este ejercicio vamos a utilizar los dos interruptores, toma en cuenta la posición en la que encendía el led, recuerda que usas una PULLUP interno y vas a leer un falso cuando esta presionado hay que usar el NOT (!) en la lectura o en el uso de esa variable.
Para simplificar la negación la haremos en la captura de la variable.
int lectura_A = !digitalRead(interruptor_1);
int lectura_B = !digitalRead(interruptor_2);para que el resultado de la operación se refleje en el led, usaremos digitalWrite(<puerto>,<valor>) de esta manera:
digitalWrite(led_rojo,(lectura_A && lectura_B));El loop() quedaría así:
void loop()
{
int lectura_A = !digitalRead(interruptor_1);
int lectura_B = !digitalRead(interruptor_2);
digitalWrite(led_rojo,(lectura_A && lectura_B));
}Con este circuito y código verifica la tabla del operador AND (&&) usando tu circuito.
| lectura_A | lectura_B | lectura_A && lectura_B |
|---|---|---|
| 0 | 0 | ? |
| 0 | 1 | ? |
| 1 | 0 | ? |
| 1 | 1 | ? |
OR
Similar al operador lógico AND vamos a usar el operador OR (||) tomando las mismas lecturas, solo modificamos la operación lógica en el despliegue del led.
| lectura_A | lectura_B | lectura_A \ | \ | lectura_B |
|---|---|---|---|---|
| 0 | 0 | ? | ||
| 0 | 1 | ? | ||
| 1 | 0 | ? | ||
| 1 | 1 | ? |
Comparadores
Para el uso de los comparadores no usaremos los interruptores, lo vamos a hacer directo, pondremos valores en las variables y las compararemos poniendo el resultado de la comparación en el led.
Prueba con valores de lecturas que sepas que resultado vas a tener por ejemplo 4 y 5 respectivamente, para que identifiques cuando se cumplen con los comparadores.
El loop() quedaría así para == igual a:
void loop()
{
int lectura_A = 4;
int lectura_B = 5;
digitalWrite(led_rojo,(lectura_A == lectura_B));
}El loop() quedaría así para >= mayor o igual a:
void loop()
{
int lectura_A = 4;
int lectura_B = 5;
digitalWrite(led_rojo,(lectura_A == lectura_B));
}Completa las comparaciones y cambia los valores de la variables para que pruebes su funcionamiento.
| Comparador | Resultado |
|---|---|
| lectura_A == lectura_B | ? |
| lectura_A != lectura_B | ? |
| lectura_A > lectura_B | ? |
| lectura_A < lectura_B | ? |
| lectura_A >= lectura_B | ? |
| lectura_A <= lectura_B | ? |
Conclusiones:
El uso de los operadores lógicos y las comparaciones nos da un principio de decisión para el flujo de lo que va a suceder con nuestro programa, las acciones a tomar las podemos dirigir dependiendo de eventos o decisiones del usuario.
Estas operaciones lógicas junto con las comparaciones son esenciales para la dirección de nuestro programa.