UNIVERSIDAD POLITÉCNICA

DEL CENTRO

Investigacion Arduino

Matrícula - Nombre del Alumno

004089-José Raúl González De La Cruz
004289-Andric David Parra Collado

Asignatura
Programación de Periféricos

Profesor
DR. Jose Ney Garrido Vázquez

Cuatrimestre: 4

Grupo: 2

Correo: josergc2001@gmail.com
Correo: parra172001@gmail.com

20 de septiembre del 2020

Practica 1 - T1
 Objetivo

El objetivo durante esta Práctica es aprender a utilizar nuestro circuito Arduino y

comprender la complejidad, responsabilidad e importancia que tiene en nuestra vida
y en nuestro desarrollo académico, también cuenta con el objetivo de aprender los
diversos materiales electrónicos que se utilizan en los diferentes ejercicios, a través
de esta primera practica aprenderemos a:

 Activar una salida digital

 Encender un led en ON/OFF
 Temporizar una señal de salida
 Sintaxis de un programa en Arduino

Cablear un circuito

Condicional If/else

Estado de un pulsador

Leer una entrada digital y escribir una salida digital

Manejar una entrada digital

Ver datos por la pantalla del computador

Consola serial

Leer una entrada digital y escribir por consola serial

Manejar una entrada análoga

Ver datos por la pantalla del computador
Múltiples estados de un potenciómetro
Leer una entrada análoga
 Introducción

Arduino es una plataforma de creación de electrónica de código abierto, la cual está

basada en hardware y software libre, flexible y fácil de utilizar para los creadores y
desarrolladores. Esta plataforma permite crear diferentes tipos de
microordenadores de una sola placa a los que la comunidad de creadores puede
darles diferentes tipos de uso.

El Arduino es una placa basada en un microcontrolador ATMEL. Los

microcontroladores son circuitos integrados en los que se pueden grabar
instrucciones, las cuales las escribes con el lenguaje de programación que puedes
utilizar en el entorno Arduino IDE. Estas instrucciones permiten crear programas
que interactúan con los circuitos de la placa. El microcontrolador de Arduino posee
lo que se llama una interfaz de entrada, que es una conexión en la que podemos
conectar en la placa diferentes tipos de periféricos. La información de estos
periféricos que conectes se trasladará al microcontrolador, el cual se encargará de
procesar los datos que le lleguen a través de ellos.

El tipo de periféricos que puedas utilizar para enviar datos al microcontrolador

depende en gran medida de qué uso le estés pensando dar. Pueden ser cámaras
para obtener imágenes, teclados para introducir datos, o diferentes tipos de
sensores.

También cuenta con una interfaz de salida, que es la que se encarga de llevar la
información que se ha procesado en el Arduino a otros periféricos. Estos periféricos
pueden ser pantallas o altavoces en los que reproducir los datos procesados, pero
también pueden ser otras placas o controladores.

Dentro de este reporte encontraremos los diferentes ejercicios realizados

correspondientes a la materia de Programacion de Perifericos.
 Materiales y Métodos
Para realizar los ejercicios se utilizaran los siguientes materiales:
 Arduino Mega 2560
 Cable USB tipo AB
 Un led
 Protoboard
 Resistencia
 Conectores MM

1. En la primera actividad conectamos nuestra respectiva placa y la

configuramos en nuestra plataforma Arduino IDE y seguimos los pasos
mencionados en el pdf de las actividades.

En el primer ejercicio colocamos nuestro led en el pin 13 y el GND que se

encuentran conectados directo a un led que se identifica como L.
Después entramos a la configuración de Blink donde encontraremos la
programación respecto a ese led y al pin 13, después de esto se observa la
fincion Digitalwrite (13 Hight) delay (1000) esto quiere decir que en el pin
13 la función enciende el led durante un segundo.
Debajo encontramos nuevamente la función Digitalwrite(13,low) delay
(1000) esto quiere decir que aquí la función apaga el led después de un
segundo y se mantiene constante (enciende y apaga).

2.A) En este ejercicio encontramos que es similar al ejercicio numero 1 la

