Vous êtes sur la page 1sur 36

UNIVERSIDAD POLITÉCNICA

DEL CENTRO

Portafolio de Evidencias

Matricula - Nombre del Alumno


002379-Jose Armando Ascencio Cornelio

Asignatura
Programacion de Perifericos

Profesor
Pablo Perez Lopez

Cuatrimestre: 4

Grupo: 4-1

e-mail: armandoascencio.01@gmail.com

23 de noviembre de 2017
1. ENCUADRE (MAX. 3 HOJAS)
Colocar el encuadre de la materia que le proporciono el profesor, donde estuvo de
acuerdo con las políticas de la asignatura.

2. EVALUACIÓN DIAGNÓSTICA (2 hojas)


 Incluir escaneado su evaluación diagnóstica realizada, con el resultado obtenido
 Incluir en una tabla las recomendaciones (temas a reforzar) que le realizó el
profesor.

3. INFORMACIÓN DE UNIDADES DE APRENDIZAJE


 Se colocará un separador en una hoja que indique el inicio de cada unidad.

UNIDAD I

“NOMBRE”

 Listado de evidencias que se aplicaron en dicha unidad.


 Escanear Instrumento de evaluación (calificados) aplicada a cada evidencia
(rúbricas, lista de cotejos, etc.).

4. AUTOEVALUACIÓN DEL APRENDIZAJE


 Describir los resultados alcanzados durante el curso.
 Describir los temas no cubierto por diversos motivos o aprendizajes no
logrados si es el caso.
 Observaciones o recomendaciones para mejorar el curso.
UNIVERSIDAD POLITÉCNICA DEL CENTRO
ENCUADRE
Fecha: 18/09/2017

Programa Educativo Periodo


Ing. Mecatrónica Septiembre - Diciembre 2017

Cuatrimestre, grupo Asignatura


4,M1 Programación de Periféricos

PLANTEAMIENTO
El alumno será capaz de usar lenguajes de instrumentación virtual que permitan el uso de instrumentos y la conexión de los mismo s
Objetivo de la asignatura
por medio de tarjetas de adquisición de datos comerciales.

Competencias genéricas a
Análisis, trabajo en forma autónoma y en equipo, resolución de problemas, aplicar conocimientos en la práctica
desarrollar

PROGRAMA DE ESTUDIO
Unidades de aprendizaje Horas
Teórico P
Resultados de aprendizaje Evidencias r
á
c
t
i
c
a

Al completar la unidad de aprendizaje, el alumno será capaz de:


I. Interfaces de entrada y salida Identificar las interfaces E/S usadas en los dispositivos EC1 Tabla comparativa entre las diferentes tarjetas de programación.
periféricos. 1
04/09/2017 EP1: Elaborar codificación de ejercicios propuestos. 2
Identificar el entorno de desarrollo de arduino. 5
02/10/2017 EP2: Elaborar codificación de la solución de casos prácticos

II. Programación de interfaces de entrada Al completar la unidad de aprendizaje, el alumno será capaz de:
y salida Identificar el entorno de la programación.
02/10/2017 Conocer las diferentes librerias de los componentes arduino. 1
EP1: Elaborar codificación de ejercicios propuestos. 2
30/10/2017 Identificar el uso de la programación. 5

III. Sistemas de adquisición de datos y Al completar la unidad de aprendizaje, el alumno será capaz de:
control Analizar los componentes que permiter recabar información. 1
Identificar las partes digitales y análogicas de arduino y sus
EP1: Elaborar codificación de ejercicios propuestos. 2
30/10/2017 6
06/12/2017 componentes.
SUBTOTAL 6 4
6
TOTAL
52

EVALUACIÓN
Evidencias de Conocimiento Conceptos teóricos, principios, técnicas y metodologías de los diferentes temas presentados e investigados a lo largo del
(EC) 30% curso.
Evidencias de Producto (EP) 60%
Revisión de la producción terminal de objetos y/o presentación de elementos acabados y resultado de producto esperado.
Evidencias de Actitud (EA) 10% Asistencia, entrega de trabajos en tiempo y forma, trabajo en equipo, orden, limpieza, honestidad, disciplina, respeto, etc. Esta
evidencia se considera en todas las unidades.
Nota 1 La calificación final de cada unidad de aprendizaje será un promedio o bien una suma ponderada de las evidencias que la integran.

