INSTITUTO TECNOLÓGICO DE TIJUANA

MICROCONTROLADORES

Bitácora

Fortunato Ramírez Arzate

Presenta:
Mancilla Chávez Brenda Guadalupe, 21212745

Tijuana B.C., 18 de mayo de 2024

 Práctica 1. Introducción a la
programación del Microcontrolador

Tipos y capacidades de memorias

Tiene información necesaria para iniciar la computadora, ejecutar programas y acceder a datos

Todas las RAM (Random Acces Memory, memoria de acceso aleatorio) tienen
la capacidad de lectura y escritura, pero pierden los datos almacenados
RAM
cuando se desconecta la alimentación, recibiendo el nombre de memorias
volátiles. Tienen capacidad de memoria de 8 GB o 16 GB.

(Read Only Memory, memoria de sólo lectura) mantiene de forma

ROM permanente los datos almacenados. Empezando con kB hasta GB de
almacenamiento

Son memorias de lectura/ escritura, no volátil, de bajo consumo, que se

puede escribir y borrar. Funciona como ROM y una RAM pero consume
FLASH menos y es más pequeña. A diferencia de la ROM, la memoria FLASH es
programable en el circuito. con capacidad de almacenamiento desde GB a
TB.

Almacena datos temporales. Es útil para gestionar variables locales y el

Pila control de flujo en programas. El almacenamiento predeterminado puede
ser de 8MB, aunque puede ser ajustado por el usuario.

Tipos de datos, tamaño de memoria y rango de valores para cada

tipo de dato con signo y sin signo
 Descripción Tamaño de memoria Rango de valores

Bool Dos valores: true y false 1 byte (8 bits) verdadero (1) o falso (0)

Char Almacena caracteres 1 byte (8 bits) -128 a 127

individuales.

Unsigned Variable del tipo de dato 1 byte (8 bits) 0 a 255

char/byte char donde se
almacenan valores
enteros sin signo.

int Cantidad entera 2 bytes (16 bits) -32,768 a 32,767

negativa y positiva.

Unsigned int Variable del tipo de dato 2 bytes (16 bits) 0 to 65,535
int para almacenar
valores enteros sin
signo.

long Variable numérica de 4 bytes (32 bits) -2,147,483,648 a

tipo extendido (números 2,147,483,647
enteros sin decimales)

unsigned long Variable del tipo de dato 4 bytes (32 bits) 0 a 4,294,967,295
long que almacena
valores enteros sin
signo.

float Cantidades con 4 bytes (32 bits) 1.175494E-38 a

decimales. 3.402823E+38

double Almacena valores reales 8 bytes (64 bits) 1.797693E-308 a

en doble precisión. 1.797693E+308

string Cadena de caracteres 1 byte (8 bits) Array de caracteres

array Colección de variables a 1 byte (8 bits) Colección de variables

las que se accede con
un número de índice.

short Dato entero que se 2 bytes (16 bits) -32,768 a 32,767

utiliza para almacenar
 números más pequeños
que el int.

Representación de un número de punto flotante, describir la

estructura utilizada con bits para representar el signo, la base y la
mantisa

Signo Exponente Mantisa

float (32 bits) 1 bit. Indica si el 8 bits. Representa el 23 bits. representa la

número es positivo (0) exponente en una fracción del número.
o negativo (1). forma desplazada para
el exponente es 127.

double (64 bits) 1 bit. Igual que float. 11 bits. Representa el 52 bits. Igual que float,
exponente en una el primer bit (implícito)
forma desplazada para se asume como 1 y no
el exponente 1032. se almacena.

Ejemplo

Considerando el número “-5.75” en formato float:

1. Convertir a binario:
a. La parte entera: “5” en binario es 101
b. La parte fraccionaria: “0.75” en binario es -101.11
2. Convertir a notación científica binaria:
a. -101.11 se convierte en -1.0111 x 2^2
3. Desglosar los componentes
a. Signo: 1 (porque el número es negativo)
b. Exponente: 2 en binario es “10”, pero se almacena en formato biased: 2+127 =129 y en binario es
10000001
c. Mantisa: 0111 (el primer 1 es implícito y no se almacena)
4. Juntar todo
a. Signo: 1
b. Exponente: 10000001
c. Mantisa: 01110000000000000000000

Por lo tanto, -5.75 en formato float es

1 10000001 01110000000000000000000

Operadores lógicos
AND (&&)

Verifica si todos los operandos son verdaderos: el resultado es verdadero solo cuando todos los operandos
son verdaderos.
 Primer operando Segundo operando Resultado

true true true

true false false

false true false

false false false

AND a nivel de bits(&)

Ambos bits deben ser 1 para que el resultado sea 1 (igual que en una operación and ordinaria)

OR (||)

Verifica si al menos uno de los operandos es verdadero; el resultado es verdadero si al menos uno de los
operandos es verdadero.

Primer operando Segundo operando Resultado

true true true

true false true

false true true

false false false

OR a nivel de bits(|)

Basta con que un solo bit sea 1 para que el resultado sea 1.

NOT (!)
Niega el operando, es decir, devuelve lo opuesto al operando.

Operando Resultado

true true

false true

NOT a nivel de bits (~)

Realiza una operación NOT, invirtiendo el bit.

XOR a nivel de bits (^)

Realiza una operación XOR donde cada bit del resultado es 1 si los bits correspondientes expr1 y expr2 son
diferentes (uno es 1 y el otro 0).

Operador módulo
El operador modulo (%) se trata de un operador de división entre datos de tipo entero, que no obtiene el
cociente, sino el residuo o resto de la división. Solo se usa en datos de tipo int.

Representación de literales
Representan valores constantes que se pueden utilizar directamente en el código fuente.

Literales enteros

Decimal: se escribe como una secuencia de dígitos sin ningún prefijo.

Ejemplo: “1”, “123”, “0”
Octal: se escribe con un prefijo “0”.
Ejemplo: “01” (equivalente a decimal 1), “012” (equivalente a decimal 10)
Hexadecimal: se escribe con un prefijo “0x”.
Ejemplo: “ox1” (equivalente a decimal 1), “oxA” (equivalente a decimal 10)

Literales enteros

Decimal: se escribe como una secuencia de dígitos con un punto decimal.

Ejemplo: “1.0”, “3.14”, “0.001”
Notación científica: se escribe con un exponente utilizando “E”.
Ejemplo: “1E3” (equivalente a 1000), “3.14E-2” (equivalente a 0.0314)

Literales carácter

Carácter simple: se escribe entre comillas simples

Ejemplo: “ ‘a’ ”, “ ‘1’ ”, “ ‘\n’ ”
Carácter de escape: se utiliza la barra invertida (\) seguida de un carácter.
Ejemplo: “\n” (nueva línea), “\t” (tabulación), “\” (comilla simple)

Literales de cadena
 Cadena de caracteres: se escribe entre comillas dobles.
Ejemplo: “hola”, “123”, “” (cadena vacía).

Literales de tipo largo y sin signo

Largo (long): se añade el sufijo “L”.

Ejemplo: “123L”, “0x1L”.
Sin signo (unsigned): se añade el sufijo “U”
Ejemplo: “123U”, “ox1U”.
Largo sin signo (unsigned long): se combina el sufijo “L” y “U”.
Ejemplo: “123UL”, Ox1UL”

Palabras clave
Representan una instrucción que es entendida de una manera específica por el programa en la solución de un
problema. Se encuentran estandarizadas y cumplen con tareas específicas dentro de los programas y no
pueden usarse para propósitos diferentes.

Palabra reservada Descripción

const Específica que el objeto o variable no se puede

modificar.

static Crea almacenamiento permanente para una

variable.

void La función no devuelve ningún valor.

volatile Indica que un campo puede ser modificado por

varios subprocesos que se ejecutan al mismo
tiempo.

Casteo
El casteo o type casting es el proceso en el que el compilador convierte automáticamente un tipo de datos de
un programa en otro. Se realiza utilizando operadores específicos para indicar al compilador cómo interpretar o
convertir el valor de una expresión a otro tipo de dato.

(tipo_deseado) expresion

tipo_deseado: el tipo al que se desea convertir la expresión

expresion: es la variable, contante o expresión que se desea convertir.

Estructuras de control
Permiten al programador dirigir el flujo de ejecución del programa, tomar decisiones y realizar tareas repetitivas.
 Estructura Descripción