diferencia es que se requiere que el led encienda y apague cada 3 segundos,
es decir mantener el led encendido 3 segundos y mantenerlo apagado 3
segundos para esto requerimos las mismas funciones solo que en ocupar
1000 mili segundos que sabemos que es un segundo ocupamos 3000 mili
segundos que es igual a tres segundos en conclusión las finciones quedarían
como Digitalwrite (13 Hight) delay (3000) y Digitalwrite(13,low) delay
(3000).

2. B) Este ejercicio lo encontramos también similar solo cambia el tiempo de

encendido y apagado tenemos que mantenerlo encendido por 200 mili
segundos y apagado por 500 mili segundos ¿Cómo lo realizamos? pues en
nuestras funciones Digitalwrite (13 Hight) delay (¿?) dentro del paréntesis
colocamos el tiempo de encendido del led en este caso tenemos marcado
200 nos quedaría como Delaywrite (13hight) delay(200) y
Digitalwrite(13,low) delay (500).
Ejercicio 2.
En este problema nos pide realizar un circuito donde nuestro led se
mantenga intermitente dos segundos prendido y un segundos apagado.
Para esta actividad tenemos conocimientos sobre los ejercicios anteriores
para esto utilizaremos una protoboard donde colocaremos nuestro led
acompañado de una resistencia para la disminución de su voltaje, nos pide
conectarlo obligatorio al pin numero 5 después de esto conectamos el
siguiente cable al puerto GND y la colocamos en nuestra protoboard ahí se
inserta e led y su resistencia en nuestra plataforma Arduino IDE
seleccionamos en nuevo y en void loop hacemos las fnciones a realizar en
este caso colocamos Digitalwrite (5Hight)delay (2000), Digitalwrite(5,low)
delay (1000). con esto tendremos a nuestro del intermitente.

Ejercicio 3.
En este ejercicio nos habla acerca de los Strober como sabemos son luces
que se utilizan comúnmente en fiestas y eventos de iluminación artificial, nos
pide realizar uno con nuestros conocimientos ya adquiridos, para realizarlo
sabemos que es el mismo procedimiento, solo debemos cambiar los mili
segundos en este ejercicio se programaron las funciones en void loop
Digitalwrite (13Higth)delay(100) y Digitalwrite(13,low)delay(100) estra
función programa nuestro led para encender y apagar durante 0.1 segundo
haciendo la función de un strober.
 Resultados y Discusión
A continuación se encuentran los resultados de las practicas realizadas, como
sabemos estas prácticas están familiarizadas a las mismas funciones sabemos que
para encender y apagar nuestro les utilizamos el Higth que es encendido y el Low
que es apagado en nuestra plataforma arduino colocamos en la funcion de void loop
lo que queremos programar en este caso encender y apagar nuestro led,para llevar
a cabo esto se utiliza la funcion Digitalwrite(13Higth)delay(100).
Digitalwrite: Estructura principal (nunca se elimina ya que de lo contratrio nos
marcara error en nuestra programación)
13: es el número del puerto al que se encuentra conectado uno de los conectores
MM el otro conector debería estar conectado al GND (Tierra)
Higth: Es la función de ENCENDIDO
Delay: significa retrasar
Low: Es la función de APAGADO
100: son los mili segundos que queremos retrasar

Ejercicio Ejemplo 1.

Para realizar el primer ejercicio debemos utilizar los siguientes materiales:

 Arduino Mega 2560
 Cable tipo USB tipo AB
 Led Azul
 Protoboard
Lo primero que debemos realizar es conectar nuestra tarjeta Arduino mega
2560 a un puerto usb de nuestra computadora, posteriormente abrimos el
programa de Arduino IDE ya instalado en nuestro dispositivo.

A continuación entraremos a herramientas y vamos a seleccionar en el

programa nuestro tipo de tarjeta, en este caso seleccionaremos la opción
Arduino mega or mega 2560, después de esto seleccionamos el puerto al
que se encuentra conectado nuestra tarjeta Arduino, en nuestro caso se
encuentra conectada al puerto COM 4.