Nota 2 Una unidad de aprendizaje se considera aprobada si y solo si todas las evidencias que la integran tienen una calificación aprobatoria

En caso de NO ACREDITAR una evaluación parcial se aplicará lo establecido en el CAPÍTULO II Recuperación de Evidencias,
Nota 3
Art. 30, del Lineamiento Interno de Alumnos de la UPC.
La calificación final de la asignatura será un promedio o bien una suma ponderada de las calificaciones asignadas a cada unidad de
aprendizaje que se haya acreditado.
Nota 4 Nota: la comprensión de los aspectos tratados en las clases, son parte integral de la evaluación del curso, es responsabilidad del alumno
poner la debida atención. Así mismo, las asesorías son para aclarar dudas, no se repetirla por ningún motivo, razón o circunstancia
alguna sesión de clases.

BIBLIOGRAFÍA
BÁSICA COMPLEMENTARIA

TÍTULO: El gran libro del PC interno TÍTULO: Programación Gráfica para Ingenieros
AUTOR: DURAN, Lluís, (aut.) AUTOR: MOLINA Martínez, José Miguel Y Jiménez BUENDÍA, Manuel
EDITORIAL O REFERENCIA: MARCOMBO EDITORIAL O REFERENCIA: MARCOMBO
LUGAR Y AÑO DE LA EDICIÓN 2007 LUGAR Y AÑO DE LA EDICIÓN 2010
ISBN O REGISTRO: ISBN: 8426714250 ISBN-13: 9788426714251 ISBN O REGISTRO: 9788426716767

TÍTULO: C++ Como Programar TÍTULO: Labview: Entorno gráfico de programación


AUTOR: DEITEL Harvey M. Y Deitel Paul AUTOR: LAJARA Vizcaíno, José Rafael; Pelegrí Sebastià, José, (aut.)
EDITORIAL O REFERENCIA: PEARSON EDITORIAL O REFERENCIA: MARCOMBO
LUGAR Y AÑO DE LA EDICIÓN 2008 LUGAR Y AÑO DE LA EDICIÓN 2007
ISBN O REGISTRO: 9702-612-73X

LINEAMIENTOS A CUMPLIR
1. Ser alumno inscrito de la Universidad.
2. Asistir puntualmente a las sesiones de clase establecidas en los horarios formulados por la Universidad, con los
instrumentos y materiales necesarios para el buen desarrollo de las mismas.
3. Deberá cumplirse con el 80% de asistencias en todas y cada una de las unidades de la asignatura, de lo contrario
no se otorgará calificación de la unidad en que incurra la inasistencia, sea esta aprobatoria o no, debiendo remediar la
situación conforme lo indicado en el punto anterior.
4. Justificar inasistencia con documento oficial, emitido por el departamento de Servicios Escolares, el cual deberá
Para la Asignatura. presentarlo el día posterior inmediato a la falta.
5. Queda prohibido hacer uso de teléfonos celulares, dispositivos electrónicos, así como de cualquier otro dispositivo
de audio y video durante la clase. El uso de computadoras personales y laptops queda restringido a menos que la clase lo
requiera.
6. Durante la estancia en el aula de clases se deberá mantener el orden absteniéndose de: fumar, introducir bebidas
y alimentos, utilizar gorras, dormir, silbar, tocar instrumentos musicales o cualquier otra actividad que entorpezca el
desarrollo de la sesión.
7. Promover el trato amable y respetuoso entre las compañeras (os) y hacia el profesor.
Para mis compañeros y
8. Toda falta de orden, respeto o disciplina considerada como grave será sancionada por un comité especialmente
profesor. formado para tal efecto.
Para la Institución y
9. Debe cuidar la integridad y limpieza de las instalaciones de la Universidad. personal de Apoyo.

10. Cumplir con lo estipulado en el lineamiento interno de alumnos de la Universidad Politécnica del Centro.
11. Participar activamente durante y fuera de las sesiones de clase y en todos los trabajos relativos a la materia.
Para mi persona
12. Ser promotor de conocimiento al propiciar el aprendizaje, personal y grupal, al aportar conocimientos anteriores e
ideas de mejora, siempre que estas estén asociadas al tema en estudio.