if Toma decisiones basadas en la evaluación de una

condición booleana.

if - else Ejecuta diferentes bloques de código dependiendo

el resultado de una condición.

if-else-if-else Evalúa múltiples condiciones en secuencia.

for Repetir un bloque de código un número específico

de veces.

while Permite ejecutar una instrucción o conjunto de

ellas una o más veces, siempre y cuando la
condición se cumpla, es decir, se evalúa como
verdadera.

do - while Garantiza que el bloque de código ejecute al menos

una vez antes de evaluar la condición.

switch Tomar decisiones múltiples basadas en el valor de

una variable.

Palabras de control
Son términos que tienen un significado especial específico en el lenguaje. No pueden ser utilizado como
identificadores.

Estructura Descripción

default Para casos en que ninguna de las sentencias case

sean verdaderas,

brake Sale inmediatamente de un bucle

continue salta al final de un bucle y comienza la siguiente

iteración.

Estructuras de datos
El casteo o type casting es el proceso en el que el compilador convierte automáticamente un t

Estructura Descripción

struct Dato que agrupa variables de diferentes tipos bajo

un mismo nombre. Útil para crear registros
complejos con múltiples atributos.

union Todos los miembros comparten la misma ubicación

de memoria. Solo uno de los miembros puede
almacenar un valor en un momento dado.

bitfield Para definir y acceder a porciones específicas de

bits dentro de una palabra de datos.

Funciones, llamado de funciones, retorno valores de las funciones

Funciones

Se diseña para realizar una tarea concreta, y normalmente su nombre refleja esa tarea. Una función contiene
declaraciones e instrucciones.

Llamado de funciones

No podemos llamar a una función en una sentencia sin que esté declarada previamente. La llamada a una
función se hace especificando su nombre y entre paréntesis, las expresiones cuyos valores se van a enviar
como argumentos de la función.

salida = nombre_funcion(arg_1, arg_2, ..., arg_n);

Retorno valores de las funciones

Cuando una función devuelve un valor, el valor se devuelve a través de una sentencia return al llamante de la
función.
Contenido
Práctica 2 – E/S Digitales y Retardos ............................................................................. 4
Marco teórico................................................................................................................ 4
Llamado implícito de funciones............................................................................... 4
Niveles lógicos: Alto, Bajo ....................................................................................... 5
Pull – down................................................................................................................ 6
Rebote mecánico de un push button ...................................................................... 6
Retardos en un microcontrolador como mecanismo para corregir el rebote
mecánico ................................................................................................................... 7
Algoritmo para la detección del flanco de subida de un push button .................. 7
Desarrollo ..................................................................................................................... 8
Código ....................................................................................................................... 9
Notas adicionales ....................................................................................................... 12
Conclusiones.............................................................................................................. 13
Referencias ................................................................................................................. 14
Práctica 3 – Temporizador/contador............................................................................. 14
Marco teórico.............................................................................................................. 14
Pull – up................................................................................................................... 14
Temporizadores/contadores en microcontrolador ............................................... 15
Desarrollo ................................................................................................................... 15
Código ..................................................................................................................... 15
Notas adicionales ....................................................................................................... 17
Conclusión.................................................................................................................. 18
Referencias ................................................................................................................. 18
Práctica 4 – juego de reflejos ........................................................................................ 19
Marco teórico.............................................................................................................. 19
Alta impedancia ...................................................................................................... 19
Temporizadores ...................................................................................................... 19
Técnica de CharliePlexing para controlar 6 leds con tres pines ......................... 20
Numero aleatorio dentro del microcontrolador .................................................... 20
Desarrollo ................................................................................................................... 21
Código ..................................................................................................................... 21
Conclusión.................................................................................................................. 28
Referencias ................................................................................................................. 28

2
Práctica 5 – Convertidores ADC y Comunicación Serial ............................................ 29
Marco teórico.............................................................................................................. 29
Conversión Analógica – Digital ............................................................................. 29
Resolución de Amplitud de un Convertidor ADC ................................................. 30
Módulos ADC del Microcontrolador ...................................................................... 30
Comunicación Serial del Microcontrolador .......................................................... 31
Desarrollo ................................................................................................................... 31
Código ..................................................................................................................... 32
Conclusión.................................................................................................................. 39
Práctica 6 – Comunicación inalámbrica entre microcontroladores: Bluetooth – serial
........................................................................................................................................ 40
Desarrollo ................................................................................................................... 40
Conclusión.................................................................................................................. 45
Práctica 7 – Teclado + LCD + WIFI ................................................................................ 46
Desarrollo ................................................................................................................... 46
Conclusión.................................................................................................................. 50

3
 Práctica 2 – E/S Digitales y Retardos
Marco teórico
Llamado implícito de funciones
Generalmente se refiere a la manera en el que las funciones se manejan de manera
automática, sin que el usuario tenga que declararlas explícitamente, simplificando
el programa y hacerlo más accesible.
Ejemplos:
1. Funciones “setup( )” y “loop( )”:
a. setup( ): función que se ejecuta una vez al principio para configurar las
cosas.
b. Loop( ): función que se repite una y otra vez.
Solo se necesita definir las funciones, el programa se encarga de llamarlas.

void setup() {
// Configura cosas aquí, se ejecuta una vez
}

void loop() {
// Código que se repite una y otra vez
}

2. Bibliotecas:
Solo se tiene que incluir al inicio del código y luego usar sus funciones
directamente.
#include <Wire.h>

void setup() {
Wire.begin(); // Inicia la comunicación I2C
}

void loop() {
Wire.requestFrom(8, 6); // Pide datos de un dispositivo
while (Wire.available()) {

4
 char c = Wire.read(); // Lee un dato
Serial.print(c); // Muestra el dato en la consola
}
}
3. Funciones básicas de Arduino
Hay funciones como “digitalRead()”, “digitalWrite()”, “pinMode()”, etc., que se
pueden usar sin necesidad de hacer configuraciones adicionales.

Apagar y prender un LED:

void setup() {
pinMode(LED_BUILTIN, OUTPUT); // Configura el pin del LED como salida
}

void loop() {
digitalWrite(LED_BUILTIN, HIGH); // Enciende el LED
delay(1000); // Espera un segundo
digitalWrite(LED_BUILTIN, LOW); // Apaga el LED
delay(1000); // Espera un segundo
}

Niveles lógicos: Alto, Bajo

Se refieren a los voltajes eléctricos que representan los estados binarios 1 y 0,
respectivamente. Estos niveles se utilizan en las operaciones de entrada y salidas
digitales.
- Nivel lógico alto (“HIGH”): es la tensión máxima que se usa para
representar un valor lógico 1, este valor es de 3.3 V.
- Nivel lógico bajo (“LOW”): es generalmente cercano a 0 V.

Configuración de pin de salida y alternar los niveles alto y bajo

void setup() {
pinMode(2, OUTPUT); // Configura el pin GPIO2 como salida
}

void loop() {

5
 digitalWrite(2, HIGH); // Establece el pin GPIO2 en nivel lógico alto (3.3V)
delay(1000); // Espera 1 segundo
digitalWrite(2, LOW); // Establece el pin GPIO2 en nivel lógico bajo (0V)
delay(1000); // Espera 1 segundo
}

Pull – down
Es la acción de disminuir la tensión de entrada o salida que tiene un circuito lógico
mientras está en reposo. Se utiliza para asegurar que la entrada digital se mantenga
en estado bajo (LOW) cuando no está conectado a ningún otro voltaje y evitar que
el pin flote, lo que puede resultar lecturas inestables.

Rebote mecánico de un push button

Los rebotes son las falsas pulsaciones (ruido) que se producen al hacer falsos
contactos con el interruptor, para manejar el rebote de botones en el ESP32 se
utilizan técnicas de debouncing que se pueden hacer tanto con el software como
con hardware.

Debouncing con software

En el código se utiliza un retraso breve después de detectar una transición de estado
del botón.

Debouncing con hardware

1. Conexión del botón: conectar la terminal del botón a una entrada digital del
ESP32 y otra terminal a tierra.

6
 2. Conexión del resistor: conectar el resistor (10 kΩ) entre el pin de entrada
digital y Vcc (3.3V). y conectar el otro pin del botón en tierra.

Retardos en un microcontrolador como mecanismo para corregir el rebote

