Montesdeoca.J PruebaCorreción MICRO

PLANTEL: WNEßiDN TécAICA DEL NoaTE ASIGNATURA: micoocoNT20LAOOQES
ALUMNO: moNEsbEOCA bouA CURSO: Gh6 C1EE

FECHA: CALIFICACIÓN:
TRIMESTRE: FIRMA PROFESOR:
13
33d2 1
A
3302
3302
as 3202
3
SNcc 33p2
SK 3202
/OAlycoUIDA TECACA DEL NORTE

CIELE
MiceoroNTeOLADoeES
MeTEs DEOCA bosoA
PluEBA_|
de 2023
q de royo
pin Mot3ou1f1)
inMoce(S O01u
bin lock6 O0TUT
-.in Mode OUTPUT
intode (lo,o1pUT)
ESTILOD
Mrtode(, 101)
Nod loop
Analo:unk (3 ow);
AIGH);
UNIVERSIDAD TÉCNICA DEL NORTE
FACULTAD DE INGENIERÍA EN
CIENCIAS APLICADAS
ELECTRICIDAD
PRUEBA PRIMER PARCIAL

MICROCONTROLADORES
Implementación de un sistema de control de

secuencias de luces utilizando un
potenciómetro como elemento de control con
Prueba #: 1 Tema: Arduino (Mega 2560).
Fecha de realización
de la práctica: 2023 Mayo 9
año mes día
Observaciones: Sistema de control de secuencias de luces utilizando un potenciómetro como elemento de control
Fecha de entrega del

informe: 2023 Mayo 21
año mes día
Observaciones: Presentación de informe y resultados.
Periodo: Abril – Agosto

Octubre – Febrero
Taller de Microcontroladores
Taller N. 1
1. Tema: Implementación de un sistema de control de secuencias de luces utilizando un

potenciómetro como elemento de control con Arduino (Mega 2560).
2. Objetivo General.
Desarrollar habilidades en la programación y uso de la plataforma de prototipado electrónico

Arduino Mega 2560 para simular un sistema de control de secuencias de luces utilizando un
potenciómetro como elemento de control.
3. Objetivos Específicos.
 Comprender los principios básicos del funcionamiento de la plataforma Arduino Mega 2560 y
su entorno de programación (IDE).
 Montar un circuito en una protoboard que permita simular un sistema de control de secuencias
de luces utilizando componentes electrónicos (potenciómetro como elemento de control) y
Arduino Mega 2560.
 Programar el Arduino Mega 2560 utilizando el lenguaje de programación de Arduino (basado
en C++) para controlar el encendido y apagado de los LEDs para cada una de las secuencias
requeridas por el docente.
4. Marco Teórico
4.1. Introducción
En este taller práctico de laboratorio se explorará el uso de la tarjeta de desarollo Arduino Mega
2560, una herramienta ampliamente utilizada en la industria y la educación para el desarrollo de
proyectos electrónicos y robóticos. Se simulará el encendido y apagado de un LED, además de
la simulación diferentes secuencias de luces controladas mediante un potenciómetro en una
protoboard, lo que permitirá a los participantes adquirir habilidades en la programación y uso de
esta plataforma, así como en la comprensión de los principios físicos fundamentales que la
sustentan.
En este taller, se profundizará en conceptos fundamentales de la electrónica y la programación
para la simulación de los casos mencionados anteriormente con Arduino Mega 2560. Para
alcanzar los objetivos específicos, se utilizarán diversas técnicas y herramientas como el diseño
y construcción de circuitos en una protoboard, la programación en el lenguaje de programación
de Arduino (C++), la simulación y análisis de resultados. El uso de componentes electrónicos
como resistencias, diodos led y cables dupond, será necesario para el correcto funcionamiento
del circuito, mientras que el software de programación Arduino IDE permitirá la interacción con el
microcontrolador ATmega2560 presente en la placa de desarrollo Arduino Mega 2560.
4.2. ¿Qué es Arduino?