Ya finalizado seleccionamos la opción de nuevo proyecto y comenzamos a

programar lo que nos pide nuestro ejercicio.
Inciso A)

void setup()
{
pinMode(13,OUTPUT);
}

void loop()
{
digitalWrite(13,HIGH);
delay(3000);
digitalWrite(13,LOW);
delay(3000);
}
Inciso B)

void setup()
{
pinMode(13,OUTPUT);
}

void loop()
{
digitalWrite(13,HIGH);
delay(200);
digitalWrite(13,LOW);
delay(500);
}
Ejercicio 2.

void setup()
{
pinMode(13,OUTPUT);
}

void loop()
{
digitalWrite(13,HIGH);
delay(2000);
digitalWrite(13,LOW);
delay(1000);
}
Ejercicio 3.

void setup()
{
pinMode(5,OUTPUT);
}

void loop()
{
digitalWrite(5,HIGH);
delay(100);
digitalWrite(5,LOW);
delay(100);
}
Practica 1 – T2
 Materiales y Métodos
Materiales:

 Arduino mega 2560

 Protoboard
 Un led
 Conectores MM
 Cable USB tipo AB
 Recistencias
 2 pulsores

Ejercicio 1.

Al realizar la primera practica se utilizan las siguientes configuraciones en el

Arduino IDE, como sabemos debemos encender nuestro led cada que
presionemos el pulsor lara ello conectamos nuestro led en el pin 13 a través de la
protoboard hacemos la conexión del pulsor con su respectiva resistencia después
de esto cerramos nuestro circuito, para la programación utilizamos las
programaciones del void setup dentro de esta se ejecutan funciones cada que el
Arduino se inicia colocamos debajo de esta pinMode(pulsador, INPUT); que
configura nuestro pulsador como una entrada, y pinMode(led,OUTPUT); que
configura nuestro Led como una salida.
En el Void loop que sabemos que esta función se mantiene ejecutando cuando el
Arduino está conectado en esta función esbribimos (digitalRead(pulsador)==HIGH)
este se utiliza para saber el estado de nuestro pulsador, digitalWrite(led,HIGH);
con este ordenamos que nustro led se encianda cada que apretemos el pulsador
//Pulsador NO oprimido digitalWrite(led,LOW); mantiene nuestro led apagado es
muy fácil identificar las funciones ya que colocamos las funciones detalladas que
realiza cada configuración.
Ejercicio 2.
Para el ejercicio numero 2 lo encontramos algo similar la única diferencia es que
utilizamos 2 pulsadores y nuestro led debe de encender solo cuando presionemos
nuestros dos pulsadores, debemos ser cuidadosos ya que si presionamos un
botón y enciende el les quiere decir que está mal reiteremos nuevamente que el
led debe de encender solo si se presionan los dos botones al mismo tiempo.
Para llevar este tipo de programación es necesario utilizar las funciones
void setup() Funciones que se ejecutan una sola vez

pinMode(pulsador, INPUT); Pulsador presionado led encendido

pinMode(led,OUTPUT); pulsador sin oprimir led apagado

void loop() Funciones que se ejecutan cunado el Arduino se encuentra energizado

if (digitalRead(pulsador)==HIGH) pulsador oprimido led encendido

digitalWrite(led,HIGH); pulsador sin oprimir led apagado