mecánico
millis()
Es una alternativa de “delay()”, esta devuelve la cantidad de milisegundos
transcurridos desde que la placa comenzó a ejecutar el programa. Es importante
tener en cuenta que el valor de retorno es un unsigned long, que pueden ocurrir
errores lógicos si un programador intenta hacer operaciones aritméticas con tipos
de datos más pequeños, como los int.

Ejemplo:
unsigned long time;

void setup(){
Serial.begin(9600);
}
void loop(){
Serial.print("Time: ");
time = millis();

Serial.println(time); //prints time since program started

delay(1000); // wait a second so as not to send massive amounts of data
}

Algoritmo para la detección del flanco de subida de un push button

El flanco de subida consiste en el cambio de una señal nivel bajo a un nivel alto.

7
Programar un flanco de subida
Detectar el flanco de subida de un push button significa detectar el momento exacto
en que el botón pasa de un estado bajo (no presionado) a un estado alto
(presionado). Esto es útil para ejecutar una acción una sola vez por cada pulsación
del botón, en lugar de ejecutar acciones continuamente mientras el botón está
presionado.

Ejemplo
SeñalActual = medida del detector;
If (SeñalActual == HIGH && SeñalAntigua == LOW)
{
//EJECUTAR ACCIÓN CORRESPONDIENTE
}
SeñalAntigua = SeñalActual

Desarrollo
• Realizar estos programas con estructuras if – else y posteriormente sin
utilizar estructuras de control, únicamente llamado implícito de funciones:
o Realizar un programa que prenda/apague un led según el estado de
un push button Presionado/No-presionado.
o Realizar un programa en el Microcontrolador que prenda los Leds
pares si el Push Button Presionado. Y que apague los pares y prenda
los impares si el Push Button no está presionando.
• Realizar el siguiente programa utilizando los recursos del Microcontrolador
de manera eficiente:
o Realizar un programa que vaya prendiendo, uno por uno, cada Led de
manera secuencial cada que se presiona el Push Button (flanco de
subida). Mientras cada Led está prendido, el resto de los Leds se
encuentran apagados.

8
Código
Realizar un programa en el Microcontrolador que prenda los Leds pares si el Push
Button Presionado. Y que apague los pares y prenda los impares si el Push Button
no está presionando.
1. int led1 = 0;
2. int led2 = 4;
3. int led3 = 18;
4. int led4 = 19;
5. int estado; // almacenar el estado de la entrada
6.
7. void setup() {
8. pinMode(led1, OUTPUT);
9. pinMode(led2, OUTPUT);
10. pinMode(led3, OUTPUT);
11. pinMode(led4, OUTPUT);
12. pinMode(34, INPUT); // Entrada del push button
13. }
14.
15. void loop() {
16. estado = digitalRead(34); // Leer el estado del botón
17.
18. if(estado == HIGH)
19. {
20. digitalWrite(led1, LOW);
21. digitalWrite(led2, HIGH);
22. digitalWrite(led3, LOW);
23. digitalWrite(led4, HIGH);
24. }
25. else{
26. digitalWrite(led1, HIGH);
27. digitalWrite(led2, LOW);
28. digitalWrite(led3, HIGH);
29. digitalWrite(led4, LOW);
30. }

9
 31. }

LEDS pares LEDS impares

Realizar un programa que vaya prendiendo, uno por uno, cada Led de manera
secuencial cada que se presiona el Push Button (flanco de subida). Mientras cada
Led está prendido, el resto de los Leds se encuentran apagados.

1. int led1 = 0;
2. int led2 = 4;
3. int led3 = 18;
4. int led4 = 19;
5. int before = LOW;
6. int led = 0;
7. int now = LOW;
8.
9. void setup() {
10. pinMode(34, INPUT); // Entrada del push button
11. pinMode(led1, OUTPUT);
12. pinMode(led2, OUTPUT);
13. pinMode(led3, OUTPUT);
14. pinMode(led4, OUTPUT);

10
15. digitalWrite(led1, LOW);
16. digitalWrite(led2, LOW);
17. digitalWrite(led3, LOW);
18. digitalWrite(led4, LOW);
19.
20. Serial.begin(9600);
21. }
22.
23. void loop() {
24. now = digitalRead(34);
25.
26. if (now == HIGH && before == LOW) {
27. delay(50);
28. now = digitalRead(34);
29. if (now == HIGH) {
30. if (led == 0) {
31. digitalWrite(led1, HIGH);
32. } else if (led == 1) {
33. digitalWrite(led2, HIGH);
34. } else if (led == 2) {
35. digitalWrite(led3, HIGH);
36. } else if (led == 3) {
37. digitalWrite(led4, HIGH);
38. }
39. led++;
40. led = led % 4;
41. Serial.println(led);
42. }
43. }
44.
45. before = now;
46.
47. if(now==LOW)
48. {
49. digitalWrite(led1, LOW);

11
 50. digitalWrite(led2, LOW);
51. digitalWrite(led3, LOW);
52. digitalWrite(led4, LOW);
53. }
54. }

Notas adicionales
Programa 1
1. int boton;
2. void setup() {
3. // put your setup code here, to run once:
4. pinMode(5, INPUT);
5.
6. pinMode(18,OUTPUT);
7. pinMode(19,OUTPUT);
8. pinMode(21,OUTPUT);
9. pinMode(3,OUTPUT);
10. }
11.
12. void loop() {
13. // put your main code here, to run repeatedly:
14. boton = digitalRead(5);
15. digitalWrite(21, boton);
16. digitalWrite(18, boton);
17.
18. if(boton==LOW){

12
 19. digitalWrite(19, HIGH);
20. digitalWrite(3, HIGH);
21. }
22. else{
23. digitalWrite(19, LOW);
24. digitalWrite(3, LOW);
25. }
26. }

En este programa aprendí a cómo hacer las configuraciones de los pines del
microcontrolador de entradas y salidas, que van declarados en el setup porque solo
se repite una vez y en el loop que es un ciclo infinito se hacen las funciones
necesarias para que se ejecuten las instrucciones deseadas. En la línea 14, se lee
el estado (alto/bajo) de la entrada 5 (en este caso es el botón) y guarda el valor en
la variable botón, si este se presiona se encontrará en bajo. Con el uso de la
condición if se verifica si el botón está en bajo entonces que los pines 19 y 3 estén
en alto y si no que se pongan en bajo.

Conclusiones
En esta práctica se utilizaron las entradas y salidas digitales del microcontrolador.
Primero se configuraron los pines que se utilizarían para la entrada para el botón y
las salidas para los leds con las funciones pinMode(), digitalRead() y digitalWrite().
Además para que se pudiera identificar de manera controlada la salida se utilizó la
función delay().
Con la lectura del estado de los pines, ya sea en alto o en bajo dependiendo
lo que se solicitaba, una vez conociendo esto, a partir del uso de condiciones como
un “if” se fue construyendo el programa de una manera que sea fácil de entender.
Sin embargo, la complicación que se presentó en esta práctica fue el entendimiento
del módulo para que vaya prendiendo el led de uno por uno.

13
Referencias
Arduino. (2024) Constantes. Recuperado de:
https://www.arduino.cc/reference/es/language/variables/constants/constants
/
Fundamentos de programación en C++. (2020) Funciones en C++. Recuperado de:
https://www2.eii.uva.es/fund_inf/cpp/temas/8_funciones/funciones.html#:~:t
ext=en%20su%20prototipo.-
,LLamada%20a%20la%20funci%C3%B3n,o%20cualquier%20otra%20expre
si%C3%B3n%20v%C3%A1lida.
Programafacil. (2020) Resistencia pull up y pull down. Recuperado de:
https://programarfacil.com/blog/arduino-blog/resistencia-pull-up-y-pull-down/

Práctica 3 – Temporizador/contador
Marco teórico
Pull – up
Cuando el circuito está en reposo, es decir, cuando el botón está sin pulsar, la caída
de tensión es de 3.3 V (HIGH), en cambio, cuando se pulsa el botón se deriva toda
la corriente a masa y caída de tensión a 0 V (LOW). Normalmente las resistencias
que se utilizan en estos casos son de 10 K.