Arduino fue creado en Ivrea, Italia en 2005 por un equipo de estudiantes de diseño y programación
de la Escuela de Diseño de Interacción de Ivrea. Los fundadores del proyecto son Massimo Banzi,
David Cuartielles, Tom Igoe, Gianluca Martino y David Mellis. El primer Arduino, el Arduino Uno,
fue lanzado en 2005 y desde entonces ha sido ampliamente utilizado en todo el mundo para una
amplia gama de aplicaciones, desde proyectos educativos hasta sistemas de automatización del
hogar y robótica.
Arduino es una plataforma de hardware y software de código abierto para la creación de proyectos
interactivos basados en la electrónica y la programación. Esta plataforma está compuesta por una
serie de placas electrónicas, sensores, actuadores, módulos y periféricos que se conectan entre
sí para formar circuitos electrónicos. Además, cuenta con un lenguaje de programación propio y
un entorno de desarrollo integrado (IDE) que permite la creación y carga de programas en las
placas de desarrollo.
La plataforma Arduino es especialmente conocida por su facilidad de uso y accesibilidad, lo que
la ha convertido en una herramienta popular para la enseñanza y aprendizaje de la electrónica y
la programación. Además, la comunidad de usuarios de Arduino es muy activa y colaborativa, lo
que ha llevado a la creación de una gran cantidad de proyectos y recursos educativos que están
disponibles de forma gratuita en línea. Con Arduino es posible desarrollar proyectos en diversas
áreas como robótica, domótica, automatización, arte, música, entre otras. Con el paso del tiempo,
Arduino ha evolucionado para incluir una variedad de placas y herramientas de desarrollo, como
el Arduino Mega 2560 utilizado en este trabajo.
4.3. IDE de Arduino
El IDE de Arduino es un entorno de desarrollo integrado que se utiliza para escribir y cargar
programas en las placas de desarrollo de Arduino. Es una aplicación que se instala en un
ordenador y proporciona un editor de texto para escribir el código fuente, un compilador que
convierte el código en lenguaje de máquina y un cargador de programas que carga el código
compilado en la placa de desarrollo. Además, el IDE de Arduino incluye herramientas de
depuración para identificar y solucionar errores en el código. Es una herramienta muy útil para los
desarrolladores y aficionados que quieren crear proyectos con Arduino, ya que les permite escribir
y probar el código en un entorno amigable y fácil de usar. El IDE de Arduino es de código abierto
y está disponible para su descarga en el sitio web oficial de Arduino.
4.3.1. Programación en Arduino
La programación en Arduino se realiza utilizando el lenguaje de programación C/C++, aunque
con algunas simplificaciones y modificaciones para facilitar su uso. El proceso de programación
se realiza a través del IDE de Arduino, donde se pueden crear y editar programas, compilarlos y
cargarlos en la placa de desarrollo.
Los programas en Arduino se denominan "sketches" y están compuestos por dos funciones
principales: setup() y loop(). La función setup() se ejecuta una vez al inicio del programa y se
utiliza para inicializar variables, configurar los pines de entrada/salida y otros parámetros
necesarios para el correcto funcionamiento del programa. Por otro lado, la función loop() se
ejecuta continuamente después de que la función setup() haya terminado y se utiliza para definir
las acciones que el programa debe realizar en bucle.
La sintaxis de programación en Arduino es muy similar a la del lenguaje C/C++, pero se han
agregado algunas funciones y librerías específicas para trabajar con los periféricos de la placa de
desarrollo, como sensores, actuadores y pantallas. Además, Arduino cuenta con una amplia
comunidad de usuarios que han creado y compartido una gran cantidad de ejemplos y recursos
educativos en línea para facilitar el aprendizaje y la programación en esta plataforma.
4.4. Arduino Mega 2560
El Arduino Mega 2560 es una placa de desarrollo de la familia Arduino que se lanzó en el año
2010. Fue creada por un equipo de diseñadores y programadores liderados por Massimo Banzi.
El Arduino Mega 2560 es una placa potente y versátil que cuenta con un microcontrolador de la familia
AVR de 8 bits, el ATmega2560, que opera a una velocidad de 16 MHz. Esta placa tiene 54 pines
digitales de entrada/salida, 16 pines analógicos, cuatro UARTs (puertos serie), una conexión USB,
una toma de alimentación, una conexión ICSP y un botón de reinicio. Además, el Arduino Mega 2560
es compatible con la mayoría de los shields de Arduino y tiene capacidad para manejar proyectos
más complejos y demandantes que el Arduino UNO u otras placas más básicas de la familia Arduino.
5. PWM y su relación con Arduino
PWM (Pulse Width Modulation) es una técnica utilizada en electrónica para generar señales de voltaje
que varían en su nivel de potencia mediante la modulación del ancho del pulso de la señal.
En el contexto de Arduino, la mayoría de las placas de Arduino tienen uno o varios pines que admiten
la generación de señales PWM. Esto permite a los usuarios generar señales analógicas en sus
proyectos, ya que una señal PWM se puede filtrar y suavizar para obtener una señal analógica.
La función analogWrite() de Arduino se utiliza para generar una señal PWM en un pin determinado.
El usuario especifica la frecuencia y la duración del pulso a través de esta función, y la placa de
Arduino genera una señal PWM en el pin especificado. Esta técnica se utiliza comúnmente para
controlar la intensidad de un LED, la velocidad de un motor o para generar tonos de audio
En resumen, PWM es una técnica utilizada para generar señales analógicas a partir de una señal
digital, y es ampliamente utilizado en proyectos de Arduino para controlar la intensidad de la luz, la
velocidad del motor y otras aplicaciones similares.
6. Pines Analógicos
Los pines analógicos en Arduino son uno de los recursos más importantes que ofrece la
plataforma para interactuar con el mundo físico mediante la programación. Estos pines permiten
leer señales analógicas provenientes de sensores y otros dispositivos electrónicos, lo que permite
a los usuarios capturar y procesar información en tiempo real.
Los pines analógicos en Arduino se identifican por tener una numeración precedida por la letra
'A', y pueden funcionar tanto como entrada como salida. Para utilizar un pin analógico como
entrada, es necesario configurar su modo de operación mediante el comando pinMode()
indicando que el pin será utilizado como entrada analógica pinMode(pin, INPUT). Luego, se
puede leer el valor analógico del pin con el comando analogRead(), que permite leer el valor
analógico de una señal en el pin.
Cabe mencionar que el rango de valores que puede ser leído en un pin analógico varía
dependiendo de la resolución del convertidor analógico-digital (ADC) de la placa, que en Arduino
Uno es de 10 bits. Esto significa que el rango de valores que puede ser leído va desde 0 a 1023.
Por otro lado, para utilizar un pin analógico como salida, es necesario configurar su modo de
operación mediante el comando pinMode() indicando que el pin será utilizado como salida
analógica pinMode(pin, OUTPUT). Luego, se puede establecer el valor analógico del pin con el
comando analogWrite(), que permite enviar una señal analógica en el rango de 0 a 255. Es
importante tener en cuenta que no todos los pines analógicos de Arduino permiten enviar señales
analógicas utilizando el comando analogWrite(), sino que solo algunos de ellos tienen la
capacidad de hacerlo.
7. Librerías de/para Arduino
Las librerías en Arduino son colecciones de código preescrito que permiten a los usuarios acceder a
ciertas funciones y características que no están incluidas en el código básico de Arduino.
Estas librerías proporcionan un conjunto de funciones y herramientas útiles para simplificar el
desarrollo de proyectos. Los usuarios pueden incorporar estas librerías en su propio código para
extender las funcionalidades de sus proyectos y reducir la cantidad de tiempo y esfuerzo necesarios
para escribir código desde cero.
Por ejemplo, si deseas utilizar un sensor de temperatura y humedad en tu proyecto, en lugar de tener
que escribir todo el código para leer los datos del sensor y realizar los cálculos necesarios para
mostrar la información en una pantalla LCD, puedes usar una librería como DHT para realizar todas
estas tareas de forma sencilla.
Arduino cuenta con una gran cantidad de librerías de código abierto disponibles que se pueden
descargar e incorporar en tus proyectos. Algunas de las librerías más populares incluyen librerías
para el manejo de sensores, librerías para el control de motores, librerías para el manejo de pantallas
LCD, entre otras.
En pocas palabras, las librerías en Arduino permiten a los usuarios agregar nuevas funcionalidades
y simplificar el desarrollo de sus proyectos al proporcionar una colección de funciones y herramientas
útiles.
6.1. Cómo instalar las librerías de/para Arduino?
Para instalar una librería en Arduino, sigue los siguientes pasos:
1) Descarga la librería: la mayoría de las librerías de Arduino están disponibles en línea en sitios
como el sitio web oficial de Arduino, GitHub, desde el mismo IDE Arduino y otros. Descarga
la librería que necesitas a tu computadora.
2) Abre el software de Arduino: abre el software de Arduino en tu computadora.
3) Importa la librería: ve al menú Sketch y selecciona la opción Include Library, luego selecciona
la opción Add .ZIP Library. En caso de hacerlo de la IDE de Arduino, vas al apartado de Library
Manager e instalas la librería que desees.
4) Selecciona la librería descargada: busca la ubicación de la librería que descargaste en el paso
1 y selecciónala.
5) Instala la librería: el software de Arduino instalará la librería y la agregará a la lista de librerías
disponibles.
6) Usa la librería en tu proyecto: para usar la librería en tu proyecto, ve al menú Sketch y
selecciona la opción Import Library, y luego selecciona la librería que acabas de agregar.
Con estos pasos, se podrá agregar cualquier librería al proyecto de Arduino y empezar a utilizarla.
Es importante destacar que algunos proyectos pueden requerir varias librerías, así que debemos
asegurarnos de agregar todas las librerías necesarias para nuestro proyecto.
8. Trabajo Preparatorio
Antes de rendir la prueba correspondiente al primer parcial, el estudiante debió revisar lo conceptos
y programación vista en anteriores clases.
Para este punto, el estudiante debería tener un conocimiento básico de la función de la librería PWM
en Arduino y su relación con la modulación de ancho de pulso (PWM, por sus siglas en inglés), que
se utiliza para controlar la cantidad de energía que se envía a un dispositivo, como un LED. La
modulación PWM permite que la energía se envíe en pulsos rápidos, lo que permite controlar la
intensidad del LED o cualquier otro dispositivo que se utilice.
Se realizar una programación a para controlar las diferentes secuencias de encendido y apagado de
los LEDs. Para ello, se puede utilizar las diferentes funciones de Arduino, que permiten leer la señal
analógica del potenciómetro y dictar que hará cada uno de los LEDs
Finalmente, el estudiante deberá estar en la capacidad de programa todo esto de forma escrita.
Este trabajo preparatorio permitirá concluir la prueba con todas las indicaciones y requerimientos
mencionados por el docente.
9. Equipos y Materiales
 Arduino Mega 2560
 Computador portátil / Laptop
 Software de programación para Arduino (Arduino IDE)
 Protoboard
 USB tipo B
 Potenciómetro 5k
 Cables dupond
 Resistencias de 330 Ω
 Diodos emisores de luz (LEDs)