Ejercicio 3.
Para este ejercicio nos pide simular los apagadores de escalera nos pide que al
encender un botón encien da el led y al presionar el segundo botos también
encienda. La programación queda de esta manera:
void setup() -Aquí podemos ver que en la funciones que se ejecutan
{ Una sola vez.
pinMode(2,INPUT);
pinMode(13,INPUT);
pinMode(3,INPUT);
}
void loop() - Funciones que se realizan cada que el aurduino se
encuentra energizado.
{
while(digitalRead(2))
{digitalWrite(13,HIGH); Aquí observamos que dentro del pin 13 se le ordena
Que encienda y apague
digitalWrite(13,LOW);
}
while(digitalRead(3)) Ocurre lo mismo pero en un canal diferente
{digitalWrite(13,HIGH);
digitalWrite(13,LOW);
 Resultados y Discusión
Para las actividades del T2 observamos que eran similares la diferencia de estas
es que en una de ellas utilizamos 2 pulsadores y al presionar los dos nuestro led
se encendía los códigos son algo idénticos y es muy fácil determinar sus funciones
en el software Arduino IDE
 Practica 1 ejemplo

int pulsador=2;

int led=13;

void setup()

pinMode(pulsador, INPUT);

pinMode(led,OUTPUT);

void loop()

if (digitalRead(pulsador)==HIGH)

digitalWrite(led,HIGH);

else

//Pulsador NO oprimido

digitalWrite(led,LOW);

}
void setup()

pinMode(2,INPUT);

pinMode(13,INPUT);

pinMode(3,INPUT);

void loop()

while(digitalRead(2))

if (digitalRead(3))

{digitalWrite(13,HIGH);

digitalWrite(13,LOW);

}
Practica 3

Tu padre quiere que realices un sistema de iluminación LED para las escaleras de la casa. La
condición es que si estás arriba y pulsas a S1 o si estás abajo y pulsas S2 el LED Rojo se enciende y al
dejar de pulsar se apaga. Como guía de montaje toma la imagen anterior

void setup()

pinMode(2,INPUT);

pinMode(13,INPUT);

pinMode(3,INPUT);

void loop()

while(digitalRead(2))

{digitalWrite(13,HIGH);

digitalWrite(13,LOW);

while(digitalRead(3))

{digitalWrite(13,HIGH);

digitalWrite(13,LOW);

}
Practica 1 – T3
 Materiales y Métodos
Materiales:

 Arduino mega 2560

 Protoboard
 Un led
 Conectores MM
 Cable USB tipo AB
 Recistencias
 2 pulsores

Ejercicio 1 T3
En el ejercicio número uno nuestro problema nos pide realizar un circuito que
simule el proceso de llenado y sellado de un embace de refresco para esto
sabemos que cuando el embace se encuentre lleno nuestro led debe de encender
al presionar el pulsor S1 y posteriormente debe de encender nuevamente
simulando el sellado del envase a través del pulsor S2.
Para la programación de esta actividad sabemos que en nuestras funciones
debemos colocar nuestras variables las cuales determinaran si es verdadero o
falso la programación del llenado y sellado del envase.
Colocamos los pines a los que se encuentran conectados nuestros dispositivos
electrónicos, dentro de nuestra función Void setup especificamos que el nuestros
pulsadores 2 y 3 se encuentran en funciones de entrada y en nuestro led 13 que
es nuestro indicador contaremos con una función de salida.
Debajo de esta se escribe el valor del comienzo serial en este caso 9600
En la funcion Void loop agragamos que nuestra lectura digital en el pulsador S2 se
encuentra apagado también declaramos que el estado nuemero 1 es falso
A continuación se realiza la programación de las funciones de gaseosa llena y
gaseosa tapata para esto especificamos correctamente las funciones con los
respectivos pulsadores S1 y S2
Ejercicio 2 T3
Para el ejercicio número 2 se pide realizar la programación de unas luces
navideñas para esto sabemos que cada que presionemos nuestro pulsador S1 el
led debe de encender y la variable que comienza desde 0 debe de incrementar de
20 en 20 y al momento de presionar el pulsador S2 el valor de la variable debe de
cambiar a un “Hola mundo” la explicación del sistema de programación se
encuentra escrita en los resultados y Discusión es muy fácil de entender e
interpretar

Resultados y Discusión
Ejercicio ejemplo 1
//Declaramos los botones y sus pines de entrada, asi como el led y su pin de salida

const int s1 = 13, s2 = 12, led = 11;

// Declaramos la variable que se incrementara en 20 con el boton s1 pulsado

// Tambien declaramos la variable que da el tiempo de intermitencia del led

long variable = 20, intermitencia =1000;

// Declaramos la rutina del led

// Enciende - espera un tiempo encendido - Apaga - espera un tiempo apagado

void hola_mundo(){

digitalWrite(led, HIGH);

delay(intermitencia);

digitalWrite(led, LOW);

delay(intermitencia);

void setup() {

//Usamos los numeros de los pines para oficialmente declararlos como entradas y salidas

pinMode(s1,INPUT);

pinMode(s2,INPUT);

pinMode(led,OUTPUT);

//Inicializamos tambien el puerto serial,

//con una velocidad por defecto de 9600(Esto es una convencion, por que en realidad hay otras
velocidades)

//Esto se usa para poder imprimir en el puerto serial

Serial.begin(9600);

void loop() {

//imprimimos el valor de la variable

Serial.println(variable);

//Leemos el estado actual de los pines

bool lectura_s1 = digitalRead(s1);

bool lectura_s2 = digitalRead(s2);

// Cuando ambos botones son pulsados, se devuelve la variable a cero

if (lectura_s1 && lectura_s2){

variable = 20;

// Te doy un segundo para que apretes los botones, osea, sueltalos antes de un segundo

// Esto lo hago por que una vez que la variable se ponga en cero, y no quitas los dedos exactamente al
mismo tiempo,

//es posible que termines activando algunas de las otras dos condiciones sin querer

delay(1000);

// Cuando el boton s1 es pulsado, empieza a incrementar de 20 en 20 la variable

else if(lectura_s1){

variable += 20;

// Cuando se pulsa s2 cargarmos el valor actual que tenga la variable

// Para que se actualice el tiempo de intermitencia del led

else if(lectura_s2){

intermitencia = variable;

// Ejecutamos la rutina del led que declaramos arriba

hola_mundo();
Practica 1 – T4
 Materiales y Métodos

Materiales:

 Arduino Mega 2560

 Protoboard
 Conectores MM
 Cables USB tipo AB
 Potenciometro
 Contador de 7segmentos
 Resistencias

Ejercicio 1 T4.
El siguiente ejercicio consiste en mostrar a través de una consola serial un número
entre el 0 y el 10 y esta debe cambiar cada que se mueva nuestro potenciómetro.
Para realizar esto debemos de conectar nuestros componentes dentro de nuestra
protoboard como sabemos el potenciómetro cuenta con una salida analógica la
cual nos ayudara a controlar el contador de 7 segmentos para comprender el
contador debemos de saber cómo funciona para esto se utiliza su diagrama así
nos facilita la ejecución y función del contador.
Dentro del software arduino colocamos correctamente todos los pines que
estamos utilizando dentro de nuestra protoboard posteriormente en la funcion Void
Loop colocamos cada uno de los números que se pueden programar dentro de
nuestro contador de 7 segmentos, como nos muestra en el diagrama cada led se
identifica con una letra del abecedario.
Se colocan las estructuras digitales para este caso se colocan ocho estructuras
digitales en cada una de estas se le ordena al led si debe de encender o apagarse
esto se realiza a través de los comandos Higth( encendido), Low (apagado), a
travez de este proceso se programa cuales led deben de encender para asi formar
losnumeros
 Resultados y Discusión

Ejemplo ejercicio 1
int a=2;
int b=3;
int c=4;
int d=5;
int e=6;
int f=7;
int g=8;

void setup()
{
Serial.begin(9600);
pinMode(a,OUTPUT);
pinMode(b,OUTPUT);
pinMode(c,OUTPUT);
pinMode(d,OUTPUT);
pinMode(e,OUTPUT);
pinMode(f,OUTPUT);
pinMode(g,OUTPUT);
}
void loop()
{
int pote=analogRead(A0);

if(pote>=0&&pote<102)
{
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH); //número:0
digitalWrite(e,HIGH);
 digitalWrite(f,HIGH);
digitalWrite(g,LOW);
}
if(pote>=102&&pote<204)
{
digitalWrite(a,LOW);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,LOW); //número:1
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
}
if(pote>=204&&pote<306)
{
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,LOW);
digitalWrite(d,HIGH); //número:2
digitalWrite(e,HIGH);
digitalWrite(f,LOW);
digitalWrite(g,HIGH);
}
if(pote>=306&&pote<408)
{
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH); //número:3
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,HIGH);
}
if(pote>=408&&pote<510)
{
digitalWrite(a,LOW);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,LOW); //número:4
digitalWrite(e,LOW);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
}
if(pote>=510&&pote<612)
{
digitalWrite(a,HIGH);
digitalWrite(b,LOW);
digitalWrite(c,HIGH); //número:5
digitalWrite(d,HIGH);
digitalWrite(e,LOW);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
}
if(pote>=612&&pote<714)
{
digitalWrite(a,HIGH);
digitalWrite(b,LOW);
digitalWrite(c,HIGH); //número:6
digitalWrite(d,HIGH);
digitalWrite(e,HIGH);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
}
if(pote>=714&&pote<816)
{
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,LOW); //número:7
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW); if(pote>=816&&pote<918)
{
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH); //número:8
digitalWrite(e,HIGH);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
}
if(pote>=918&&pote<1023)
{
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH); //número:9
digitalWrite(e,LOW);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
 Código Ejercicio 2 T4