14
Temporizadores/contadores en microcontrolador
Los temporizadores y contadores son componentes que permiten medir el tiempo,
general pulsos y controlar eventos.
Desarrollo
• Realizar un programa que vaya prendiendo los Leds de manera secuencial,
uno por uno. Mientras el Led en turno está prendido, el resto se encuentran
apagados. Al presionar el Push Button y mantenerlo presionado la velocidad
de la secuencia es mayor, al soltar el Push Button la velocidad regresa a la
normalidad.
• Utilizar otro Push Button conectado en Pull-UP y otro Led el cual prenderá
mientras el Push Button esté presionado. Este mecanismo deberá funcionar
de manera simultánea con el programa anterior sin que ninguno de los dos
procesos se encuentre afectado.
Código
27. unsigned long now;
28. unsigned long ult = 0;
29. unsigned long ult_2 = 0;
30. byte contador = 0;
31. byte LED[4] = {12, 14, 27, 26};
32. byte LED5 = 25;
33. byte PB_1 = 34;
34. byte PB_2 = 39;
35. int tiempo = 999;
36. int tiempo_2 = 199;
37. bool estadoL5 = LOW;
38.
39. enum {
40. LED1,
41. LED2,
42. LED3,
43. LED4,
44. TOTAL_LEDS,
45. };

15
46.
47. void setup() {
48. for(int i=LED1; i<TOTAL_LEDS; i++)
49. {
50. pinMode(LED[i],OUTPUT);
51. }
52. pinMode(LED5, OUTPUT);
53. pinMode(PB_1, INPUT);
54. pinMode(PB_2, INPUT);
55. }
56.
57. void loop() {
58. //PRENDER LEDS
59. now = millis(); //tiempo que ha pasado
60.
61. if(digitalRead(PB_1))
62. tiempo = 199;
63. else
64. tiempo = 999;
65. if(now - ult > tiempo) //Ha pasado 1 segundo?
66. {
67. digitalWrite(LED[(contador+3)%4],LOW);
68. digitalWrite(LED[contador%TOTAL_LEDS],HIGH);
69. contador++;
70. ult = now;
71. }
72.
73. if(!digitalRead(PB_2))
74. tiempo_2 = 99;
75. else
76. tiempo_2 = 199;
77. if(now - ult_2 > tiempo_2)
78. {
79. estadoL5 = !estadoL5;
80. digitalWrite(LED5, estadoL5);

16
 81. ult_2 = now;
82. }
83. }

Led blanco conectado a otro push button en pull – up

Notas adicionales
Programa 1. Contador
1. //Programa que registre el tiempo que ha pasado en el microcontrolador
2.
3. unsigned long now;
4. unsigned long last = 0;
5.
6. void setup() {
7. Serial.begin(115200);
8. }
9.
10. void loop() {
11. now = millis(); //tiempo que ha pasado
12.

17
 13. //Ha pasado un segundo?
14. if(now-last > 999)
15. {
16. Serial.println(now);
17. last = now;
18. }
19. }

En este programa se busca imprimir por medio del puerto serie el tiempo que ha
pasado en milisegundos, representando solo el segundo. Aquí aprendí que al igual
a 0 una variable es para que almacene el último evento registrado. Con el
Serial.begin() empieza la comunicación serie a una velocidad que se establezca.
Después, now=millis() es para devolver los milisegundos desde que se empieza a
ejecutar el programa, es por eso que en la condición si ha pasado menos de un
segundo se utiliza 999 para no utilizar >= y sea más preciso. Finalmente, si se
cumple se muestra el tiempo que pasó y la variable last se actualiza.

Conclusión
En esta práctica por medio de los leds con temporizador controlados por botones
se hace un código que combine dos entradas digitales y retardos para el
funcionamiento de 4 leds en conjunto y uno solo. Se implementó la función millis()
con el fin de medir el tiempo que pasa y controlar cada uno de las salidas.
Con el uso de variables como “ult” y “ult_2” se manejan las dos tareas
diferentes, esto lo hace más preciso para que no haya conflictos, así como el uso
de “tiempo” y “tiempo_2” que modula esta velocidad de parpadeo. Además, se hace
uno de la negación para invertir el valor leído del botón 2.

Referencias
Programafacil. (2020) Resistencia pull up y pull down. Recuperado de:
https://programarfacil.com/blog/arduino-blog/resistencia-pull-up-y-pull-down/

18
Llamas, L. (2023) Cómo usar los timers del ESP32. Recuperado de:
https://www.luisllamas.es/esp32-timers/

Práctica 4 – juego de reflejos

Marco teórico
Alta impedancia
El estado de alta impedancia se utiliza cuando se desea inhibir determinadas salidas
digitales, por ejemplo, en buses de comunicación. Una entrada digital no conectada,
o en alta impedancia, recogerá todo el ruido eléctrico ambiental, lo que dará lugar a
errores debidos a que este ruido será interpretado como bruscas modificaciones de
estados lógicos.
Las entradas del Arduino son de alta impedancia lo que significa que la
corriente que circulará por esa línea sea mínima en el orden de los microamperios,
por lo que el voltaje que “cae” en la resistencia pull – up es mínimo y tenemos casi
el mismo voltaje de fuente en la entrada del Arduino.

Temporizadores
Un timer es un contador que puede medir el tiempo transcurrido en unidades de
reloj del sistema. Permiten ejecutar funciones o interrupciones en momentos
específicos o después de cierto tiempo transcurrido. Estos dispositivos permiten
medir intervalos de tiempo y ejecutar tareas en momentos precisos, lo que resulta
útil en aplicaciones que requieren sincronización, control de eventos o ejecución de
tareas periódicas.
ESP32 ofrece varios timers internos, que pueden ser utilizados para
diversas aplicaciones. Para el entorno de Arduino, se siguen pasos generales.
Primero se debe inicializar el timer deseado, con la función timerBegin() que toma
como argumentos el número del timer (0,1, 2, etc) el dividor del reloj y si el timer se
reinicia después de alcanzar el valor de comparación.
Se adjunta la función de manejo de interrupción al timer usando
timerAttachInterrupt(). Estableciendo cuál función será ejecutada cuando el timer
alcance el valor de comparación. Con timerAlarmWrite()se establece el valor al que

19
el timer debe contar antes de generar una interrupción o ejecutar una acción. Por
último, se habilita el timer usando timerAlarmEnable().

Técnica de CharliePlexing para controlar 6 leds con tres pines

Esta es una técnica que permite controlar muchos más LEDs que pines. La cantidad
exacta que se pueden controlar con una cantidad determinada de pines está dada
por n^2-n donde n es la cantidad de pines utilizados (es decir, 3^2 -3 = 9 – 3 = 6
LEDs usando solo n = 3 pines).

CharliePlexing no solo aprovecha los dos estados que normalmente se utilizan,

ALTO y Bajo, sino que también usa un tercer estado al cambiar entre los modos
SALIDA y ENTRADA, lo que afecta a las resistencias internas del Arduino.

Numero aleatorio dentro del microcontrolador

El ESP32 cuenta con un módulo de hardware de generación de números aleatorios
(RNG Random Number Generator) que permite generar números aleatorios de alta
calidad. Para utilizar el módulo RNG del ESP32 en código se puede generar un
número aleatorio con la función esp_random(), que devuelve un entero de 32 bits
(entre 9 y 4294967295).