10. Datos y Observaciones.

Las indicaciones por parte del docente fueron las siguientes:
Para la prueba se requerirá 11 LEDs (color a su elección), 11 resistencias (a su conveniencia), un
potenciómetro (5K), cables dupond y Arduino (Mega 2560).
El potenciómetro debe conectarse al pin A7 y los 11 leds desde el pin 2 hasta el pin 12.
Con esto debe realizar lo siguiente:
1. Secuencia 1: los leds deben encenderse y apagarse desde los extremos, esto hasta llegar al
centro. Una vez que hayan llegado al centro, deben hacer la secuencia en reversa; deben
encenderse y apagarse desde el centro hacia los extremos. El tiempo de encendido y apagado
solicitado para cada uno de los LEDs es de 10ms y debe ejecutarse en el rango del
potenciómetro de 0 a 255.
2. Secuencia 2: esta secuencia es de ida y retorno. Los LEDs deben encenderse y apagarse
des el extremo izquierdo saltando uno (impares), el retorno debe ser de la misma manera,
pero desde el extremo derecho (pares). El tiempo de encendido y apagado solicitado para
cada uno de los LEDs es de 10ms y debe ejecutarse en el rango del potenciómetro de 256 a
512.
3. Secuencia 3: se debe realizar una secuencia en cascada de encendido y apagado desde los
extremos izquierdo y derecho de los LEDs. Se enciende los LEDs de los extremos de uno en
uno, esto hasta que se enciendan 3. Luego conforme vayan avanzando hacia el centro se van
apagando desde los extremos sucesivamente para solo tener tres leds. En la sección central
deben estar encendidos 5 LEDs, luego 3, después 1 y se apagaría este último. También deben
realizarse la secuencia inversa desde el centro y una vez se haya apagado el último LED
(central). El tiempo de encendido y apagado solicitado para cada uno de los LEDs es de 10ms
y debe ejecutarse en el rango del potenciómetro de 513 a 769.
4. Secuencia 4: está ultima secuencia en la similar la secuencia dos descrita anteriormente. En