int sensorPin=A0;
int sensorValue=0;
void setup()
{
pinMode(4,INPUT);
Serial.begin(9600);
}
void loop()
{
sensorValue=analogRead(sensorPin);
Serial.println(sensorValue);
delay(150);

if(sensorValue>=705&&sensorValue<=725)
if(digitalRead(4)==LOW)
{
Serial.println("Adivinaste el numero");
delay(5000);
}
if (sensorValue>0&&sensorValue<1023)
if (digitalRead(4)==LOW)
{
Serial.println("Intenta de nuevo");
delay(2500);
}
}
 Conclusión

Sabemos que Arduino es un instrumento muy útil en nuestra vida como estudiantes
de ingeniería en mecatronica, aparte de aprender también nos divierte y nos da
curiosidad interactuar con este dispositivo, durante el desarrollo de las diferentes
practicas fuimos muy conscientes de la complejidad que se lleva al realizar los
ejercicios y lo divertido que puede ser, sin embargo fue de mucho aprendizaje para
los alumnos el interactuar por primera vez con este equipo de Arduino, se plantean
diferentes actividades a lo largo del ciclo con el objetivo de que los alumnos
aprendan a programar y saber manipular el software arduino y los diversos
componentes electrónicos, al realizar los reportes nos ayuda ya que representamos
todo lo que realizamos a lo largo de la práctica.
 UNIVERSIDAD POLITÉCNICA DEL CENTRO