20
Desarrollo
• Realizar una función que retorne el estado del Push Button y utilizarla en el
resto de las actividades.
• Realizar la conexión de CharliePlexing para conectar 6 Leds en 3 salidas del
Microcontrolador.
• Realizar la programación para el método CharliePlexing: hacer una función
que reciba el número de Led que se desea prender y que prenda el Led
correspondiente (Utilizar enum con constantes para los números de LED y
switch-case para filtrar el número de Led a cada caso). Y utilizarla en las
actividades siguientes.
• Realizar una función que genere una secuencia continua en los Leds.
• Realizar una función que genere una secuencia aleatoria en los Leds.
• Realizar una función que prenda y apague la mitad de los Leds de manera
alternada
Código
1. byte salidas[] = {12,14,27};
2. byte estadoActual=0;
3. int ctr=0;
4. int r;
5. unsigned long _millis = 0;
6. unsigned int cuentaRegresiva = 0;
7. unsigned int cuentaProgresiva = 0;
8. unsigned int ctrLeds = 0;
9. unsigned int ctrSecGana = 0;
10. unsigned int ctrSecPierde = 0;
11. bool banderaWin = HIGH;
12. bool prendidos = HIGH;
13. bool mitad = HIGH;
14. unsigned long reinicio = 0;
15. const unsigned long resetTime = 500;
16.
17. enum{
18. SAL1,

21
19. SAL2,
20. SAL3,
21. TOTAL_SALIDAS,
22. };
23.
24. enum{
25. LED1,
26. LED2,
27. LED3,
28. LED4,
29. LED5,
30. LED6,
31. TOTAL_LEDS,
32. };
33.
34. enum{
35. INICIO,
36. ESPERANDO,
37. INICIA_CUENTA,
38. TERMINA_CUENTA,
39. TERMINA_JUEGO,
40. GANASTE,
41. PERDISTE,
42. };
43.
44. void setup() {
45. pinMode(35,INPUT);
46. }
47.
48. void loop() {
49. if (digitalRead(35) == HIGH) {
50. if (reinicio == 0) {
51. reinicio = millis();
52.
53. }

22
54. else if (millis() - reinicio > resetTime) {
55. resetGame();
56. }
57. }
58. else {
59. reinicio = 0;
60. }
61.
62. switch(estadoActual)
63. {
64. case INICIO:
65. cuentaRegresiva = esp_random()%5000+2000;// 1999 a 6999
66. estadoActual++;
67. break;
68.
69. case ESPERANDO:
70. secuenciaContinua();
71. if(digitalRead(35))
72. estadoActual++;
73. break;
74.
75. case INICIA_CUENTA:
76. secuenciaAleatoria();
77. cuentaRegresiva--;
78. if(cuentaRegresiva==0)
79. {
80. apagarLeds();
81. estadoActual++;
82. }
83. break;
84.
85. case TERMINA_CUENTA:
86. cuentaProgresiva++;
87. if(digitalRead(35))
88. estadoActual++;

23
89. break;
90.
91. case TERMINA_JUEGO:
92. if(cuentaProgresiva > 400)
93. {
94. estadoActual = PERDISTE;
95. }
96. else
97. {
98. estadoActual = GANASTE;
99. }
100. break;
101.
102. case GANASTE:
103. secuenciaGana();
104. break;
105.
106. case PERDISTE:
107. secuenciaPierde();
108. break;
109. }
110.
111. delay(1);
112. _millis++;
113. }
114.
115. void secuenciaGana()
116. {
117. if(_millis%250 == 0)
118. {
119. prendidos = !prendidos;
120. }
121. if(prendidos)
122. {
123. prenderLed(ctrSecGana%TOTAL_LEDS);

24
124. ctrSecGana++;
125. }
126. else
127. {
128. apagarLeds();
129. }
130. }
131.
132. void secuenciaPierde()
133. {
134. if(_millis%350 == 0)
135. {
136. mitad = !mitad;
137. }
138. if(mitad)
139. {
140. prenderLed(ctrSecPierde%(TOTAL_LEDS/2));
141. ctrSecPierde++;
142. }
143. else
144. {
145. prenderLed((ctrSecPierde%(TOTAL_LEDS/2))+3);
146. ctrSecPierde++;
147. }
148. }
149.
150. void secuenciaAleatoria()
151. {
152. if(_millis%100==0)
153. {
154. prenderLed(esp_random()%TOTAL_LEDS);
155. }
156. }
157.
158. void apagarLeds()

25
159. {
160. for(byte i=SAL1; i<TOTAL_SALIDAS; i++)
161. pinMode(salidas[i],INPUT);
162. }
163.
164. void secuenciaContinua()
165. {
166. if(_millis%1000==0)
167. {
168. prenderLed(ctrLeds%TOTAL_LEDS);
169. ctrLeds++;
170. }
171. }
172.
173. void prenderLed(byte led){
174. switch(led)
175. {
176. case LED1:
177. pinMode(salidas[SAL1], OUTPUT);
178. digitalWrite(salidas[SAL1], LOW);
179. pinMode(salidas[SAL2], OUTPUT);
180. digitalWrite(salidas[SAL2], HIGH);
181. pinMode(salidas[SAL3], INPUT);
182. break;
183.
184. case LED2:
185. pinMode(salidas[SAL1], OUTPUT);
186. digitalWrite(salidas[SAL1], HIGH);
187. pinMode(salidas[SAL2], OUTPUT);
188. digitalWrite(salidas[SAL2], LOW);
189. pinMode(salidas[SAL3], INPUT);
190. break;
191.
192. case LED3:
193. pinMode(salidas[SAL1], INPUT);

26
194. pinMode(salidas[SAL2], OUTPUT);
195. digitalWrite(salidas[SAL2], LOW);
196. pinMode(salidas[SAL3], OUTPUT);
197. digitalWrite(salidas[SAL3], HIGH);
198. break;
199.
200. case LED4:
201. pinMode(salidas[SAL1], INPUT);
202. pinMode(salidas[SAL2], OUTPUT);
203. digitalWrite(salidas[SAL2], HIGH);
204. pinMode(salidas[SAL3], OUTPUT);
205. digitalWrite(salidas[SAL3], LOW);
206. break;
207.
208. case LED5:
209. pinMode(salidas[SAL1], OUTPUT);
210. digitalWrite(salidas[SAL1], LOW);
211. pinMode(salidas[SAL2], INPUT);
212. pinMode(salidas[SAL3], OUTPUT);
213. digitalWrite(salidas[SAL3], HIGH);
214. break;
215.
216. case LED6:
217. pinMode(salidas[SAL1], OUTPUT);
218. digitalWrite(salidas[SAL1], HIGH);
219. pinMode(salidas[SAL2], INPUT);
220. pinMode(salidas[SAL3], OUTPUT);
221. digitalWrite(salidas[SAL3], LOW);
222. break;
223. }
224. }
225.
226. void resetGame() {
227. estadoActual = INICIO;
228. cuentaRegresiva = 0;

27
 229. cuentaProgresiva = 0;
230. ctrLeds = 0;
231. ctrSecGana = 0;
232. ctrSecPierde = 0;
233. prendidos = HIGH;
234. mitad = HIGH;
235. apagarLeds();
236. }

Juego perdido Juego ganado Reinicio del juego

Conclusión
En esta práctica se realizó un juego con leds basado en estados como “inicio”,
“esperando”, “inicia_cuenta”, “termina_cuenta”, “termina_cuenta”, “termina_juego”,
“ganaste” y “perdiste”. Una vez que se ejecuta el juego si se deja presionado el
botón cierto tiempo se reinicia con “resetGame”. Esta función se encarga de
restablecer todas las variables y estados a los valores iniciales para poder empezar
de nuevo el juego.

Referencias
DitecnoMarkers. (s,f) Resistencias pull – up. Recuperado de:
https://ditecnomakers.com/resistencias-pull-up-y-pull-
down/#:~:text=El%20estado%20de%20alta%20impedancia,a%20un%20est
ado%20l%C3%B3gico%20alto%20.

28
Ptkrf. (2024) Charlieplexing Made Easy (and What It Even Means?!). Recuperado
de: https://www.instructables.com/Charlieplexing-Made-Easy-and-What-It-
Even-Means/

Práctica 5 – Convertidores ADC y Comunicación Serial

Marco teórico
Conversión Analógica – Digital
Consiste en la transcripción de señales analógicas en señal digital, con el propósito
de facilitar su procesamiento (codificación, comprensión, etc) y hacer la señal
resultante (digital) más inmune al ruido y otras interferencias a las que son más
sensibles las señales analógicas.
Para realizar esa tarea, el conversor ADC (Analog – to – Digital Converter –
Conversor – Analógico Digital) tiene que efectuar los procesos de muestreo de la
señal analógica, cuantización de la señal propia y la codificación del resultado de la
cuantización, en código binario.

Señal analógica
El conjunto de señales que percibimos es analógica, ya sea la luz, el sonido, la
energía, etc., son señales que tienen variación continua.

Señal digital
Se trata de la señal cuyos signos representan ciertos valores discretos que
contienen información decodificada. Los sistemas de señales digitales emplean la
lógica binaria de dos estados, los cuales son reemplazados por unos y ceros, que
indican el estado alto o bajo del nivel de tensión eléctrica. Pierde poca calidad y
pueden procesarse de manera sencilla y poco susceptibles al ruido ambiental.