este caso se debe dimerizar cada uno de los LEDs con ayuda del potenciómetro, mientras la
secuencia se ejecuta. El tiempo de encendido y apagado solicitado para cada uno de los LEDs
es de 10ms y debe ejecutarse en el rango del potenciómetro de 770 a 1023.
11. Código, esquemas, simulaciones y resultados.
11.1. Código en IDE Arduino (secuencia_1)
/*
CIELE
MICROCONTROLADORES
Joshua Steven Montesdeoca Montesdeoca
Entrada Analógica
00 de Mayo de 2023
*/
// Definir pines
const int pinesLed[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
const int numPinesLed = sizeof(pinesLed) / sizeof(int);
// Definir variables
int tiempo = 200; // variable que controla el tiempo de encendido y apagado de un
led
int paso = 1; // variable que indica el paso actual en la secuencia
unsigned long tiempoAnterior = 0; // variable para almacenar el tiempo anterior
void setup() {
// Configurar los pines
for (int i = 0; i < numPinesLed; i++) {
pinMode(pinesLed[i], OUTPUT);
}
}
void loop() {
unsigned long tiempoActual = millis(); // obtener el tiempo actual
// Encender los extremos

if (paso == 1) {
digitalWrite(pinesLed[0], HIGH); // enciende el primer LED en la secuencia. Esto
se logra al establecer el pin pinesLed[0] en el estado HIGH.
digitalWrite(pinesLed[numPinesLed - 1], HIGH); // enciende el último LED
en la secuencia. Esto se logra al establecer el pin pinesLed[numPinesLed - 1] en el
estado HIGH.
tiempoAnterior = tiempoActual;
paso = 2; // actualiza la variable paso a 2. Esto indica que se ha completado el
primer paso (encender los extremos) y se pasará al siguiente paso en la secuencia
}
// Apagar los extremos y encender los LEDs intermedios

else if (paso < numPinesLed && tiempoActual - tiempoAnterior >= tiempo) {
digitalWrite(pinesLed[paso - 2], LOW); // apaga el LED en la posición paso - 2.
Esto apaga el LED que se encendió en el paso anterior.
digitalWrite(pinesLed[numPinesLed - paso + 1], LOW); // Esto apaga el LED que se
encendió en el paso anterior, pero en el extremo opuesto al apagado en la línea
anterior.
digitalWrite(pinesLed[paso - 1], HIGH); // enciende el LED en la posición paso -
1. Esto enciende el siguiente LED en la secuencia.
digitalWrite(pinesLed[numPinesLed - paso], HIGH); // enciende el LED en la
posición numPinesLed - paso. Esto enciende el LED en el extremo opuesto al encendido
en la línea anterior.
paso++;
}
// Apagar los LEDs intermedios y encender el siguiente extremo

else if (paso == numPinesLed && tiempoActual - tiempoAnterior >= tiempo) {
digitalWrite(pinesLed[numPinesLed - 2], LOW); // apaga el penúltimo LED en la
secuencia. Es decir, el LED en la posición numPinesLed - 2
digitalWrite(pinesLed[1], LOW); // apaga el segundo LED en la secuencia. Es
decir, el LED en la posición 1 (segunda posición del array).
digitalWrite(pinesLed[numPinesLed - 1], HIGH); // enciende el último LED en la
secuencia. Es decir, el LED en la posición numPinesLed - 1
paso = 1; // se reinicia la secuencia y se vuelve al primer paso.
}
}
/*
CIELE
MICROCONTROLADORES
Secuencia 2 Prueba
00 de Mayo de 2023
*/
// Definir pines
unsigned long tiempoInicio = 0; // variable que guarda el tiempo en que se inició el
ciclo actual
led
// Definir secuencia de encendido de pines

int secuencia[] = {12, 10, 8, 6, 4, 2, 3, 5, 7, 9, 11};
void setup() {
for(int i = 0; i < 11; i++){
pinMode(secuencia[i], OUTPUT);
}
}
void loop() {
// Verificar si ha pasado el tiempo suficiente para avanzar al siguiente LED
if(millis() - tiempoInicio >= tiempo){
// Encender el siguiente LED en la secuencia
digitalWrite(secuencia[paso - 1], HIGH);
// Guardar el tiempo de inicio del ciclo actual

tiempoInicio = millis();
// Apagar el LED anterior en la secuencia

digitalWrite(secuencia[(paso - 2 + 11) % 11], LOW); // apaga el LED anterior en
la secuencia. Utiliza (paso - 2 + 11) % 11 para calcular la posición del LED
anterior teniendo en cuenta los índices del array.
// Incrementar el paso actual

paso++;
// Si se alcanza el último paso, regresar a la primera secuencia

if(paso > 11){
paso = 1;
} // verifica si se alcanzó el último paso de la secuencia. Si es así, se
reinicia paso a 1 para volver a la primera secuencia.
}
}
/*
CIELE
MICROCONTROLADORES
Secuencia 2 Prueba
00 de Mayo de 2023
*/
// Definir pines
int pins[] = {12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2};
int num_pins = 11;
int delay_time = 200; // tiempo de espera entre cada parpadeo, en milisegundos
void setup() {
// Configurar pines como salidas
for (int i = 0; i < num_pins; i++) {
pinMode(pins[i], OUTPUT);
}
}
void loop() {
// Encender pines 12 y 2
digitalWrite(pins[0], HIGH);
delay(delay_time);
delay(delay_time);
delay(delay_time);
// Apagar pines 12 y 2, encender pines 9 y 5

digitalWrite(pins[0], LOW);
delay(delay_time);

delay(delay_time);
// Apagar pines 10 y 4, encender pin 7

delay(delay_time);
// Apagar pines 9 y 5, encender pines 8, 7 y 6
delay(delay_time);

delay(delay_time);
// Apagar pin 7
delay(delay_time);
//Secuencia inversa
// Encender pin 7
delay(delay_time);
// Encender pines 8, 6 y 7
delay(delay_time);
delay(delay_time);
// Apagar pin 7 y encender pines 10 y 4

delay(delay_time);
// Apagar pines 8 y 6 y encender pines 11 y 3

delay(delay_time);

delay(delay_time);
// Apagar pin 10 y pin 4

delay(delay_time);

delay(delay_time);

delay(delay_time);
}
/*
CIELE
MICROCONTROLADORES
Secuencia 2 Prueba
00 de Mayo de 2023
*/
// Definir pines
unsigned long tiempoInicio = 0; // variable que guarda el tiempo en que se inició el
ciclo actual
led
// Definir secuencia de encendido de pines

int secuencia[] = {12, 10, 8, 6, 4, 2, 3, 5, 7, 9, 11};
void setup() {
for(int i = 0; i < 11; i++){
}
}
void loop() {
// Leer el valor del potenciómetro
int potValue = analogRead(A0);
// Mapear el valor del potenciómetro al rango de PWM (770-1023)

int pwmValue = map(potValue, 770, 1023, 0, 255);

// Encender el siguiente LED en la secuencia con la intensidad mapeada
analogWrite(secuencia[paso - 1], pwmValue);


digitalWrite(secuencia[(paso - 2 + 11) % 11], LOW);

paso++;

if(paso > 11){
paso = 1;
}
}
}
11.5. Código en IDE Arduino (prueba_1_secuenciasPot)
/*
CIELE
MICROCONTROLADORES
Prueba Correción
00 de Mayo de 2023
*/
// Definir pines
int potValue = 0;
const int numPinesLed = sizeof(pinesLed) / sizeof(int);
// Definir variables general