Lista de cotejo de prácticas

Nombre del alumno:_______________________________________________ Fecha: 07/09/2020

Ingeniería en Mecatrónica - Cuatrimestre 4 grupo 2 - Materia: Programación de Periféricos
Revisar las actividades que se solicitan y marque en los apartados “Sí” cuando la evidencia se cumple; en caso contrario “No”. En
la columna “OBSERVACIONES” indicaciones que puedan ayudar al alumno a saber cuáles son las condiciones no cumplidas, si
fuese necesario.
Valor del Característica a cumplir (Reactivo) Cumple Observaciones
Sí no
5% Portada: El trabajo cuenta con portada que
incluye los siguientes requisitos:
Logo UPC, nombre completo de la Universidad,
fecha de entrega, nombre del trabajo, nombre del
alumno, nombre de la materia, grupo, nombre de
carrera.
5% Objetivo: Redacta el objetivo del reporte.
10% Introducción: Revisión documental que sustenta el
marco teórico de la actividad.
5% Materiales y métodos: Detalla la metodología
realizada y los materiales utilizados.
40% Resultados y discusión. Resume y presenta los
resultados de la actividad práctica, discute los
mismos y presenta la explicación del código.
20% Conclusión. Resume y presenta los resultados de la
actividad práctica.
5% Bibliografía. En formato APA.
5% Entrega a tiempo, en la fecha solicitada.
5% El reporte esta ordenado, limpio y sin faltas de
ortografía.
100% Calificación

Dr. José Ney Garrido Vázquez

PROFESOR DE LA ASIGNATURA