29
Resolución de Amplitud de un Convertidor ADC
Un dispositivo establece una relación entre su entrada (señal analógica) y su salida
(digital) dependiendo de su resolución. La resolución determina la precisión con la
que se reproduce la señal original. Se puede saber, siempre y cuando conozcamos
el valor de la entrada a convertir y la cantidad máxima de la salida en dígitos
binarios.
Para calcular la resolución de un convertidor analógico digital (ADC) de n –
bit, se divide 1 entre 2 elevado a n.
1
𝑟𝑒𝑠𝑜𝑙𝑢𝑐𝑖ó𝑛 =
2𝑛
Por ejemplo, un convertidor analógico digital (ADC) de 16 bits tiene una resolución
de:
1 1
𝑟𝑒𝑠𝑜𝑙𝑢𝑐𝑖ó𝑛 = 16
= = 0.0000152
2 65536
Si el rango de entrada es de 5V,
5𝑉 5
16
= = 0.07629𝑚𝑉
2 65536
Lo que significa que se pueden medir variaciones de 0.07629mV en la señal
analógica de entrada.

Módulos ADC del Microcontrolador

Todos los modelos de ESP32 tienen disponibles dos ADC de 12 bits, denominados
ADC1 y ADC2. Con una resolución de 12 bits, una resolución de 3.3 volts / 4096
unidades, es equivalente a 0.8 mV por paso.
La cantidad de pines dependerá del modelo de ES32. Por ejemplo, este tiene
18 pines, organizados en ADC1 conectado a 8 GPIOs (32-39) y el ADC2 conectado
a 10 GPIOs (0,2,4,12-15 y 25-27). Para el entorno de programación se tiene que

30
usar la función analogRead(GPIO). Que acepta como único argumento el único pin
al que está conectado el sensor.

Comunicación Serial del Microcontrolador

Es un protocolo de comunicación que permite la trasmisión y recepción de datos de
forma asíncrona entre dispositivo. Este tipo de comunicación envía datos bit a bit,
un bit a la vez, secuencialmente a través de un canal de comunicación. En
programación se emplea el Serial.println() que manda caracteres por el puerto serial
en Arduino.

Desarrollo
Parte 1. Introduciendo una señal analógica al microcontrolador:
• Identificar los puertos de conversión ADC (Entradas Analógicas) del
Microcontrolador.
• Realizar un divisor de voltaje con ayuda de un Potenciómetro (valor indistinto)
y la fuente de voltaje del Microcontrolador (3.3 V). De tal manera que al girar
el potenciómetro se tenga una señal de voltaje variable de 0 V a 3.3 V.
• Introducir la señal de voltaje en una de las entradas ADC del
Microcontrolador.

Parte 2. Enviando la señal analógica convertida a través del puerto serial:

• Configurar el puerto serial del Microcontrolador a 115200 Baudios.
• Leer de manera continua la Entrada ADC del microcontrolador (de la Parte
1).
• Enviar cada muestra leída a través del Puerto Serial del Microcontrolador
hacia la computadora. uC
• En la Computadora, abrir un Monitor Serial, configurarlo a 115200 Baudios y
observar las muestras de la señal recibida.
• Contestar las siguientes preguntas: ¿Qué significan los valores enteros que
se observan? ¿Cuál es el rango de valores (Mínimo-Máximo) que se
observa? ¿A qué se debe ese rango de valores?

31
Parte 3. Indicadores de nivel con Leds:
• En el código del Microcontrolador realizar una función que reciba el valor de
cada muestra leída y que encienda Leds (6 Leds utilizando 3 Salidas) de
acuerdo al nivel de la señal, distribuidos equiespaciadamente.

Parte 4. Leer una segunda señal analógica:

• De manera simultánea, generar e introducir una segunda señal analógica e
introducirla al Microcontrolador por otro puerto ADC.
• Realizar una función que reciba cada muestra leída de la segunda señal
analógica y que encienda un Led si la señal sobrepasa un umbral
determinado (ustedes determinan el valor del umbral).

Parte 5. Graficar ambas señales:

• Enviar ambas señales del Microcontrolador a la Computadora (Comunicación
Serial) y graficarlas simultáneamente en el Monitor Serial.

Parte 6. Dos modos de funcionamiento:

• Realizar las adecuaciones necesarias para que el Microcontrolador tenga
dos modos de funcionamiento. Los modos de funcionamiento serán
seleccionados presionando un Push Button conectado al microcontrolador.
• El Primer modo de funcionamiento corresponde a todas las Partes anteriores
manejando la señal en el rango de 0 a 4095.
• El Primer modo de funcionamiento corresponde a todas las Partes anteriores
manejando la señal en el rango de 0 a 3.3v.

Código
1. bool boton, botonAnt, bloque;
2. byte salidas[] = {12,14,27};
3. byte estadoActual=0;
4. u_int ctr=0; // Contador para los leds
5. u_long _millis = 0; // milisegundos
6. float val,poten; //pines analogicos

32
7. int pt, pt2; //0-4095
8. byte intensidad = 0;
9. byte intensidadUmb = 0;
10.
11. enum{
12. SAL1,
13. SAL2,
14. SAL3,
15. TOTAL_SALIDAS,
16. };
17.
18. //comportamiento de led en funcion de val
19. enum{
20. intensidad1,
21. intensidad2,
22. intensidad3,
23. };
24.
25. enum{
26. LED1,
27. LED2,
28. LED3,
29. LED4,
30. LED5,
31. LED6,
32. TOTAL_LEDS,
33. };
34.
35. // in1 = 0, in2 = 0
36. enum{
37. in1,
38. in2,
39. };
40.
41. void setup() {

33
42. Serial.begin(115200); //comunicacion serial
43. pinMode(34,INPUT);
44. }
45.
46. void loop() {
47. boton = digitalRead(34);
48. val = analogRead(15);
49. pt = analogRead(15);
50. val = (val/4095)*3.3; //conversión del valor leido a voltaje
51.
52. nivelLeds(val); //llamar a la funcion para ajustar los leds
53.
54. pt2 = analogRead(35);
55. poten = analogRead(35); //valores analogicos
56. poten=(poten/4095)*3.3;
57.
58. switch(bloque) //control de estado in1, in2 controlado por boton
59. {
60. case in1:
61. if(_millis%1000==0)
62. hp(pt,pt2);
63.
64. if(boton == HIGH && botonAnt == LOW)
65. bloque = in2;
66. break;
67.
68. case in2:
69. if(_millis%1000==0)
70. func(val,poten);
71.
72. if(boton == HIGH && botonAnt == LOW)
73. bloque = in1;
74. break;
75. }
76.

34
77. botonAnt = boton;
78.
79. potenLed(poten); //ajusta la intensidad del LED segun poten
80.
81. delay(1);
82. _millis++; //incremento de contador
83.
84. }
85.
86. void hp(int pt, int pt2)//0-4095
87. {
88. Serial.print(pt);
89. Serial.print(",");
90. Serial.println(pt2);
91. }
92.
93. void func(float val, float poten)//0-3.3
94. {
95. Serial.print(val);
96. Serial.print(",");
97. Serial.println(poten);
98. }
99.
100. void potenLed(float poten)
101. {
102.
103. if(poten < 1.6)
104. intensidadUmb = 0;//si poten es menor que 1.6, intensidad = 0
105. if(poten >= 1.6)
106. intensidadUmb = 1;
107. switch(intensidadUmb) //dependiendo del estado actual de
intensidad
108. {
109. case intensidad1:
110. pinMode(4,OUTPUT);

35
111. digitalWrite(4,LOW);
112. break;
113.
114. case intensidad2:
115. pinMode(4,OUTPUT);
116. digitalWrite(4,HIGH);
117. break;
118. }
119. }
120.
121. void nivelLeds(float val)
122. {
123. //intensidad basada en val_f
124. if(val >=1 && val<=1.1)
125. intensidad=0;
126. else if(val>1.1 && val<=2.2)
127. intensidad=1;
128. else if(val>2.2 && val<=3.3)
129. intensidad=2;
130. switch(intensidad) //controlar activacion de los leds
131. {
132. case intensidad1:
133. if(_millis%1 == 0)
134. {
135. prenderLed(ctr%(2));/*contador empiza en 0*/
136. ctr++;
137. }
138. break;
139. case intensidad2:
140. if(_millis%1 == 0)
141. {
142. prenderLed(ctr%4);
143. ctr++;
144. }
145. break;

36
146. case intensidad3:
147. if(_millis%1 == 0)
148. {
149. prenderLed(ctr%TOTAL_LEDS);
150. ctr++;
151. }
152. break;
153. }
154. }
155.
156. void apagarLeds()
157. {
158. //Configurar pines de los leds como entradas, apagandolos
159. for(byte i=SAL1; i<TOTAL_SALIDAS; i++)
160. pinMode(salidas[i],INPUT);
161. }
162.
163. void prenderLed(byte led){
164. switch(led)
165. {
166. case LED1:
167. pinMode(salidas[SAL1], OUTPUT);
168. digitalWrite(salidas[SAL1], LOW);
169. pinMode(salidas[SAL2], OUTPUT);
170. digitalWrite(salidas[SAL2], HIGH);
171. pinMode(salidas[SAL3], INPUT);
172. break;
173.
174. case LED2:
175. pinMode(salidas[SAL1], OUTPUT);
176. digitalWrite(salidas[SAL1], HIGH);
177. pinMode(salidas[SAL2], OUTPUT);
178. digitalWrite(salidas[SAL2], LOW);
179. pinMode(salidas[SAL3], INPUT);
180. break;

37
181.
182. case LED3:
183. pinMode(salidas[SAL1], INPUT);
184. pinMode(salidas[SAL2], OUTPUT);
185. digitalWrite(salidas[SAL2], LOW);
186. pinMode(salidas[SAL3], OUTPUT);
187. digitalWrite(salidas[SAL3], HIGH);
188. break;
189.
190. case LED4:
191. pinMode(salidas[SAL1], INPUT);
192. pinMode(salidas[SAL2], OUTPUT);
193. digitalWrite(salidas[SAL2], HIGH);
194. pinMode(salidas[SAL3], OUTPUT);
195. digitalWrite(salidas[SAL3], LOW);
196. break;
197.
198. case LED5:
199. pinMode(salidas[SAL1], OUTPUT);
200. digitalWrite(salidas[SAL1], LOW);
201. pinMode(salidas[SAL2], INPUT);
202. pinMode(salidas[SAL3], OUTPUT);
203. digitalWrite(salidas[SAL3], HIGH);
204. break;
205.
206. case LED6:
207. pinMode(salidas[SAL1], OUTPUT);
208. digitalWrite(salidas[SAL1], HIGH);
209. pinMode(salidas[SAL2], INPUT);
210. pinMode(salidas[SAL3], OUTPUT);
211. digitalWrite(salidas[SAL3], LOW);
212. break;
213. }
214. }