led
unsigned long tiempoAnterior = 0; // variable para almacenar el tiempo anterior
// Definir variables para secuencia 2

unsigned long tiempoInicio = 0; // variable que guarda el tiempo en que se
inició el ciclo actual
// Definir secuencia de encendido de pines, secuencia 2
int secuencia[] = {12, 10, 8, 6, 4, 2, 3, 5, 7, 9, 11};
// Definir variables para secuencia 3

int pins[] = {12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2};
int num_pins = 11;
int delay_time = 200; // tiempo de espera entre cada parpadeo, en milisegundos
void setup() {
Serial.begin(9600); // Inicializa la comunicación serial a una velocidad de 9600
baudios
//1
for (int i = 0; i < numPinesLed; i++) {
pinMode(pinesLed[i], OUTPUT);
}
//2
for(int i = 0; i < 11; i++){
}
//3
for (int i = 0; i < num_pins; i++) {
pinMode(pins[i], OUTPUT);
}
void loop() {
// Leer el valor del potenciómetro
potValue = analogRead(A8);
Serial.println(potValue); // Imprime el valor del potenciómetro en la consola de
Arduino
//Inicio secuencia 1
// Determinar en qué rango se encuentra el valor del potenciómetro
if (potValue >= 0 && potValue <= 255) {
unsigned long tiempoActual = millis(); // obtener el tiempo actual
// Encender los extremos

if (paso == 1) {
digitalWrite(pinesLed[0], HIGH);
digitalWrite(pinesLed[numPinesLed - 1], HIGH);
paso = 2;
}
// Apagar los extremos y encender los LEDs intermedios
else if (paso < numPinesLed && tiempoActual - tiempoAnterior >= tiempo) {
digitalWrite(pinesLed[paso - 2], LOW);
digitalWrite(pinesLed[numPinesLed - paso + 1], LOW);
digitalWrite(pinesLed[paso - 1], HIGH);
digitalWrite(pinesLed[numPinesLed - paso], HIGH);
paso++;
}
// Apagar los LEDs intermedios y encender el siguiente extremo

else if (paso == numPinesLed && tiempoActual - tiempoAnterior >= tiempo) {
digitalWrite(pinesLed[numPinesLed - 2], LOW);
digitalWrite(pinesLed[1], LOW);
digitalWrite(pinesLed[numPinesLed - 1], HIGH);
paso = 1;
}
} // fin secuencia 1
//inicio secuencia 2
else if (potValue >= 256 && potValue <= 512) {
// Encender el siguiente LED en la secuencia
digitalWrite(secuencia[paso - 1], HIGH);



paso++;

if(paso > 11){
paso = 1;
}
}
} //fin secuencia 2
delay(delay_time);
delay(delay_time);
delay(delay_time);

delay(delay_time);

delay(delay_time);

delay(delay_time);
// Apagar pines 9 y 5, encender pines 8, 7 y 6

delay(delay_time);

delay(delay_time);
// Apagar pin 7
delay(delay_time);
//Secuencia inversa
// Encender pin 7
delay(delay_time);
// Encender pines 8, 6 y 7
delay(delay_time);
delay(delay_time);
// Apagar pin 7 y encender pines 10 y 4

delay(delay_time);

delay(delay_time);

delay(delay_time);

delay(delay_time);

delay(delay_time);

delay(delay_time);
}//fin secuencia 3
// Encender el siguiente LED en la secuencia con la intensidad mapeada
analogWrite(secuencia[paso - 1], pwmValue);



