Tabla de contenido

📙 Introducción

Las sentencias condicionales y la lectura de entradas son elementos fundamentales en la programación de sistemas embebidos y dispositivos electrónicos. Estas herramientas permiten tomar decisiones y responder a diferentes condiciones dentro del programa, lo que es esencial para controlar el comportamiento del sistema en tiempo real.

En esta sección, exploráremos los conceptos básicos de las sentencias condicionales, como el if, if-else, else if encadenado y switch case, así como la lectura de entradas en dispositivos electrónicos, que es crucial para interactuar con el entorno y responder a eventos externos.

📘 Fundamento Teórico

📖 Operadores de Asignación y Comparación

Los operadores de comparación son herramientas fundamentales en las sentencias condicionales. Estos operadores permiten comparar dos valores y determinar si son iguales, diferentes, mayores, menores, o mayores/menores o iguales.

Ejemplo	Descripción	Explicación
=	Asignación	Se utiliza para asignar el valor de la derecha al operando de la izquierda.
==	Comparación	Comprueba si los valores de dos operandos son iguales.

📑 Ejemplo en C

condition
x == y (x is equal to y)
x != y (x is not equal to y)
x <  y (x is less than y)
x >  y (x is greater than y)
x <= y (x is less than or equal to y)
x >= y (x is greater than or equal to y)

📖 Sentencias condicionales

📄 Sentencia condicional “If”

La sentencia if permite ejecutar un bloque de código si se cumple una condición especificada.

📑 Ejemplo en C

if (condition) 
{
  //statement(s)
}

📄 Sentencia condicional “if - else”

La sentencia if-else permite ejecutar un bloque de código si se cumple una condición y otro bloque de código si no se cumple la condición.

📑 Ejemplo en C

if (condition) 
{
  //statement(s)
}
else
{
  //statement(s)
}

📄 Sentencia condicional “else if encadenado”

La estructura else if encadenado permite evaluar múltiples condiciones en secuencia.

📑 Ejemplo en C

if (condition) 
{
  //statement(s)
}
	else if (condition)
	{
	  //statement(s)
	}
		else if (condition)
			{
			  //statement(s)
			}
				else
				{
				  //statement(s)
				}

📄 Sentencia condicional “Switch case”

La estructura switch case permite evaluar una expresión y ejecutar diferentes bloques de código según el valor de la expresión.

📑 Ejemplo en C

switch (var) 
{
  case constante1:
    // statements
    break;
  case constante2:
    // statements
    break;
  case constante3:
    // statements
    break;
  default:
    // statements
    break;
}

📖 Lectura de entradas

La lectura de entradas es fundamental en la interacción de sistemas electrónicos con su entorno. Para leer una entrada, se realiza una operación de AND bitwise entre el puerto de entrada y una máscara que indica qué bit se desea leer. Esto permite determinar el estado de un bit específico y tomar decisiones basadas en este estado.

Para leer una entrada existe la siguiente manera:

Se llama el puerto de entrada PINX = 0bXXXXXXXX el cual contiene un numero desconocido, después se crea una máscara con una and bitwise con el número 0b00000001 para saber el estado del bit 0 sin importar los demás para crear la siguiente lógica

$$ \begin{align} 0bxxxxxxxx\\ \&\ 0b00000001 \\Res = 0b0000000x \end{align} $$

📑 Ejemplo en AVR

//-Mascara de bits
//PINX -> puerto de lectura
// & compuerta and bitwise
//0b00000001 -> bit a evaluar (bit0)
if (PINX & 0b00000001)
//0bXXXXXXX**X** & 0b00000001 = 0b0000000**X**
//0bXXXXXXX0 & 0b00000001 = 0b00000000 = 0 = LOW
//0bXXXXXXX1 & 0b00000001 = 0b00000001 = 1 = HIGH

//-Si el bit 0 es 1 entra al if
if (PINX & 0b00000001)
//-Reducido
if (PINX & (1 << PINX0))
//-Reducido con Macro
if (PINX & _BV(PINX0))
//--Reducido con Macro AVR
if (bit_is_set(PINX,PINX0))
//--Reducido con Macro AVR
if (bit_is_clear(PINX,PINX0))
//--Custom Macro
#define buttons_pinx   PIND
#define button_1       PIND3
#define button_1_read  buttons_pinx & (1 << button_1)

📖 Operadores Bitwise vs Operadores Lógicos

Los operadores bitwise permiten realizar operaciones a nivel de bits, lo que es útil en situaciones donde se necesita manipular datos a nivel binario.

Operadores bitwise	Descripción	Explicación
&	AND (Y bitwise)	Realiza una operación AND bit a bit entre dos operandos.
		OR (O bitwise)
~	NOT (Negación bitwise)	Invierte cada bit del operando.
^	XOR (O exclusivo bitwise)	Realiza una operación OR exclusiva bit a bit entre dos operandos.

Los operadores lógicos son esenciales para realizar operaciones de lógica booleana en la programación y ayudan a controlar el flujo del programa.

Expresión	Aplicación	Explicación
&&	AND lógico	Devuelve true si ambos operandos son true, de lo contrario, devuelve false.

!	NOT lógico	Invierte el valor de verdad del operando.

📖 Ejemplos Operadores Lógicos

📄 && → AND

El operador && realiza una operación de AND lógico entre dos condiciones. Devuelve true si ambas condiciones son verdaderas, y false en cualquier otro caso.

if (condition1 && condition2)
{
  // Bloque de código si ambas condiciones son verdaderas
}
else
{
  // Bloque de código si al menos una de las condiciones es falsa
}

📄 || → OR

El operador || realiza una operación de OR lógico entre dos condiciones. Devuelve true si al menos una de las condiciones es verdadera, y false solo si ambas condiciones son falsas.

if (condition1 || condition2) 
{
  // Bloque de código si al menos una de las condiciones es verdadera
}
else
{
  // Bloque de código si ambas condiciones son falsas
}