38
 Potenciómetros en rango Potenciómetros en rango Potenciómetro en rango de
de (3.3/4095) de 0 1.1 y 2.2

Monitor serial

Conclusión
En esta práctica se solicitó controlar la intensidad y el orden de encendido de los
LEDs en función de valores analógicos leídos desde el potenciómetro y un botón.
Para que se pudieran observar cómo prendían los leds de dos en dos fue necesario
agregar dentro de una función el umbral necesario de los potenciómetros. Aquí lo
que más se complicó fue hacer la conversión de los valores una vez que se
presionara el botón.

39
 Práctica 6 – Comunicación inalámbrica entre
microcontroladores: Bluetooth – serial
Desarrollo
Parte 1:
• Analizar los códigos
o 1. Archivo-Ejemplos-BluetoothSerial-SerialToSerialBlouetooth
o 2. Archivo-Ejemplos-BluetoothSerial-SerialToSerialBlouetoothM
• Acordar con un compañero del salón quién correrá cuál código en su
Microcontrolador-1. Elegir uno cada uno, de los dos códigos anteriores.
• Elegir un nombre adecuado para el dispositivo que correrá el programa
SerialToSerialBlouetooth.
• Colocar el nombre que se eligió en el código del otro dispositivo,
Microcontrolador-2, SerialToSerialBlouetoothM, para que pueda encontrarlo
para conectarse.
• Iniciar el Microcontrolador del Código 1 y abrir el monitor serial.
• Iniciar el Microcontrolador del Código 2 y abrir el monitor serial.
• Enviarse datos de un Microcontrolador a otro.
Parte 2:
• Enviar una señal “analógica” del Microcontrolador-1 al Microcontrolador-2.
uC uC
• En el Microconctrolador-2 colocar 6 indicadores (Leds) del nivel de la señal.
o Utilizar 3 salidas para 6 Leds (Puntos extra).
o Utilizar 6 salidas para 6 Leds (Calificación regular).
Parte 3:
• Mantener el esquema de la Parte 2.
• • Agregar el envió de una señal “analógica” del Microcontrolador-2 al
Microcontrolador-1.
• • En el Microconctrolador-1 agregar los 6 indicadores (Leds) del nivel de la
señal.
o o Utilizar 3 salidas para 6 Leds (Puntos extra).

40
 o o Utilizar 6 salidas para 6 Leds (Calificación regular).

Código
1. #include "BluetoothSerial.h"
2.
3. // Verificar si Bluetooth está disponible
4. #if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
5. #error Bluetooth no está habilitado! Por favor ejecuta make menuconfig
para habilitarlo
6. #endif
7.
8. // Verificar perfil Serial Port Profile
9. #if !defined(CONFIG_BT_SPP_ENABLED)
10. #error Perfil Serial Port Profile para Bluetooth no está disponible o
no está habilitado. Solo está disponible para el chip ESP32.
11. #endif
12.
13. byte potenciometro = 0;
14. unsigned long _millis = 0;
15. BluetoothSerial SerialBT;
16. byte salidas[3] = {4,2,15};
17. enum{SAL1, SAL2, SAL3, TOTAL_SALIDAS};
18. enum{LED1,LED2,LED3,LED4,LED5,LED6,TOTAL_LEDS,};
19. byte numLed;
20.
21. String slaveName = "Aneth"; // Nombre del dispositivo esclavo BT
22. String MACadd = "E8:6B:EA:C4:2D:2A"; // Dirección MAC del dispositivo
esclavo BT
23. uint8_t address[6] = {0xE8, 0x6B, 0xEA, 0xC4, 0x2D, 0x2A}; //
Dirección MAC en formato uint8_t
24.
25. String myName = "bren";
26. String datostring;
27. int datoint;