paso++;

if(paso > 11){
paso = 1;
}
}
}
}
11.6. Esquemas y simulaciones en Fritzing

11.7. Resultados
Enlaces video
Prueba: VID20230521221908.mp4
VID20230521221729.mp4
12. Análisis de resultados
Con este código se logró realizar diversas secuencias de encendido y apagado de LEDs controladas
por un potenciómetro en un microcontrolador. En la configuración inicial, se definen los pines y
variables necesarios, incluyendo los pines de los LEDs y su cantidad, así como variables para
controlar el tiempo y el paso actual en las secuencias. En la función principal, se lee el valor del
potenciómetro y se realiza una secuencia específica según el rango en el que se encuentre. La
secuencia 1 enciende y apaga los LEDs de forma alternada. La secuencia 2 avanza en
una secuencia predefinida de encendido de los LEDs. La secuencia 3 crea un efecto de parpadeo en
los LEDs. La
secuencia 4 permite controlar la intensidad de los LEDs utilizando modulación por ancho de pulso
(PWM). Cada secuencia se ejecuta de forma continua hasta que se cambie el valor del potenciómetro.
Se consiguió un resultado favorable al momento del cargar el código a la tarjeta de desarrollo Arduino
Mega 2560. Cada una de las secuencias tuvieron un correcto funcionamiento y cumplió con mis
expectativas.
13. Conclusiones y Recomendaciones
13.1. Conclusiones
 El código proporcionado implementa varias secuencias de encendido y apagado de