Y las que se deriven del Reglamento del alumno.


Recomendación de material didáctico:
Bibliografía propuesta o documentación acerca del tema.
UNIDAD 1 “Interfaces de entrada y salida”
UNIVERSIDAD POLITÉCNICA DEL CENTRO
RUBRICA PARA EVALUAR EJERCICIOS DE LA UNIDAD 1

Programa Educativo Periodo


Ing. Mecatrónica Septiembre - Diciembre 2017

Cuatrimestre, grupo Asignatura


4,M1 Programación de Periféricos

EXCELENTE BUENO REGULAR DEFICIENTE


ELEMENTOS
2.5 puntos 2 puntos 1.5 puntos 1 punto

Presenta menos del 50%


Presenta la totalidad de Entrega más del 80% de Presenta más del 60% de
EJERCICIOS de los ejercicios a
ejercicios a resolver. los ejercicios a resolver los ejercicios a resolver.
resolver.

Refleja un razonamiento
sin orden, puede hacer los
Refleja un razonamiento Refleja un razonamiento
ejercicios pero no explica
detallado y ordenado, sin orden, puede hacer los
la manera en que los No refleja ningún
utilizando el proceso ejercicios pero no explica
resolvió. Cuando los hace razonamiento, resuelve
PROCEDIMIENTO adecuado, siguiendo los la manera en que los
utiliza el proceso los ejercicios de manera
pasos para resolver los resolvió. Utiliza otro
adecuado, siguiendo los mecánica.
ejercicios de manera proceso obteniendo un
pasos para resolver los
correcta. resultado razonable
ejercicios de manera
correcta.
Presenta 80% ó más Presenta 60 % ó más
Presenta el resultado resultados correctos, resultados correctos,
Presenta 50% o menos
obtenido de los ejercicios comete algunos errores comete algunos errores
resultados correctos, no
RESULTADOS y es correcto. Puede debido a cálculos debido a cálculos
sigue el procedimiento
corroborarlo dándole erróneos, utiliza el erróneos, y un proceso
adecuado
sentido proceso adecuado y sigue inadecuado, se salta los
los pasos para resolverlo. pasos para resolverlo.

TOTAL 10 puntos 8 puntos 6 puntos 4 puntos


//CODIGO//

int led=13;
void setup (){
pinMode(13,OUTPUT);
}
void loop (){
digitalWrite(led,HIGH);
delay(1000);
digitalWrite(led,LOW);
delay(1000);
}
int sensor = 0;
void setup() {
Serial.begin(9600);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
}
void loop() {
int valor = analogRead(sensor);
Serial.print (valor);
Serial.println("C");
if (valor<=40 ){
Serial.print(" Normal ");
digitalWrite(2,HIGH);
digitalWrite(3,LOW);
digitalWrite(4,LOW);
digitalWrite(5,LOW);
delay(1000);
}
if (valor>40 && valor <=80 ){
Serial.print(" Alta ");
digitalWrite(2,LOW);
digitalWrite(3,HIGH);
digitalWrite(4,LOW);
digitalWrite(5,LOW);
delay(1000);
}
if (valor>80 && valor<120 ){
Serial.print(" Alta media ");
digitalWrite(2,LOW);
digitalWrite(3,LOW);
digitalWrite(4,HIGH);
digitalWrite(5,LOW);
delay(1000);
}
if (valor>120 ){
Serial.print(" Extrema ");
digitalWrite(2,LOW);
digitalWrite(3,LOW);
digitalWrite(4,LOW);
digitalWrite(5,HIGH);
delay(1000);
}
}

int sensor = 0; int valor = map(value);