41
28.
29. void setup() {
30. bool connected;
31. Serial.begin(115200);
32. pinMode(potenciometro, INPUT);
33. SerialBT.begin(myName, true);
34. // SerialBT.deleteAllBondedDevices(); // Descomentar para eliminar
dispositivos emparejados; debe llamarse después de begin
35. Serial.printf("El dispositivo \"%s\" comenzó en modo maestro,
asegúrate de que el dispositivo esclavo BT esté encendido!\n",
myName.c_str());
36.
37. // Intentar conectar usando el nombre del dispositivo
38. Serial.printf("Conectando al dispositivo esclavo BT con el nombre
\"%s\"\n", slaveName.c_str());
39. //connected = SerialBT.connect(slaveName);
40.
41. // Si no se puede conectar usando el nombre, intentar con la
dirección MAC
42. if (!connected) {
43. Serial.println("Error al conectar usando el nombre. Intentando con
la dirección MAC.");
44. Serial.print("Conectando al dispositivo esclavo BT con MAC ");
45. Serial.println(MACadd);
46. connected = SerialBT.connect(address);
47. }
48.
49. if (connected) {
50. Serial.println("¡Conectado exitosamente!");
51. } else {
52. while (!SerialBT.connected(10000)) {
53. Serial.println("Error al conectar. Asegúrate de que el
dispositivo remoto esté disponible y dentro del alcance, luego
reinicia la aplicación.");
54. }

42
55. }
56.
57. // Desconectar y volver a conectar
58. if (SerialBT.disconnect()) {
59. Serial.println("¡Desconectado exitosamente!");
60. }
61.
62. SerialBT.connect();
63. if (connected) {
64. Serial.println("¡Reconectado exitosamente!");
65. } else {
66. while (!SerialBT.connected(10000)) {
67. Serial.println("Error al reconectar. Asegúrate de que el
dispositivo remoto esté disponible y dentro del alcance, luego
reinicia la aplicación.");
68. }
69. }
70. }
71.
72. void loop() {
73. if (Serial.available()) {
74. SerialBT.write(Serial.read());
75. }
76. if((_millis % (6*70)) == 0)
77. SerialBT.println(analogRead(potenciometro));
78.
79. if (SerialBT.available()) {
80. datostring = SerialBT.readStringUntil('\n');
81. datoint = datostring.toInt();
82. Serial.println(datoint);
83. }
84. nivelADC(datoint);
85.
86. delay(1);
87. _millis++;

43
88. }
89.
90. void nivelADC(int ADC){
91. numLed = floor(ADC/(pow(2,12)/6));
92. for(int i = numLed; i>=0; i--){
93. prenderLed(i);
94. delay(1);
95. _millis++;
96. }
97.
98. }
99.
100. void prenderLed(byte led){
101. switch(led)
102. {
103. case LED1:
104. pinMode(salidas[SAL1], OUTPUT);
105. digitalWrite(salidas[SAL1], LOW);
106. pinMode(salidas[SAL2], OUTPUT);
107. digitalWrite(salidas[SAL2], HIGH);
108. pinMode(salidas[SAL3], INPUT);
109. break;
110.
111. case LED2:
112. pinMode(salidas[SAL1], OUTPUT);
113. digitalWrite(salidas[SAL1], HIGH);
114. pinMode(salidas[SAL2], OUTPUT);
115. digitalWrite(salidas[SAL2], LOW);
116. pinMode(salidas[SAL3], INPUT);
117. break;
118.
119. case LED3:
120. pinMode(salidas[SAL1], INPUT);
121. pinMode(salidas[SAL2], OUTPUT);
122. digitalWrite(salidas[SAL2], LOW);

44
 123. pinMode(salidas[SAL3], OUTPUT);
124. digitalWrite(salidas[SAL3], HIGH);
125. break;
126.
127. case LED4:
128. pinMode(salidas[SAL1], INPUT);
129. pinMode(salidas[SAL2], OUTPUT);
130. digitalWrite(salidas[SAL2], HIGH);
131. pinMode(salidas[SAL3], OUTPUT);
132. digitalWrite(salidas[SAL3], LOW);
133. break;
134.
135. case LED5:
136. pinMode(salidas[SAL1], OUTPUT);
137. digitalWrite(salidas[SAL1], LOW);
138. pinMode(salidas[SAL2], INPUT);
139. pinMode(salidas[SAL3], OUTPUT);
140. digitalWrite(salidas[SAL3], HIGH);
141. break;
142.
143. case LED6:
144. pinMode(salidas[SAL1], OUTPUT);
145. digitalWrite(salidas[SAL1], HIGH);
146. pinMode(salidas[SAL2], INPUT);
147. pinMode(salidas[SAL3], OUTPUT);
148. digitalWrite(salidas[SAL3], LOW);
149. break;
150. }
151. }

Conclusión
Para este proyecto se intenta hacer por medio de una comunicación serial bluetooth
y controlar dispositivos externos como lo es las 3 salidas para controlar 6 leds. Es
importante que el dispositivo esclavo se conecte con el dispositivo maestro por

45
medio del nombre y dirección MAC. Es importante mencionar que dentro de esta
práctica hubo complicaciones como la falta de funcionalidad de alguna parte de los
códigos en el momento de tomar el control. Sin embargo, es de utilidad para poder
mandar información necesaria a otro dispositivo cuando este adquiere datos.

Práctica 7 – Teclado + LCD + WIFI

Desarrollo
Código
1. #include <Keypad.h>
2. #include <Wire.h>
3. #include <LiquidCrystal_I2C.h>
4. #include <WiFi.h>
5. #include <SocketIoClient.h>
6.
7. /******************/
8. const char* ssid = "INFINITUM0B51_TL";
9. const char* password = "9q3dJWfHEm";
10. const char* server = "192.168.1.71"; //Enter server adress
11. const uint16_t port = 5001; // Enter server port
12. uint64_t _millis = 0;
13. uint64_t now = 0;
14. /******************/
15.
16. #define ROWS 4
17. #define COLS 4
18. #define ONBOARD_LED 2
19.
20. char keyMap[ROWS][COLS] = {
21. {'1','2','3', 'A'},
22. {'4','5','6', 'B'},
23. {'7','8','9', 'C'},
24. {'*','0','#', 'D'}
25. };

46
26.
27. char key;
28.
29. uint8_t rowPins[ROWS] = {13, 12, 14, 27}; // GIOP13, GIOP12, GIOP14,
GIOP27
30. uint8_t colPins[COLS] = {26, 25, 33, 32}; // GIOP26, GIOP25, GIOP33,
GIOP32
31. uint8_t LCD_CursorPosition = 0;
32.
33. Keypad keypad = Keypad(makeKeymap(keyMap), rowPins, colPins, ROWS,
COLS );
34. LiquidCrystal_I2C I2C_LCD(0x27, 16, 2); // set the LCD address to
0x27 for a 16 chars and 2 line display
35. /******************/
36. SocketIoClient socketIO;
37. String mensaje;
38. /******************/
39.
40. void setup(){
41. Serial.begin(115200);
42. // Initialize The I2C LCD
43. I2C_LCD.begin();
44. // Turn ON The Backlight
45. I2C_LCD.backlight();
46. // Clear The Display
47. I2C_LCD.clear();
48.
49. /******************/
50. connectWiFi_STA();
51. socketIO.begin(server, port);
52. socketIO.on("DESDE_SERVER_COMANDO",procesar_comando_recibido);
53. //socketIO.on("DESDE_SERVER_SENAL",procesar_senal_recibida);
54. pinMode(ONBOARD_LED,OUTPUT);
55. /******************/
56. }

47
57.
58. void loop(){
59. now = millis();
60. key = keypad.getKey();
61.
62. if (key) {
63. Serial.print(key);
64. I2C_LCD.setCursor(LCD_CursorPosition++, 0);
65. if(LCD_CursorPosition > 16 || key == 'C')
66. {
67. I2C_LCD.clear();
68. LCD_CursorPosition = 0;
69. }
70. else
71. {
72. I2C_LCD.print(key);
73. /******************/
74. mensaje = "\""+String(key)+"\"";
75. socketIO.emit("DESDE_ESP32_TECLA",mensaje.c_str());
76. /******************/
77. }
78. }
79.
80. if(now%500==0)
81. {
82. mensaje = "\""+String(analogRead(34))+"\"";
83. socketIO.emit("DESDE_ESP32_SENAL",mensaje.c_str());
84. }
85. socketIO.loop();
86. }
87.
88. void connectWiFi_STA()
89. {
90. delay(10);
91. Serial.println("");

48
92. WiFi.mode(WIFI_STA);
93. WiFi.begin(ssid, password);
94. while (WiFi.status() != WL_CONNECTED)
95. {
96. delay(100);
97. Serial.print('.');
98. }
99. Serial.println("");
100. Serial.print("Iniciado STA:\t");
101. Serial.println(ssid);
102. Serial.print("IP address:\t");
103. Serial.println(WiFi.localIP());
104. }
105.
106. void procesar_comando_recibido(const char * payload, size_t
length) {
107. Serial.printf("Mensaje recibido: %s\n", payload);
108. String paystring = String(payload);
109.
110. I2C_LCD.setCursor(0, 1);
111. I2C_LCD.print(" ");
112. I2C_LCD.setCursor(0, 1);
113. I2C_LCD.print(paystring);
114.
115. if(paystring == "ON")
116. {
117. digitalWrite(ONBOARD_LED,HIGH);
118. }
119. else if(paystring == "OFF")
120. {
121. digitalWrite(ONBOARD_LED,LOW);
122. }
123. }
124.
125. /*

49
 126. void procesar_senal_recibida(const char * payload, size_t
length) {
127. Serial.printf("Senal recibida: %s\n", payload);
128. String paystring = String(payload);
129. I2C_LCD.setCursor(0, 1);
130. I2C_LCD.print(" ");
131. I2C_LCD.setCursor(0, 1);
132. I2C_LCD.print(paystring);
133. }
134. */

Conclusión
En esta práctica se implementaron entradas y salidas nuevas, tales como el teclado
matricial y el LCD para poder mandarlos a un servidor, las instrucciones que se
ejecuten por medio del teclado, potenciómetro o el servidor serán mostrados en la
pantalla del LCD. Para realizarlo se tuvieron que descargar librerías para que el
código funcione, además de la instalación de un programa que nos ayudará a
presentar la pagina del servidor. Pero lo más difícil de ejecutar fue el servidor ya que
había complicaciones con la IP y la solución fue conectarme a otro servidor que
alguien externo había creado.

50