LEDs de manera efectiva, controladas por un potenciómetro. Esto permite crear
efectos visuales interesantes y variados utilizando una configuración simple.
 El uso de bucles "for" y estructuras condicionales "if-else" facilita la implementación de
las secuencias y el control del tiempo de encendido y apagado de los LEDs.
 El código muestra cómo utilizar la comunicación serial para imprimir el valor del
potenciómetro en la consola de Arduino, lo que puede ser útil para monitorear y
depurar el sistema.
13.2. Recomendaciones
 Al ensamblar este código en una protoboard, se recomienda verificar correctamente

las conexiones de los pines de los LEDs y del potenciómetro. Asegúrese de que los
pines estén correctamente conectados y que no haya errores de conexión que puedan
causar mal funcionamiento o daños en los componentes.
 Es importante tener en cuenta las limitaciones de corriente de la protoboard y de los
pines del microcontrolador. Si se utilizan muchos LEDs o se aumenta la intensidad
mediante PWM, es posible que se supere la corriente máxima permitida. En ese caso,
se deben tomar precauciones adicionales, como utilizar resistencias limitadoras de
corriente o alimentar los LEDs externamente.
 Se recomienda ajustar adecuadamente el tiempo de encendido y apagado de los
LEDs, así como los retrasos entre cada secuencia. Esto permitirá obtener efectos
visuales deseados y evitará que las secuencias se ejecuten demasiado rápido o
demasiado lento, afectando la apariencia y el rendimiento del sistema. Experimentar
con diferentes valores de tiempo y retrasos puede ayudar a lograr mejores resultados
visuales.
14. Bibliografía y/o Linkografia.
 Arduino.cl. (s.f.). ¿Qué es Arduino? Recuperado el 21 de abril de 2023, de