int potenciometro = 0; //analogRead(sensor);
void setup() { Serial.print (valor);
Serial.begin(9600); Serial.println("C");
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(4,OUTPUT); if (valor<=40 ){
pinMode(5,OUTPUT); Serial.print(" Normal ");
} digitalWrite(2,HIGH);
void loop() { digitalWrite(3,LOW);
int value = digitalWrite(4,LOW);
analogRead(potenciometro); digitalWrite(5,LOW);
int position = map(value); delay(1000);
delay(1000); }
if (valor>40 && valor <=80 ){
Serial.print(" Alta "); delay(1000);
digitalWrite(2,LOW); }
digitalWrite(3,HIGH); if (valor>120 ){
digitalWrite(4,LOW); Serial.print(" Extrema ");
digitalWrite(5,LOW); digitalWrite(2,LOW);
delay(1000); digitalWrite(3,LOW);
} digitalWrite(4,LOW);
if (valor>80 && valor<120 ){ digitalWrite(5,HIGH);
Serial.print(" Alta media "); delay(1000);
digitalWrite(2,LOW); }
digitalWrite(3,LOW); }
digitalWrite(4,HIGH);
digitalWrite(5,LOW);
//RGB Y POTENCIOMETRO int ia; //Intensidad led azul
int lr=1; //Led rojo pin 1 int iv; //Intensidad led verde
int la=2; //Led azul pin 2
int lv=3; //Led verde pin 3 void setup(){
int pt = A0; //Potenciometro pin A0
int pt2 = A1; // Potenciometro 2 pin A1 pinMode (lr,OUTPUT);
int pt3= A2; pinMode (la,OUTPUT);
pinMode (lv,OUTPUT);
int vpt=0; // Valor que adquiere el
potenciometro }
int vpt2=0; //Valor que adquiere el
potenciometro2 void loop(){
int vpt3=0;
int ir; //Intensidad led rojo
vpt= analogRead(pt); //Recolecta //parecido al
valor de entrada digitalWrite(led,HIGH);
ir = map(vpt,0,1023,0,255); //El valor
se mapea vpt2=analogRead(pt2);
//del pt 0 a 1023 a el ia=map(vpt2,0,1023,0,255);
valor RGB 0 a 255 analogWrite(la,ia);
// y se almacena el
digitalWrite vpt3=analogRead(pt3);
analogWrite(lr,ir); //Se manda a iv=map(vpt3,0,1023,0,255);
encender el led analogWrite(lv,iv);
// con el valor que tiene }
almacenado ir
#include <LiquidCrystal.h> // Libreria char separador[]="CFK"; //array para
utilizada para el lcd mostrar C F K en el LCD
int valores[]={0,0,0}; // array con
LiquidCrystal lcd(12,11,5,4,3,2); // se elementos declarados
declara lcd como, Liquidcrystal y los int g_c; //grados centigrados
pines de conexion en arduino int g_f; // grados fahrenheit
char datos[13]; // se declara array con int g_k; // grados kelvin
13 elementos
int posicion=0; //variable para indicar unsigned long tiempo_lcd; //variable
la posicion para almacenar valores
unsigned long tiempo; // variables
char*resultado=NULL; //variable para almacenar valores positivos
resultado si es nulo se convierte a
caracter
void setup() {
lcd.begin(16,2); // se inicia el lcd resultado=strtok(datos, separador);
Serial.begin(115200);// puerto de //convierte (strtok) valores numericos
comunicacion entre tarjetas arduino a caracter
delay(1000); //tiempo de espera
tiempo_lcd=millis(); //se convierta while((resultado!=NULL)&&(index<3))
tiempo a milisegundos {//mientras el resultado no sea nulo y
tiempo=millis(); // sean la posiciones
}
valores[index++]=atoi (resultado);

void loop() { resultado=strtok (NULL, separador);


boolean segmentacion; // variable //resultado sera igual a un array de
booleana para validar datos entre caracteristicas
tarjetas }
while(Serial.available()>0){ // ciclo segmentacion=false; //segmentacion
mientras se escribedesde teclado se cambia a falso
delay(5); //tiempo de espera }
datos[posicion]=Serial.read(); // se lee g_c=valores[0]; //grado c toma la
dato y se manda a LCD posicion 0
posicion++; // g_f=valores[1]; //grado f toma la
segmentacion=true; // se cambia la posicion 0
variable a verdadera g_k=valores[2]; // grado k toma la
} posicion 0
posicion=0; // se reinicaliza la variable
if((millis()-tiempo_lcd)>500){
if (segmentacion==true){ //condicion //condiciones entre tiempo
segmentacion igual a verdadero lcd.clear(); // se borra datos en
int index=0; //variable que pantalla lcd
almacenara valores del array lcd lcd.setCursor(0,1); // se posiciona el
cursor en columna 0 fila 1
lcd.print(g_c); //se imprime valores lcd.print("Temperatura normal");
de g_c //se impreme en lcd
lcd.print("C"); //se imprime caracter Serial.print("n"); // se imprime en
C consola
lcd.setCursor(6,1); // se posiciona el }
cursor en columna 6 fila 1 else if(g_c<20){ //condicion para
lcd.print(g_f);//se imprime valores de temperatura baja
g_f lcd.setCursor(0,0);// se posiciona el
lcd.print("F");//se imprime caracter f cursor en columna 0 fila 0
lcd.setCursor(12,1);// se posiciona el lcd.print("Temperatura baja");//se
cursor en columna 12 fila 1 imprime en lcd
lcd.print(g_k);//se imprime valores de Serial.print("b");//se imprime en
g_k consola
lcd.print("K");//se imprime caracter K }
tiempo_lcd=millis();//se iguala a else{
milisegundos lcd.setCursor(0,0);// se posiciona el
} cursor en columna 0 fila 0
lcd.print("Temperatura alta");//se
if((millis()-tiempo)>500){ imprime en lcd
//comparacion entre tiempo Serial.print("a");//se imprime en
consola
if((g_c>=20)&&(g_c<=25)){//condicion }
para temperatura normal tiempo=millis();// tiempo se iguala a
lcd.setCursor(0,0);//se posiciona el milisegundos
cursor en columna 0 fila 0 }
}

//T1: ARDUINO DONDE ESTA int sensor = A0; //Conexion del sensor
CONECTADO EL SENSOR al Arduino
int rojo=10; // Led rojo al pin 10 del tiempo=millis(); // Variable tiempo se
arduino inicializa en milisegundos
int verde=9; // Led verde al pin 9 del }
arduino
int amarillo=8; //Led amarillo al pin 8 void loop() {
de arduino vsensor=analogRead(sensor); // se lee
valores del sensor y se almacena
int vsensor=0; // Variable para guardar temperatura=vsensor*0.4899; //se
valores del sensor hace la conversion del valor
float temperatura=0; //Variable para almacenado
almacenar la temperatura
int g_c; //grados centigrados g_c=temperatura; //Temperatura en
int g_f; // grados fahrenheit Centigrados
int g_k; // grados kelvin g_f=(g_c*1.8)+32; // Conversion para
unsigned long tiempo; //Variable que grados F
almacena valores positivos g_k=(g_c*1.8)+273.15; //Conversion
para grados Kelvin

void setup() { if((millis()-tiempo)>500){ //Condicion


Serial.begin(115200); // puerto de entre el tiempo
comunicacion entre arduino (se le Serial.print(g_c); // Imprime valor
puede dar otro valor) almacenado
delay(1000); // tiempo de espera Serial.print("C"); // Imprime el
pinMode(rojo,OUTPUT); //indica el caracter C
tiempo de modo de led Serial.print(g_f); // Imprime valor
pinMode(verde,OUTPUT); // almacenado
"""""""""""""" Serial.print("F"); // Imprime el
pinMode(amarillo,OUTPUT); // caracter F
"""""""""" Serial.print(g_k); // Imprime el valor
almacenado
Serial.print("K"); // Imprime el digitalWrite(rojo,0); //se apaga led
caracter K rojo
tiempo=millis(); // Tiempo se iguala digitalWrite(verde,0); //se apaga led
a Milisegundos verde
} digitalWrite(amarillo,1); // se
enciende led amarillo
if(Serial.available()>0){ // Condicion }
que valida entrada de teclado if(datos=='n'){ // Condicion donde
int datos=Serial.read(); // Se declara datos es igual a "n"
variable de datos y se lee el valor digitalWrite(rojo,0); // se apaga led
if(datos=='a'){ // Condicion donde rojo
datos es igual a "a" digitalWrite(verde,1); // se enciende
digitalWrite(rojo,1); // se enciende led verde
led rojo digitalWrite(amarillo,0); // se apaga
digitalWrite(verde,0); // se apaga led led amarillo
verde }
digitalWrite(amarillo,0);//se apaga
led amarillo }
} }
if(datos=='b'){ // Condicion donde
datos es igual a "b"
//T1: ARDUINO DONDE ESTA char datos [13];
CONECTADO EL SENSOR int posicion=0;
#include <LiquidCrystal.h> char*resultado=NULL;
char separador[]="CFK";
int sensor = A0; //Conexion del sensor int valores[]={0,0,0};
al Arduino
int rojo=10; // Led rojo al pin 10 del
arduino unsigned long tiempo_lcd;
int verde=9; // Led verde al pin 9 del //unsigned long tiempo;
arduino
int amarillo=8; //Led amarillo al pin 8 int vsensor=0; // Variable para guardar
de arduino valores del sensor
LiquidCrystal lcd(12,11,5,4,3,2);
float temperatura=0; //Variable para vsensor=analogRead(sensor); // se lee
almacenar la temperatura valores del sensor y se almacena
int g_c; //grados centigrados temperatura=vsensor*0.4899; //se
int g_f; // grados fahrenheit hace la conversion del valor
int g_k; // grados kelvin almacenado
unsigned long tiempo; //Variable que
almacena valores positivos g_c=temperatura; //Temperatura en
Centigrados
g_f=(g_c*1.8)+32; // Conversion para
void setup() { grados F
lcd.begin(16,2); g_k=(g_c*1.8)+273.15; //Conversion
tiempo_lcd=millis(); para grados Kelvin
tiempo=millis();
if((millis()-tiempo)>500){ //Condicion
Serial.begin(115200); // puerto de entre el tiempo
comunicacion entre arduino (se le Serial.print(g_c); // Imprime valor
puede dar otro valor) almacenado
delay(1000); // tiempo de espera Serial.print("C"); // Imprime el
pinMode(rojo,OUTPUT); //indica el caracter C
tiempo de modo de led Serial.print(g_f); // Imprime valor
pinMode(verde,OUTPUT); // almacenado
"""""""""""""" Serial.print("F"); // Imprime el
pinMode(amarillo,OUTPUT); // caracter F
"""""""""" Serial.print(g_k); // Imprime el valor
tiempo=millis(); // Variable tiempo se almacenado
inicializa en milisegundos Serial.print("K"); // Imprime el
} caracter K
tiempo=millis(); // Tiempo se iguala
void loop() { a Milisegundos
}
digitalWrite(amarillo,0); // se apaga
if(Serial.available()>0){ // Condicion led amarillo
que valida entrada de teclado }
int datos=Serial.read(); // Se declara
variable de datos y se lee el valor
if(datos=='a'){ // Condicion donde }
datos es igual a "a"
digitalWrite(rojo,1); // se enciende boolean segmentacion;
led rojo while(Serial.available()>0){
digitalWrite(verde,0); // se apaga led delay(5);
verde datos[posicion]=Serial.read();
digitalWrite(amarillo,0);//se apaga segmentacion=true;
led amarillo }
} posicion=0;
if(datos=='b'){ // Condicion donde
datos es igual a "b" if (segmentacion==true){
digitalWrite(rojo,0); //se apaga led int index=0;
rojo resultado=strtok(datos, separador);
digitalWrite(verde,0); //se apaga led
verde while((resultado!=NULL)&&(index<3))
digitalWrite(amarillo,1); // se {
enciende led amarillo
} valores[index++]=atoi (resultado);
if(datos=='n'){ // Condicion donde
datos es igual a "n" resultado=strtok (NULL, separador);
digitalWrite(rojo,0); // se apaga led }
rojo segmentacion=false;
digitalWrite(verde,1); // se enciende }
led verde g_c=valores[0];
g_f=valores[1];
g_k=valores[2];
if((g_c>=20)&&(g_c<=25)){//condicion
if((millis()-tiempo_lcd)>500){ para temperatura normal
//condiciones entre tiempo lcd.setCursor(0,0);//se posiciona el
lcd.clear(); // se borra datos en cursor en columna 0 fila 0
pantalla lcd lcd.print("Temperatura normal");
lcd.setCursor(0,1); // se posiciona el //se impreme en lcd
cursor en columna 0 fila 1 Serial.print("n"); // se imprime en
lcd.print(g_c); //se imprime valores consola
de g_c }
lcd.print("C"); //se imprime caracter
C else if(g_c<20){ //condicion para
lcd.setCursor(6,1); // se posiciona el temperatura baja
cursor en columna 6 fila 1 lcd.setCursor(0,0);// se posiciona el
lcd.print(g_f);//se imprime valores de cursor en columna 0 fila 0
g_f lcd.print("Temperatura baja");//se
lcd.print("F");//se imprime caracter f imprime en lcd
lcd.setCursor(12,1);// se posiciona el Serial.print("b");//se imprime en
cursor en columna 12 fila 1 consola
lcd.print(g_k);//se imprime valores de }
g_k else{
lcd.print("K");//se imprime caracter K lcd.setCursor(0,0);// se posiciona el
tiempo_lcd=millis();//se iguala a cursor en columna 0 fila 0
milisegundos lcd.print("Temperatura alta");//se
} imprime en lcd
Serial.print("a");//se imprime en
if((millis()-tiempo)>500){ consola
//comparacion entre tiempo }
tiempo=millis();// tiempo se iguala a
milisegundos
}

2da Unidad “Programación de interfaces de entrada y


salida”
UNIVERSIDAD POLITÉCNICA DEL CENTRO
RUBRICA PARA EVALUAR EJERCICIOS DE LA UNIDAD 2
Programa Educativo Periodo
Ing. Mecatrónica Septiembre - Diciembre 2017

Cuatrimestre, grupo Asignatura


4,M1 Programación de Periféricos

EXCELENTE BUENO REGULAR DEFICIENTE


ELEMENTOS
2.5 puntos 2 puntos 1.5 puntos 1 punto

Presenta menos del 50%


Presenta la totalidad de Entrega más del 80% de Presenta más del 60% de
EJERCICIOS de los ejercicios a
ejercicios a resolver. los ejercicios a resolver los ejercicios a resolver.
resolver.

Refleja un razonamiento
sin orden, puede hacer los
Refleja un razonamiento Refleja un razonamiento
ejercicios pero no explica
detallado y ordenado, sin orden, puede hacer los
la manera en que los No refleja ningún
utilizando el proceso ejercicios pero no explica
resolvió. Cuando los hace razonamiento, resuelve
PROCEDIMIENTO adecuado, siguiendo los la manera en que los
utiliza el proceso los ejercicios de manera
pasos para resolver los resolvió. Utiliza otro
adecuado, siguiendo los mecánica.
ejercicios de manera proceso obteniendo un
pasos para resolver los
correcta. resultado razonable
ejercicios de manera
correcta.
Presenta 80% ó más Presenta 60 % ó más
Presenta el resultado resultados correctos, resultados correctos,
Presenta 50% o menos
obtenido de los ejercicios comete algunos errores comete algunos errores
resultados correctos, no
RESULTADOS y es correcto. Puede debido a cálculos debido a cálculos
sigue el procedimiento
corroborarlo dándole erróneos, utiliza el erróneos, y un proceso
adecuado
sentido proceso adecuado y sigue inadecuado, se salta los
los pasos para resolverlo. pasos para resolverlo.

TOTAL 10 puntos 8 puntos 6 puntos 4 puntos


// LUZ ESTROBOSCOPICA pinMode(entrada, INPUT);
int ledazul = 8;
int ledrojo = 7; }
int entrada = 2; void loop() {
int ledverde = 9; digitalWrite(ledazul, HIGH);
int ledamari = 10; //enciende el led azul
int pulsador = 0; delay(tiempo); // espera un
int tiempo = 20; tiempo
void setup () { digitalWrite(ledazul, LOW);
pinMode(ledazul, OUTPUT); //apaga el led azul
pinMode(ledrojo, OUTPUT); delay(tiempo); // espera un
pinMode(ledverde, OUTPUT); tiempo
pinMode(ledamari, OUTPUT);
digitalWrite(ledazul, HIGH); digitalWrite(ledverde, LOW);
//prende led azul //apaga el led verde
delay(tiempo); // espera un delay(tiempo); // espera un
tiempo tiempo
digitalWrite(ledazul, LOW); digitalWrite(ledverde, HIGH);
//apaga el led azul //prende led verde
delay(50); // espera un delay(tiempo); // espera un
tiempo de 50ms tiempo
digitalWrite(ledverde, LOW);
digitalWrite(ledrojo, HIGH); //apaga el led verde
//enciende led rojo delay(50);
delay(tiempo); // espera un
tiempo 10ms digitalWrite(ledamari, HIGH);
digitalWrite(ledrojo, LOW); //enciende el led amarillo
//apaga el led rojo delay(tiempo); // espera un
delay(tiempo); // espera un tiempo
tiempo 10ms digitalWrite(ledamari, LOW);
digitalWrite(ledrojo, HIGH); //apaga el led amarillo
//prende led rojo delay(tiempo); // espera un
delay(tiempo); // espera un tiempo
tiempo 10ms digitalWrite(ledamari, HIGH);
digitalWrite(ledrojo, LOW); //prende led amarillo
//apaga el led rojo delay(tiempo); // espera un
delay(50); // espera un tiempo
tiempo de 150ms digitalWrite(ledamari, LOW);
digitalWrite(ledverde, HIGH); //apaga el led amarillo
//enciende el led verde delay(50);
delay(tiempo); // espera un pulsador = digitalRead(entrada); //lee
tiempo el valor del pin 2 si esta en alto o bajo
if (pulsador == HIGH) { //Si se else {
pulsa el boton se crea un retardo de tiempo=1000;
1000ms hasta que detecte lo contrario }
tiempo=20; }
}

Unidad 3 “Sistemas de adquisición de datos”


UNIVERSIDAD POLITÉCNICA DEL CENTRO
RUBRICA PARA EVALUAR EJERCICIOS DE LA UNIDAD 3
Programa Educativo Periodo
Ing. Mecatrónica Septiembre - Diciembre 2017

Cuatrimestre, grupo Asignatura


4,M1 Programación de Periféricos

EXCELENTE BUENO REGULAR DEFICIENTE


ELEMENTOS
2.5 puntos 2 puntos 1.5 puntos 1 punto

Presenta menos del 50%


Presenta la totalidad de Entrega más del 80% de Presenta más del 60% de
EJERCICIOS de los ejercicios a
ejercicios a resolver. los ejercicios a resolver los ejercicios a resolver.
resolver.

Refleja un razonamiento
sin orden, puede hacer los
Refleja un razonamiento Refleja un razonamiento
ejercicios pero no explica
detallado y ordenado, sin orden, puede hacer los
la manera en que los No refleja ningún
utilizando el proceso ejercicios pero no explica
resolvió. Cuando los hace razonamiento, resuelve
PROCEDIMIENTO adecuado, siguiendo los la manera en que los
utiliza el proceso los ejercicios de manera
pasos para resolver los resolvió. Utiliza otro
adecuado, siguiendo los mecánica.
ejercicios de manera proceso obteniendo un
pasos para resolver los
correcta. resultado razonable
ejercicios de manera
correcta.
Presenta 80% ó más Presenta 60 % ó más
Presenta el resultado resultados correctos, resultados correctos,
Presenta 50% o menos
obtenido de los ejercicios comete algunos errores comete algunos errores
resultados correctos, no
RESULTADOS y es correcto. Puede debido a cálculos debido a cálculos
sigue el procedimiento
corroborarlo dándole erróneos, utiliza el erróneos, y un proceso
adecuado
sentido proceso adecuado y sigue inadecuado, se salta los
los pasos para resolverlo. pasos para resolverlo.

TOTAL 10 puntos 8 puntos 6 puntos 4 puntos


int led = 9; }
int motor = 0; analogWrite(led, puente);
int potencia = 5; }
int estado;
void setup() {
pinMode(led, OUTPUT);
}
void loop() {
estado = Serial.read(); {
if (estado == '1'){ motor = motor + potencia;
digitalWrite (motor,1); // if (motor == 0 || motor == 255) {
} potencia = -potencia ;
if (estado == '2'){ }
digitalWrite(motor,0); // delay(30);
if (estado == '3'){ }
digitalWrite(motor,0);
Conclusión

El curso de la materia de programación de periféricos fue muy bueno y


durante él se trataron diversos temas los cuales fueron todos abarcados
también se vio una de manera de utilizar un emulador para poder hacer los
trabajos sin necesidad de utilizar una placa física de arduino esto fue de
gran ayuda en la materia ya que facilita el aprendizaje de lo que se enseñó
también durante el curso se utilizó una plataforma interactiva que se
utiliza para el desarrollo de aplicaciones móviles. En si el curso estuvo
completo y aprendí muchas cosas sobre la programación.

Vous aimerez peut-être aussi