https://arduino.cl/que-es-arduino/
 Arduino.cl. (s. f.). Programación. Recuperado de https://arduino.cl/programacion/

 Aprendiendo Arduino. (2017, enero 23). Programación Arduino (5) [Entrada de blog].
Recuperado el 21 de abril de 2023, de
https://aprendiendoarduino.wordpress.com/2017/01/23/programacion-arduino-5/
 Proyecto Arduino. (s.f.). Arduino Mega 2560. Recuperado el 21 de abril de 2023, de

https://proyectoarduino.com/arduino-mega-2560/

Montesdeoca.J PruebaCorreción MICRO

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Montesdeoca.J PruebaCorreción MICRO

Cargado por

Copyright:

Formatos disponibles

PLANTEL: WNEßiDN TécAICA DEL NoaTE ASIGNATURA: micoocoNT20LAOOQES

ALUMNO: moNEsbEOCA bouA CURSO: Gh6 C1EE

TRIMESTRE: FIRMA PROFESOR:

/OAlycoUIDA TECACA DEL NORTE

PRUEBA PRIMER PARCIAL

Implementación de un sistema de control de

Fecha de entrega del

Observaciones: Presentación de informe y resultados.

Periodo: Abril – Agosto

1. Tema: Implementación de un sistema de control de secuencias de luces utilizando un

Desarrollar habilidades en la programación y uso de la plataforma de prototipado electrónico

4.2. ¿Qué es Arduino?

5. PWM y su relación con Arduino

 Arduino Mega 2560

 Computador portátil / Laptop

 Software de programación para Arduino (Arduino IDE)

 Diodos emisores de luz (LEDs)

10. Datos y Observaciones.

4. Secuencia 4: está ultima secuencia en la similar la secuencia dos descrita anteriormente. En

11. Código, esquemas, simulaciones y resultados.

11.1. Código en IDE Arduino (secuencia_1)

// Encender los extremos

// Apagar los extremos y encender los LEDs intermedios

// Apagar los LEDs intermedios y encender el siguiente extremo

11.2. Código en IDE Arduino (secuencia_2)

// Definir secuencia de encendido de pines

// Guardar el tiempo de inicio del ciclo actual

// Apagar el LED anterior en la secuencia

// Incrementar el paso actual

// Si se alcanza el último paso, regresar a la primera secuencia

11.3. Código en IDE Arduino (secuencia_3)

// Apagar pines 12 y 2, encender pines 9 y 5

// Apagar pines 11 y 3, encender pines 8 y 6

// Apagar pines 10 y 4, encender pin 7

// Apagar pines 8 y 6, encender pin 7

// Apagar pin 7 y encender pines 10 y 4

// Apagar pines 8 y 6 y encender pines 11 y 3

// Apagar pines 9 y 5 y encender pines 12 y 2

// Apagar pin 10 y pin 4

// Apagar pin 11 y pin 3

// Apagar pin 12 y pin 2

11.4. Código en IDE Arduino (secuencia_4)

// Definir secuencia de encendido de pines

// Mapear el valor del potenciómetro al rango de PWM (770-1023)

// Verificar si ha pasado el tiempo suficiente para avanzar al siguiente LED

// Guardar el tiempo de inicio del ciclo actual

// Apagar el LED anterior en la secuencia

// Incrementar el paso actual

// Si se alcanza el último paso, regresar a la primera secuencia

11.5. Código en IDE Arduino (prueba_1_secuenciasPot)

// Definir variables general

// Definir variables para secuencia 2

// Definir variables para secuencia 3

// Encender los extremos

// Apagar los LEDs intermedios y encender el siguiente extremo

// Guardar el tiempo de inicio del ciclo actual

// Apagar el LED anterior en la secuencia

// Incrementar el paso actual

// Si se alcanza el último paso, regresar a la primera secuencia

// Apagar pines 12 y 2, encender pines 9 y 5

// Apagar pines 11 y 3, encender pines 8 y 6

// Apagar pines 10 y 4, encender pin 7

// Apagar pines 9 y 5, encender pines 8, 7 y 6