Cuadernillo Final
Cuadernillo Final
Cuadernillo Final
SUPERIOR DE MISANTLA
ING. BIOQUÍMICA
ASIGNATURA
INSTRUMENTACION Y CONTROL
GRUPO 305A
UNIDAD 2
TEMA:
PRACTICAS U2
ALUMNA
Por otra parte una de las tarjetas de desarrollo electrónico más utilizadas en la actualidad es
arduino, estas tarjetas han logrado captar la atención de una gran cantidad de personas
interesadas en el desarrollo de prototipos electrónicos, dentro de este gran público que ha
logrado captar se encuentran desde personas con grandes conocimientos de electrónica
hasta aficionados sin mayor conocimiento de electrónica pero que tienen un gran interés por
esta.
Al igual que cuando se trabaja con microcontroladores PIC, el compilador de arduino en este
caso genera un archivo “.hex”para cada programa que estemos desarrollando, la diferencia
es que para el caso de arduino este archivo no queda a simple vista del usuario y por eso lo
primero que vamos a ver es donde encontrarlo ya que es necesario para poder llevar a cabo
la simulación en proteus.
Para este caso voy a tomar uno de los ejemplos que vienen incluidos dentro del IDE de
arduino, luego de tener el programa escrito y dar click en “verificar” el IDE de arduino lo que
hace es compilar nuestro programa y en caso que no existan errores crea el archivo “.hex”
antes mencionado.
ÍNDICE
Introducción....................................................................................................................................................... 15
PRACTICA 1 , 1 LED .......................................................................................................................................... 16
PRACTICA 2 5 LEDOBJETIVO .......................................................................................................................... 20
PRACTICA #3 SEGUNDA PARTE OBJETIVO 5 LEDS ..................................................................................... 27
PRACTICA 4 ,3 LEDS ........................................................................................................................................ 36
PRACTICAS DESARROLLADASPRACTICA #5- CHALECO OBJETIVO ......................................................... 40
PRACTICA #6- SEMAFORO PEATONAL .......................................................................................................... 51
PRACTICA 7 DISPLAY CAMBIO DE NUMERO ................................................................................................. 56
PRÁCTICA 8. DISPLAY DE 7 SEGMENTOS Y LEDS ....................................................................................... 63
PRACTICA #9-POTENCIOMETRO .................................................................................................................... 73
PRACTICA #10-POTENCIOMETRO, PANTALLA Y LUCES LED ..................................................................... 76
PRACTICA #11 INDICADOR DIA Y NOCHE ...................................................................................................... 83
PRACTICA #12 POTENCIOMETRO CON RESISTENCIA ............................................................................. 87
PRACTICA #13 sensor ultrasonico ............................................................................................................... 90
PRACTICA #14 sensor ultrasonico ............................................................................................................... 93
PRACTICA #15 sensor ultrasonico .............................................................................................................. 96
PRACTICA #16 sensor ultrasonico con modulo LCD I2C ......................................................................... 100
PRACTICA #17 LCD, sensor de temperatura y foco ................................................................................. 103
PRACTICA 18 USO DEL SENRO DE MOVIMIENTO, HUMEDAD Y T6EMPERATURA .............................. 107
ANEXO .......................................................................................................................................................... 115
INDICE
Practica 1
Practica 2
Practica 3
Practica 4
Practica 5
Practica 6
Anexo
Introducción
Programar en dos lenguajes de alto nivel (ARDUINO y PROTEUS) para llevar a cabo
molecular. Estos problemas incluyen, por ejemplo desarrollar sistemas de ayuda para el
trabajo de un ingeniero bioquímico, como ejemplo un medidor de PH ,
Estas practican fortalecen al ingeniero bioquímico de tal manera que les permite desarrollar
sus propios programas, de tal manera que les ayude en la vida diaria para su trabajo u otras
cosas.
OBJETIVO
Mediante la interface de Arduino (IDE) escribir un programa para controlar el
encendido y apagado de un led, mismo que será simulado en el software de Proteus
para verificar su correcto funcionamiento. Además de que también será diseñado
en el software de Fritzing.
INSTRUMENTO Y EQUIPO
• 1 Protoboard
• Software de Fritzing
• 1 Resistencia de 100Ω
//PROGRAMA 1
int led=9; //declaro a la variable led de tipo entero y lo conecto a la salida 9
// int xxx variable de tipo
enterovoid setup()
void loop()
{
digitalWrite(led,HIGH); // Enciendo led en forma digital
//digitalWrite(xxx,HIGH/LOW);
SIMULACIÓN
1.- El led conectado al pin 9 de Arduino, permanece encendido durante diez segundos.
2.- El led conectado al pin 9 de Arduino, permanece apagado durante cinco segundos.
IMPLEMENTACIÓN FÍSICA
CONCLUSIÓN
En esta practica usamos los comando para controlar un led, de tal manera que a travez de
los códigos podemos controlar entradas y salidas.
PRACTICA 2
5 LED
OBJETIVO
Mediante la interface de Arduino (IDE) escribir un programa para controlar una serie
de 5 leds de colores, mismo que será simulado en el software de Proteus para
verificar su correcto funcionamiento.
INSTRUMENTO Y EQUIPO
• 1 Protoboard
• Software de Fritzing
• 5 leds de colores
• 5 Resistencia de 100Ω
DIAGRAMA REALIZADO EN FRITZING
CÓDIGO
//*PROGRAMA #2 SERIE DE LED
int
led13=13;
int
led12=12;
int
led11=11;
int
led10=10;
int led9=9;
int t1=300;
void setup()
{
pinMode(13,OUTPUT;
pinMode(12,OUTPUT;
pinMode (11,OUTPUT);
pinMode (10,OUTPUT);
pinMode (9,OUTPUT);
}
void loop()
{
digitalWrite (13,HIGH);
delay(t1); //reparto en tiempo
digitalWrite (13,LOW); //Apago el led en forma
digitaldelay(t1);
digitalWrite (12,HIGH);
delay(t1); //reparto en tiempo
digitalWrite (12,LOW); //Apago el led en forma
digitaldelay(t1);
digitalWrite (11,HIGH);
delay(t1); //reparto en tiempo
digitalWrite (11,LOW); //Apago el led en forma
digitaldelay(t1);
digitalWrite (10,HIGH);
delay(t1); //reparto en tiempo
digitalWrite (10,LOW); //Apago el led en forma
digitaldelay(t1);
digitalWrite (9,HIGH);
delay(t1); //reparto en tiempo
digitalWrite (9,LOW); //Apago el led en forma
digitaldelay(t1);
digitalWrite (9,HIGH);
delay(t1); //reparto en tiempo
digitalWrite (9,LOW); //Apago el led en forma
digitaldelay(t1);
digitalWrite (10,HIGH);
delay(t1); //reparto en tiempo
digitalWrite (10,LOW); //Apago el led en forma
digitaldelay(t1);
digitalWrite (11,HIGH);
delay(t1); //reparto en tiempo
digitalWrite (11,LOW); //Apago el led en forma
digitaldelay(t1);
digitalWrite (12,HIGH);
delay(t1); //reparto en tiempo
digitalWrite (12,LOW); //Apago el led en forma
digitaldelay(t1);
digitalWrite (13,HIGH);
delay(t1); //reparto en tiempo
digitalWrite (13,LOW); //Apago el led en forma
digitaldelay(t1);
}
PROCEDIMIENTO
• Montar el circuito requerido como se muestra en la imagen anterior.
• Conectar cinco leds a nuestra protoboard.
• Conectarle una resistencia 100Ω al cátodo de cada uno de los leds.
• Conectar la otra terminal (ánodo) del led al Pin 9, 10, 11,12 y 13 del Arduino.
• Conectar los cables de corriente y tierra de nuestra Arduino a la protoboard.
• Compilar y cargar el código del programa realizado en el IDE de Arduino.
• Y finalmente probar el funcionamiento del circuito en Proteus .
SIMULACIÓN
1.- El led conectado al pin 13 de Arduino, permanece encendido durante un
segundo y seapaga.
INSTRUMENTO Y EQUIPO
• 1 Protoboard
• Software de Fritzing
• 5 leds de colores
• 5 Resistencia de 100Ω
DIAGRAMA REALIZADO EN FRITZING
CÓDIGO
//*PROGRAMA #2 SERIE 02
/* REALIZADO EL 15 DE SEPTIEMBRE
*/
int
led13=13;
int
led12=12;
int
led11=11;
int
led10=10;
int led9=9;
int t1=1000;
void setup()
pinMode
(13,OUTPUT);
pinMode
(12,OUTPUT);
pinMode
(11,OUTPUT);
pinMode
(10,OUTPUT);
pinMode (9,OUTPUT);
void loop()
{ // SERIE 2
digitalWrite (13,0);
digitalWrite (12,0);
digitalWrite (11,0);
digitalWrite (10,0);
digitalWrite (9,0);
digitalWrite (13,1);
digitalWrite (12,0);
digitalWrite (11,0);
digitalWrite (10,0);
digitalWrite (9,0);
delay(t1)
digitalWrite (13,1);
digitalWrite (12,1);
digitalWrite (11,0);
digitalWrite (10,0);
digitalWrite (9,0);
digitalWrite (13,1);
digitalWrite (12,1);
digitalWrite (11,1);
digitalWrite (10,0);
digitalWrite (9,0);
digitalWrite (13,1);
digitalWrite (12,1);
digitalWrite (11,1);
digitalWrite (10,1);
digitalWrite (9,0);
digitalWrite (13,1);
digitalWrite (12,1);
digitalWrite (11,1);
digitalWrite (10,1);
digitalWrite (9,1);
digitalWrite (13,1);
digitalWrite (12,1);
digitalWrite (11,1);
digitalWrite (10,1);
digitalWrite (9,0);
digitalWrite (13,1);
digitalWrite (12,1);
digitalWrite (11,1);
digitalWrite (10,0);
digitalWrite (9,0);
digitalWrite (13,1);
digitalWrite (12,1);
digitalWrite (11,0);
digitalWrite (10,0);
digitalWrite (9,0);
digitalWrite (13,1);
digitalWrite (12,0);
digitalWrite (11,0);
digitalWrite (10,0);
digitalWrite (9,0);
digitalWrite (13,0);
digitalWrite (12,0);
digitalWrite (11,0);
digitalWrite (10,0);
digitalWrite (9,0);
PROCEDIMIENTO
• Montar el circuito requerido como se muestra en la imagen anterior.
• Conectar cinco leds a nuestra protoboard.
• Conectarle una resistencia 100Ω al cátodo de cada uno de los leds.
• Conectar la otra terminal (ánodo) del led al Pin 9, 10, 11,12 y 13 del Arduino
• Conectar los cables de corriente y tierra de nuestra Arduino a la protoboard.
• Compilar y cargar el código del programa ( hex ) realizado en el IDE de Arduino.
• Finalmente se probara el funcionamiento del circuito en Proteus 8.1 .
SIMULACIÓN
PRACTICA 4 ,3 LEDS
OBJETIVO
Mediante la interface de Arduino (IDE) escribir un programa para controlar una serie
de 3 leds de colores rojo, amarillo y verde. Será simulado en el software de Proteus
para su correcto funcionamiento.
INSTRUMENTO Y EQUIPO
• 1 Protoboard
• Software IDE de Arduino
• Software de Fritzing
• 3 leds de colores
• 3 Resistencia de 100Ω
CODIGO
/* REALIZADO EL 19 DE SEPTIEMBRE
*/
int Rojo=12;
int
Amarillo=11;int
Verde=10; int
t1=1000; void
setup()
pinMode(Rojo,OUTPUT);
pinMode(Amarillo,OUTPUT
);
pinMode(Verde,OUTPUT);
void loop() {
digitalWrite(Rojo,1);
digitalWrite(Amarillo,0);
digitalWrite(Verde,0);
digitalWrite(Rojo,1);
digitalWrite(Amarillo,1);
digitalWrite(Verde,0);
digitalWrite(Rojo,1);
digitalWrite(Amarillo,1);
digitalWrite(Verde,1);
PROCEDIMIENTO
• Conectar la otra terminal (ánodo) del led al Pin 10, 11 y 12 del Arduino.
SIMULACIÓN
PRACTICAS DESARROLLADAS
PRACTICA #5- CHALECO
OBJETIVO
Mediante la interfase de arduino (IDE) escribir un programa para controlar las luces
led para un chaleco para ciclista, mismo que sera simulado en el software de
Proteus para verificar su correcto funcionamiento.
INSTRUMENTO Y EQUIPO
• 1 tarjeta arduino
• 1 cable usb para arduino
• 10 led de colores
• 10 resistencia 100Ω
• 12 cables para conectar
• Sofware de arduino
• Software de proteus
• 1 protoboard
DIAGRAMA EN FRITZING
En este caso la pc no pudo instalar fritzing y por tanto no se pudo realizar
CODIGO EN ARDUINO
int led13=13;
int led12=12;
int led11=11;
int led10=10;
int led9=9;
int led8=8;
int led7=7;
int led6=6;
int led5=5;
int led4=4;
int t1=500;
int n;
int botizq=3;
int botparo=2;
int botder=1;
int izq,alto,der;
void setup() {
for(n=4;n<=13;n++)
{
pinMode(n,OUTPUT);
}
{
pinMode(3,INPUT);
pinMode(2,INPUT);
pinMode(1,INPUT);
}
}
void loop()
{
izq=digitalRead(botizq);
alto=digitalRead(botparo);
der=digitalRead(botder);
if(izq==HIGH)
{
izquierda();
}
else if(der==HIGH)
{
derecha();
}
else if(alto==HIGH)
{
paro();
}
else
{
libre();
}
}
void derecha()
{
//rutina derecha
digitalWrite(led13,1);
digitalWrite(led12,0);
digitalWrite(led11,0);
digitalWrite(led10,0);
digitalWrite(led9,1);
digitalWrite(led8,0);
digitalWrite(led7,0);
digitalWrite(led6,1);
digitalWrite(led5,0);
digitalWrite(led4,0);
delay(t1); //retardo en tiempo
digitalWrite(led13,0);
digitalWrite(led12,1);
digitalWrite(led11,0);
digitalWrite(led10,0);
digitalWrite(led9,0);
digitalWrite(led8,1);
digitalWrite(led7,0);
digitalWrite(led6,0);
digitalWrite(led5,1);
digitalWrite(led4,0);
delay(t1); //retardo en tiempo
digitalWrite(led13,0);
digitalWrite(led12,0);
digitalWrite(led11,1);
digitalWrite(led10,0);
digitalWrite(led9,0);
digitalWrite(led8,0);
digitalWrite(led7,1);
digitalWrite(led6,0);
digitalWrite(led5,0);
digitalWrite(led4,1);
delay(t1); //retardo en tiempo
}
void izquierda()
{
//rutina izquierda
digitalWrite(led13,0);
digitalWrite(led12,0);
digitalWrite(led11,1);
digitalWrite(led10,0);
digitalWrite(led9,0);
digitalWrite(led8,1);
digitalWrite(led7,0);
digitalWrite(led6,0);
digitalWrite(led5,0);
digitalWrite(led4,1);
delay(t1); //retardo en tiempo
digitalWrite(led13,0);
digitalWrite(led12,1);
digitalWrite(led11,0);
digitalWrite(led10,0);
digitalWrite(led9,1);
digitalWrite(led8,0);
digitalWrite(led7,0);
digitalWrite(led6,0);
digitalWrite(led5,1);
digitalWrite(led4,0);
delay(t1); //retardo en tiempo
digitalWrite(led13,1);
digitalWrite(led12,0);
digitalWrite(led11,0);
digitalWrite(led10,1);
digitalWrite(led9,0);
digitalWrite(led8,0);
digitalWrite(led7,0);
digitalWrite(led6,1);
digitalWrite(led5,0);
digitalWrite(led4,0);
delay(t1); //retardo en tiempo
}
void paro()
{
//rutina alto
digitalWrite(led13,1);
digitalWrite(led12,1);
digitalWrite(led11,1);
digitalWrite(led10,1);
digitalWrite(led9,1);
digitalWrite(led8,1);
digitalWrite(led7,1);
digitalWrite(led6,1);
digitalWrite(led5,1);
digitalWrite(led4,1);
delay(t1); //retardo en tiempo
digitalWrite(led13,0);
digitalWrite(led12,0);
digitalWrite(led11,0);
digitalWrite(led10,0);
digitalWrite(led9,0);
digitalWrite(led8,0);
digitalWrite(led7,0);
digitalWrite(led6,0);
digitalWrite(led5,0);
digitalWrite(led4,0);
delay(t1); //retardo en tiempo
}
void libre()
{
//rutina libre
for (n=4;n<=13;n++)
{
digitalWrite(n,1);
delay(20);
}
for(n=4;n<=13;n++)
{
digitalWrite(n,0);
delay(1);
}
}
PROCEDIMIENTO
SIMULACION
IMPLEMENTACION FISICA
IMPLEMENTACION FISICA
CONCLUSION
En esta práctica aprendí a usar los leds de manera muy inteligente de tal manera
de controlar las salidas digitales por medio de botones, de tal manera que obtengan
como fin un objetivo en específico, en este caso, un chaleco para ciclista, este es
muy importante ya que le brinda seguridad a los ciclistas al abordar las calles.
PRACTICA #6- SEMAFORO PEATONAL
OBJETIVO
Mediante la interfase de arduino (IDE) escribir un programa para controlar las luces
led para un semáforo peatonal, mismo que sera simulado en el software de Proteus
para verificar su correcto funcionamiento.
INSTRUMENTO Y EQUIPO
1 tarjeta rduino
5 led de colores
5 resistencia 100Ω
Sofware de arduino
Software de proteus
1 protoboard
2 botones
DIAGRAMA EN FRITZING
CODIGO EN ARDUINO
int Rojo1=11;
int Amarillo1=12;
int Verde1=13;
int t1=200;
int Rojo2=9;
int Verde2=10;
int boton=7;
int bot;
int n;
void setup()
pinMode(Rojo1,OUTPUT);
pinMode(Amarillo1,OUTPUT);
pinMode(Verde1,OUTPUT);
pinMode(Rojo2,OUTPUT);
pinMode(Verde2,OUTPUT);
pinMode(7,INPUT);
}
void loop()
bot=digitalRead(boton);
if(bot==HIGH)
digitalWrite(Rojo1,0);
digitalWrite(Amarillo1,0);
digitalWrite(Verde1,0);
digitalWrite(Rojo2,0);
digitalWrite(Verde2,0);
delay(t1);
digitalWrite(Rojo1,0);
digitalWrite(Amarillo1,0);
digitalWrite(Verde1,1);
digitalWrite(Rojo2,1);
digitalWrite(Verde2,0);
delay(3*t1);
digitalWrite(Rojo1,0);
digitalWrite(Amarillo1,1);
digitalWrite(Verde1,0);
digitalWrite(Rojo2,1);
digitalWrite(Verde2,0);
delay(t1);
digitalWrite(Rojo1,1);
digitalWrite(Amarillo1,0);
digitalWrite(Verde1,0);
digitalWrite(Rojo2,0);
digitalWrite(Verde2,1);
delay(8*t1);
digitalWrite(Rojo1,0);
digitalWrite(Amarillo1,0);
digitalWrite(Verde1,1);
digitalWrite(Rojo2,1);
digitalWrite(Verde2,0);
delay(3*t1);
digitalWrite(Rojo1,0);
digitalWrite(Amarillo1,1);
digitalWrite(Verde1,0);
digitalWrite(Rojo2,0);
digitalWrite(Verde2,1);
delay(t1);
else
{
digitalWrite(Rojo1,0);
digitalWrite(Amarillo1,0);
digitalWrite(Verde1,1);
digitalWrite(Rojo2,1);
digitalWrite(Verde2,0);
PROCEDIMIENTO
SIMULACION
En esta practica aprendí a utilizar los comando de delay, y digitalWrite para elaborar
un programa en cual se ejecutan dos semáforos, en el que uno de ellos es peatonal
e influye en el funcionamiento del otro a travez de un botón. Esto es de gran
importancia ya que permite a la sociedad para mayor comodidad de los peatones.
PRACTICA 7 DISPLAY CAMBIO DE NUMERO
OBJETIVO
El objetivo de esta práctica es realizar un programa que nos permita cambiar los
números del 0 al 9.
INSTRUMENTO Y EQUIPO
• 1 Tarjeta Arduino UNO
• 1 Resistencias de 100Ω
• Software IDE de Arduino
• 1 Cable USB AB para Arduino
• Software de Proteus
• Software de Fritzing
• Cables para conectar
• Display
• 1 Protoboard
Diagrama realizado en fritzing
CÓDIGO
int ledA=13;
int ledB=12;
int ledC=11;
int ledD=10;
int ledE=9;
int ledF=8;
int ledG=7;
int t1=300;
int n;
void setup()
{
for(n=7;n<=13;n++)
{
pinMode(n,OUTPUT);
}
void loop()
{
CERO();
delay(4*t1);
UNO();
delay(4*t1);
DOS();
delay(4*t1);
TRES();
delay(4*t1);
CUATRO();
delay(4*t1);
CINCO();
delay(4*t1);
SEIS();
delay(4*t1);
SIETE();
delay(4*t1);
OCHO();
delay(4*t1);
NUEVE();
delay(4*t1);
void CERO()
{
digitalWrite(ledA,0);
digitalWrite(ledB,0);
digitalWrite(ledC,0);
digitalWrite(ledD,0);
digitalWrite(ledE,0);
digitalWrite(ledF,0);
digitalWrite(ledG,1);
void UNO()
{
digitalWrite(ledA,1);
digitalWrite(ledB,0);
digitalWrite(ledC,0);
digitalWrite(ledD,1);
digitalWrite(ledE,1);
digitalWrite(ledF,1);
digitalWrite(ledG,1);
void DOS()
{
digitalWrite(ledA,0);
digitalWrite(ledB,0);
digitalWrite(ledC,1);
digitalWrite(ledD,0);
digitalWrite(ledE,0);
digitalWrite(ledF,1);
digitalWrite(ledG,0);
}
void TRES()
{
digitalWrite(ledA,1);
digitalWrite(ledB,1);
digitalWrite(ledC,1);
digitalWrite(ledD,1);
digitalWrite(ledE,0);
digitalWrite(ledF,0);
digitalWrite(ledG,1);
}
void CUATRO()
{
digitalWrite(ledA,0);
digitalWrite(ledB,1);
digitalWrite(ledC,1);
digitalWrite(ledD,0);
digitalWrite(ledE,0);
digitalWrite(ledF,1);
digitalWrite(ledG,1);
}
void CINCO()
{
digitalWrite(ledA,1);
digitalWrite(ledB,0);
digitalWrite(ledC,1);
digitalWrite(ledD,1);
digitalWrite(ledE,0);
digitalWrite(ledF,1);
digitalWrite(ledG,1);
void SEIS()
{
digitalWrite(ledA,1);
digitalWrite(ledB,0);
digitalWrite(ledC,1);
digitalWrite(ledD,1);
digitalWrite(ledE,1);
digitalWrite(ledF,1);
digitalWrite(ledG,1);
}
void SIETE()
{
digitalWrite(ledA,1);
digitalWrite(ledB,1);
digitalWrite(ledC,1);
digitalWrite(ledD,0);
digitalWrite(ledE,0);
digitalWrite(ledF,0);
digitalWrite(ledG,0);
void OCHO()
{
digitalWrite(ledA,1);
digitalWrite(ledB,1);
digitalWrite(ledC,1);
digitalWrite(ledD,1);
digitalWrite(ledE,1);
digitalWrite(ledF,1);
digitalWrite(ledG,1);
void NUEVE()
{
digitalWrite(ledA,1);
digitalWrite(ledB,1);
digitalWrite(ledC,1);
digitalWrite(ledD,0);
digitalWrite(ledE,0);
digitalWrite(ledF,1);
digitalWrite(ledG,1);
}
PROCEDIMIENTO
• Colocar el display en el protoboard.
• Conectar los cables de corriente a nuestro arduino a la protoboard como se
muestra en la simulación de fritzing.
• Conectarle una resistencia 100Ω al display
• Compilar y cargar el código del programa ( hex ) realizado en el IDE de Arduino.
• Probar el funcionamiento del circuito en Proteus
• Realizar el diagrama en Fritzing.
SIMULACIÓN
1. la pantalla empezara con el numero 0, y posteriormente ira cambiando
conforme al tiempo en la pantalla del display.
IMPLEMENTACION FISICA
CONCLUSIÓN
En esta practica logramos entender como esque funciona la pantalla de
numero,de tal manera que lo hicimos funcionar a partir de un programa en A
OBJETIVO
Para esta práctica se realizará un programa que nos permita hacer funcionar un
display donde se pueda mostrar mediante tempos como se forma y cambia los
números del 0 al 9 y que a su vez se enciendan los 10 leds conforme al número
que se esté mostrando.
INSTRUMENTO Y EQUIPO
void setup()
{
for(n=2;n<=17;n++)
{
pinMode(n,OUTPUT);
}
void loop()
{
CERO();
delay(4*500); UNO();
delay(4*500); DOS();
delay(4*500); TRES();
delay(4*500); CUATRO();
delay(4*500); CINCO();
delay(4*500); SEIS();
delay(4*500); SIETE();
delay(4*500); OCHO();
delay(4*500); NUEVE();
delay(4*500);
}
void CERO()
{
digitalWrite(ledA,0);
digitalWrite(ledB,0);
digitalWrite(ledC,0);
digitalWrite(ledD,0);
digitalWrite(ledE,0);
digitalWrite(ledF,0);
digitalWrite(ledG,1);
digitalWrite(led1,0);
digitalWrite(led2,0);
digitalWrite(led3,0);
digitalWrite(led4,0);
digitalWrite(led5,0);
digitalWrite(led6,0);
digitalWrite(led7,0);
digitalWrite(led8,0);
digitalWrite(led9,0);
}
oid UNO()
{
digitalWrite(ledA,1);
digitalWrite(ledB,0);
digitalWrite(ledC,0);
digitalWrite(ledD,1);
digitalWrite(ledE,1);
digitalWrite(ledF,1);
digitalWrite(ledG,1);
digitalWrite(led1,1);
digitalWrite(led2,0);
digitalWrite(led3,0);
digitalWrite(led4,0);
digitalWrite(led5,0);
digitalWrite(led6,0);
digitalWrite(led7,0);
digitalWrite(led8,0);
digitalWrite(led9,0);
void DOS()
{
digitalWrite(ledA,0);
digitalWrite(ledB,0);
digitalWrite(ledC,1);
digitalWrite(ledD,0);
digitalWrite(ledE,0);
digitalWrite(ledF,1);
digitalWrite(ledG,0);
digitalWrite(led1,1);
digitalWrite(led2,1);
digitalWrite(led3,0);
digitalWrite(led4,0);
digitalWrite(led5,0);
digitalWrite(led6,0);
digitalWrite(led7,0);
digitalWrite(led8,0);
digitalWrite(led9,0);
void TRES()
{
digitalWrite(ledA,0);
digitalWrite(ledB,0);
digitalWrite(ledC,0);
digitalWrite(ledD,0);
digitalWrite(ledE,1);
digitalWrite(ledF,1);
digitalWrite(ledG,0);
digitalWrite(led1,1);
digitalWrite(led2,1);
digitalWrite(led3,1);
digitalWrite(led4,0);
digitalWrite(led5,0);
digitalWrite(led6,0);
digitalWrite(led7,0);
digitalWrite(led8,0);
digitalWrite(led9,0);
}
void CUATRO()
{
digitalWrite(ledA,1);
digitalWrite(ledB,0);
digitalWrite(ledC,0);
digitalWrite(ledD,1);
digitalWrite(ledE,1);
digitalWrite(ledF,0);
digitalWrite(ledG,0);
digitalWrite(led1,1);
digitalWrite(led2,1);
digitalWrite(led3,1);
digitalWrite(led4,1);
digitalWrite(led5,0);
digitalWrite(led6,0);
digitalWrite(led7,0);
digitalWrite(led8,0);
digitalWrite(led9,0);
}
void CINCO()
{
digitalWrite(ledA,0);
digitalWrite(ledB,1);
digitalWrite(ledC,0);
digitalWrite(ledD,0);
digitalWrite(ledE,1);
digitalWrite(ledF,0);
digitalWrite(ledG,0);
digitalWrite(led1,1);
digitalWrite(led2,1);
digitalWrite(led3,1);
digitalWrite(led4,1);
digitalWrite(led5,1);
digitalWrite(led6,0);
digitalWrite(led7,0);
digitalWrite(led8,0);
digitalWrite(led9,0);
void SEIS()
{
digitalWrite(ledA,0);
digitalWrite(ledB,1);
digitalWrite(ledC,0);
digitalWrite(ledD,0);
digitalWrite(ledE,0);
digitalWrite(ledF,0);
digitalWrite(ledG,0);
digitalWrite(led1,1);
digitalWrite(led2,1);
digitalWrite(led3,1);
digitalWrite(led4,1);
digitalWrite(led5,1);
digitalWrite(led6,1);
digitalWrite(led7,0);
digitalWrite(led8,0);
digitalWrite(led9,0);
void SIETE()
{
digitalWrite(ledA,0);
digitalWrite(ledB,0);
digitalWrite(ledC,0);
digitalWrite(ledD,1);
digitalWrite(ledE,1);
digitalWrite(ledF,1);
digitalWrite(ledG,1);
digitalWrite(led1,1);
digitalWrite(led2,1);
digitalWrite(led3,1);
digitalWrite(led4,1);
digitalWrite(led5,1);
digitalWrite(led6,1);
digitalWrite(led7,1);
digitalWrite(led8,0);
digitalWrite(led9,0);
void OCHO()
{
digitalWrite(ledA,0);
digitalWrite(ledB,0);
digitalWrite(ledC,0);
digitalWrite(ledD,0);
digitalWrite(ledE,0);
digitalWrite(ledF,0);
digitalWrite(ledG,0);
digitalWrite(led1,1);
digitalWrite(led2,1);
digitalWrite(led3,1);
digitalWrite(led4,1);
digitalWrite(led5,1);
digitalWrite(led6,1);
digitalWrite(led7,1);
digitalWrite(led8,1);
digitalWrite(led9,0);
void NUEVE()
{
digitalWrite(ledA,0);
digitalWrite(ledB,0);
digitalWrite(ledC,0);
digitalWrite(ledD,1);
digitalWrite(ledE,1);
digitalWrite(ledF,0);
digitalWrite(ledG,0);
digitalWrite(led1,1);
digitalWrite(led2,1);
digitalWrite(led3,1);
digitalWrite(led4,1);
digitalWrite(led5,1);
digitalWrite(led6,1);
digitalWrite(led7,1);
digitalWrite(led8,1);
digitalWrite(led9,1);
PROCEDIMIENTO
PRACTICA #9-POTENCIOMETRO
OBJETIVO
INSTRUMENTO Y EQUIPO
• 1 tarjeta arduino
• 1 cable USB para arduino
• 3 cables para conectar
• Sofware de arduino
• Software de proteus
• 1 protoboard
DIAGRAMA EN FRITZING
CODIGO EN ARDUINO
/*Programa #9
* Lectura del puesrto A0 de arduino
* realizado el 14/octubre/2022
* por LEIDI, ANA P., GILA
*/
float pot,voltaje;
void setup()
{
Serial.begin(9600);
}
void loop()
{
pot= analogRead(A0);
voltaje= pot*5/1023;
Serial.print("Valor de Potenciómetro ");
Serial.println(pot);
Serial.print("valor del voltaje ");
Serial.println(voltaje);
delay(1000);
PROCEDIMIENTO
SIMULACION
EN PROTEUS
CONCLUSIÓN
En esta práctica se buscó medir el voltaje partir de un programa de Arduino y con
apoyo de un potenciómetro, este se encargará de medir el voltaje dependiendo de
la rotación del potenciómetro será el aumento del voltaje.
OBJETIVO
Mediante la interfase de Arduino (IDE) escribir un programa a partir de un
potenciómetro, una pantalla y luces led, en el cual respecto al movimiento del
potenciómetro será el numero que se presente en la pantalla y por tanto el numero
de focos que se prenderán
INSTRUMENTO Y EQUIPO
• 1 tarjeta arduino
• 1 cable USB para arduino
• 16 cables para conectar
• Sofware de arduino
• Software de proteus
• 1 protoboard
• 1 pantalla
• 1 potenciometro
• 5 luces led
• 5 resistencias
DIAGRAMA EN FRITZING
CODIGO EN ARDUINO
//programa 10 U3
float pot, voltaje;
int ledA=13;
int ledB=12;
int ledC=11;
int ledD=10;
int ledE=9;
int ledF=8;
int ledG=7;
int led1=6;
int led2=5;
int led3=4;
int led4=3;
int led5=2;
int n;
int ti=500;
void setup()
{
Serial.begin(9600);
for(n=2;n<=13;n++)
{
pinMode(n,OUTPUT);
}
}
void loop()
{
pot=analogRead(A0);
voltaje=pot*5/1023;
Serial.print("Valor del voltaje ");
Serial.println(voltaje);
if (voltaje<=0.5)
{
digitalWrite(led1,0);
digitalWrite(led1,0);
digitalWrite(led1,0);
digitalWrite(led1,0);
digitalWrite(led1,0);
digitalWrite(ledA,0);
digitalWrite(ledB,0);
digitalWrite(ledC,0);
digitalWrite(ledD,0);
digitalWrite(ledE,0);
digitalWrite(ledF,0);
digitalWrite(ledG,1);
digitalWrite(led1,0);
}
if (voltaje>0.5&&voltaje<=1.5)
{
digitalWrite(led1,1);
digitalWrite(led2,0);
digitalWrite(led3,0);
digitalWrite(led4,0);
digitalWrite(led5,0);
digitalWrite(ledA,1);
digitalWrite(ledB,0);
digitalWrite(ledC,0);
digitalWrite(ledD,1);
digitalWrite(ledE,1);
digitalWrite(ledF,1);
digitalWrite(ledG,1);
digitalWrite(led1,1);
}
if (voltaje>1.5&&voltaje<=2.5)
{
digitalWrite(led1,1);
digitalWrite(led2,1);
digitalWrite(led3,0);
digitalWrite(led4,0);
digitalWrite(led5,0);
digitalWrite(ledA,0);
digitalWrite(ledB,0);
digitalWrite(ledC,1);
digitalWrite(ledD,0);
digitalWrite(ledE,0);
digitalWrite(ledF,1);
digitalWrite(ledG,0);
digitalWrite(led1,1);
}
if (voltaje>2.5&&voltaje<=3.5)
{
digitalWrite(led1,1);
digitalWrite(led2,1);
digitalWrite(led3,1);
digitalWrite(led4,0);
digitalWrite(led5,0);
digitalWrite(ledA,0);
digitalWrite(ledB,0);
digitalWrite(ledC,0);
digitalWrite(ledD,0);
digitalWrite(ledE,1);
digitalWrite(ledF,1);
digitalWrite(ledG,0);
digitalWrite(led1,1);
}
if (voltaje>3.5&&voltaje<=4.5)
{
digitalWrite(led1,1);
digitalWrite(led2,1);
digitalWrite(led3,1);
digitalWrite(led4,1);
digitalWrite(led5,0);
digitalWrite(ledA,1);
digitalWrite(ledB,0);
digitalWrite(ledC,0);
digitalWrite(ledE,1);
digitalWrite(ledD,1);
digitalWrite(ledF,0);
digitalWrite(ledG,0);
digitalWrite(led1,1);
}
if (voltaje>=4.5)
{
digitalWrite(led1,1);
digitalWrite(led2,1);
digitalWrite(led3,1);
digitalWrite(led4,1);
digitalWrite(led5,1);
digitalWrite(ledA,0);
digitalWrite(ledB,1);
digitalWrite(ledC,0);
digitalWrite(ledD,0);
digitalWrite(ledE,1);
digitalWrite(ledF,0);
digitalWrite(ledG,0);
digitalWrite(led1,1);
}
}
PROCEDIMIENTO
• Colocar el potenciómetro en el protoboard, al igual que el display y los 5 leds.
• Colocar una resistencia a cada cátodo del led y para el display.
• Conectar los cables de corriente al ánodo de los leds
• Compilar y cargar el código del programa ( hex ) realizado en el IDE de
Arduino.
SIMULACION
Al rotar el potenciómetro cambiara el numero de la pantalla y ese mismo en este
caso el numero de luces led.
CONCLUSIÓN
OBJETIVO
A partir de una foto celda nos indica la cantidad de luz de tal manera que
indentifica si es de dia o noche.
INSTRUMENTO Y EQUIPO
• 1 tarjeta arduino
• 1 cable USB para arduino
• 3 cables para conectar
• Sofware de arduino
• Software de proteus
• 1 protoboard
• 1 pantalla
• 1 potenciometro
• 1 resistencias
• 1 fotoresistencia
DIAGRAMA EN FRITZING
CODIGO EN ARDUINO
void setup() {
Serial.begin(9600);
}
void loop() {
foto2=analogRead(A0);
Serial.print("Valor de la fotoresistencia");
Serial.println(foto2);
delay(1000);
+
float foto2,foto;
void setup()
{
Serial.begin (9600);
void loop()
foto2=analogRead(A0);
PROCEDIMIENTO
• Colocar la fotocelda en el protoboard.
• Conectar los cables de corriente
• Compilar y cargar el código del programa
• Probar el funcionamiento del circuito en Proteus
• Realizar el diagrama en Fritzing.
SIMULACION
CONCLUSIÓN
OBJETIVO
Se creara un programa que logre medir la resistencia a partir del voltaje
INSTRUMENTO Y EQUIPO
• 1 tarjeta arduino
• 1 cable USB para arduino
• 4 cables para conectar
• Sofware de arduino
• Software de proteus
• 1 protoboard
• 1 potenciometro
• 1 resistencias
DIAGRAMA EN FRITZING
CODIGO EN ARDUINO
//Programa #12
//medido r de resistores
//realizado el dia 28 de octubre del 2022
//ELABORADO POR LIEDI ASANETH,GIL GABRIEL, ANA PATRICIA
float pot,R,Voltaje;
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
}
void loop() {
// put your main code here, to run repeatedly:
pot=analogRead(A0);
Voltaje=5*pot/1023;
R=Voltaje*1000/(5-Voltaje);
Serial.print("El valor del Resistores ");
Serial.print(R);
Serial.println("ohms");
}
PROCEDIMIENTO
• Colocar el potenciómetro
• Colocar una resitencia conectada al potenciometro
• Conectar los cables de corriente
• Compilar y cargar el código del programa
SIMULACION
CONCLUSIÓN
OBJETIVO
Se realiza un programa con el fin de que detecte el sonico con ayuda de Arduino.
INSTRUMENTO Y EQUIPO
o 1 tarjeta arduino
o 1 cable USB para arduino
o 3 cables para conectar
o Sofware de arduino
o Software de proteus
o 1 protoboard
o 1 potenciometro
o 1 sensor ultrasonico
DIAGRAMA EN FRITZING
CODIGO EN ARDUINO
#include <HCSR04.h>
//"prueba de sonido" "ultrasonico" practica #13
float D=7.5;
float H=18.3;
float h;
float d;
float v;
float hagua;
UltraSonicDistanceSensor distanceSensor(13, 12); // Initialize sensor that uses
digital pins 13 and 12.
void setup () {
Serial.begin(9600); // We initialize serial connection so that we could print
values from sensor.
}
void loop () {
// Every 500 miliseconds, do a measurement using the sensor and print the
distance in centimeters.
Serial.println(distanceSensor.measureDistanceCm());
delay(500);
h=(distanceSensor.measureDistanceCm());
hagua=H-hagua;
v=((PI*D*D)/4)*(hagua);
delay(500);
}
PROCEDIMIENTO
• Conectar el sensor ultrasónico al Arduino
• Compilar y cargar el código del programa
SIMULACION
Se conecta el sensor ultrasónico al Arduino
IMPLEMENTACIÓN FIICA
CONCLUSIÓN
Podemos decir que logramos entender el funcionamiento del programa y del elemento
para detectar sonido.
OBJETIVO
Escribir un programa con ayuda de arduino que nos ayude a la detección de proximidad de
un objeto el cual será reportado en cm, será informado con ayuda de LEDS, será simulado
con proteus para su buen funcionamiento.
INSTRUMENTO Y EQUIPO
CODIGO EN ARDUINO
*/
int Trigger=12; //pin digital 2 para el trigger del ssensor
int Echo=13; //pin digital 3 para el Echo del sensor
int led01=11;
int led02=10;
int led03=9;
int led04=8;
int led05=7;
int led06=6;
int n;
void setup()
{
for(n=6;n<=11;n++)
{
pinMode(n,OUTPUT);
}
Serial.begin(9600); // iniciamos la comunicacion serial
pinMode(Trigger, OUTPUT); //declaramos el pin como salida
pinMode(Echo, INPUT); //declaramos el pin como entrada
digitalWrite(Trigger, LOW); //inicializamos el pin con 0
}
void loop()
{
long t; //tiempo en que demora en llegra el eco
long d; //distancia en centimetros
long d1;
digitalWrite(Trigger,HIGH);
delayMicroseconds(10); //enviamos un pulso de
digitalWrite(Trigger,LOW);
t= pulseIn(Echo,HIGH);
d=(t/59); // transformamos el tiempo en centimetros
d1=d/3;
Serial.print("Distancia");
Serial.print(d1);
Serial.print("cm");
Serial.println();
delay(500);
if (d1<59)
{
digitalWrite(led01,HIGH);
digitalWrite(led02,HIGH);
digitalWrite(led03,HIGH);
digitalWrite(led04,HIGH);
digitalWrite(led05,HIGH);
digitalWrite(led06,HIGH);
}
else if (d1>=59&&d1<118)
{
digitalWrite(led01,HIGH);
digitalWrite(led02,HIGH);
digitalWrite(led03,HIGH);
digitalWrite(led04,HIGH);
digitalWrite(led05,HIGH);
digitalWrite(led06,LOW);
}
else if (d1>=118&&d1<177)
{
digitalWrite(led01,HIGH);
digitalWrite(led02,HIGH);
digitalWrite(led03,HIGH);
digitalWrite(led04,HIGH);
digitalWrite(led05,LOW);
digitalWrite(led06,LOW);
}
else if (d1>=177&&d1<236)
{
digitalWrite(led01,HIGH);
digitalWrite(led02,HIGH);
digitalWrite(led03,HIGH);
digitalWrite(led04,LOW);
digitalWrite(led05,LOW);
digitalWrite(led06,LOW);
}
else if (d1>=236&&d1<295)
{
digitalWrite(led01,HIGH);
digitalWrite(led02,HIGH);
digitalWrite(led03,LOW);
digitalWrite(led04,LOW);
digitalWrite(led05,LOW);
digitalWrite(led06,LOW);
}
else if (d1>=295)
{
digitalWrite(led01,HIGH);
digitalWrite(led02,LOW);
digitalWrite(led03,LOW);
digitalWrite(led04,LOW);
digitalWrite(led05,LOW);
digitalWrite(led06,LOW);
}
}
PROCEDIMIENTO
1. Colocar la tarjeta de Arduino
2. En el pin 13 y 12 conectar el sensor ultrasónico
3. Colocar los leds en los pies del 11 al 8
4. Colocar resistencia a los leds
5. Conectar los leds a tierra
6. Colocar una terminal en el pin 0 y 1
7. Colocar un POT-HG y conectarlo en el sensor
8. Conectar una tierra y un voltaje al POT-HG
SIMULACION
Se conecta el sensor ultrasónico al Arduino
CONCLUSIÓN
Podemos decir que logramos entender el funcionamiento del programa y del elemento para
detectar sonido.
OBJETIVO
Se realiza un programa con ayuda de Arduino para a travez del potenciómetro medir
la intensidad de luz que transmite la pantalla .
INSTRUMENTO Y EQUIPO
o 1 tarjeta arduino
o 1 cable USB para arduino
o 12 cables para conectar
o Sofware de arduino
o Software de proteus
o 1 protoboard
o 1 potenciometro
DIAGRAMA EN FRITZING
CODIGO EN ARDUINO
/* practica 15
LiquidCrystal Library - Hello World
The circuit:
* LCD RS pin to digital pin 12
* LCD Enable pin to digital pin 11
* LCD D4 pin to digital pin 5
* LCD D5 pin to digital pin 4
* LCD D6 pin to digital pin 3
* LCD D7 pin to digital pin 2
* LCD R/W pin to ground
* LCD VSS pin to ground
* LCD VCC pin to 5V
* 10K resistor:
* ends to +5V and ground
* wiper to LCD VO pin (pin 3)
http://www.arduino.cc/en/Tutorial/LiquidCrystalHelloWorld
*/
void setup() {
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
// Print a message to the LCD.
lcd.print("HELLO MUNDO");
}
void loop() {
// set the cursor to column 0, line 1
// (note: line 1 is the second row, since counting begins with 0):
lcd.setCursor(0, 1);
// print the number of seconds since reset:
lcd.print(millis() / 1000);
}
PROCEDIMIENTO
• Conectar el potenciómetro y la pantalla display a Arduino
• Compilar y cargar el código del programa
IMPLEMENTACIÓN FIICA
CONCLUSIÓN
Podemos decir que logramos entender el funcionamiento del programa realizado y
hacer uso de el para maniobrar el brillo en la pantalla display así como transmitir un
mensaje a través de ella.
OBJETIVO
INSTRUMENTO Y EQUIPO
• 1 tarjeta arduino
• 1 cable USB para arduino
• 3 cables para conectar
• Sofware de arduino
• Software de proteus
• 1 protoboard
• 1 pantalla
• 1 sensor ultrasónico
• I2C
CODIGO EN ARDUINO
//YWROBOT
//Compatible with the Arduino IDE 1.0
//Library version:1.1
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <HCSR04.h>
void loop () {
Serial.println(distanceSensor.measureDistanceCm());
float distancia=distanceSensor.measureDistanceCm();
lcd.setCursor(2,0);
lcd.print("DIST =");
lcd.setCursor(7,0);
lcd.print(distancia);
lcd.setCursor(12,0);
lcd.print("CM");
PROCEDIMIENTO
• Conectar el sensor ultrasónico
• Colocar el I2C
• Colocar la pantalla display
• Conectar los cables al Arduino
• Compilar programa
• Mandar el programa a ejecutar
SIMULACION
IMPLEMENTACIÓN FIICA
CONCLUSIÓN
OBJETIVO
Escribir un programa que incluya el uso del sensor I2C, el LCD y un foco led, para hallar la
emperatura y sonido.
INSTRUMENTO Y EQUIPO
CODIGO EN ARDUINO
// Include the libraries we need
#include <OneWire.h>
#include <DallasTemperature.h>
// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas
temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16,2); // set the LCD address to 0x27 for a 16 chars and 2 line
display;
int verde=8;
int azul=9;
int rojo=7;
void setup(void)
{
// start serial port
Serial.begin(9600);
Serial.println("Dallas Temperature IC Control Library Demo");
lcd.init(); // initialize the lcd
lcd.backlight();
lcd.setCursor(6,0);
lcd.print("HOLA");
lcd.setCursor(3,1);
lcd.print("BIOQUIMICOS");
Serial.begin(9600);
delay (5000);
// Start up the library
sensors.begin();
pinMode(verde,OUTPUT);
pinMode(azul,OUTPUT);
pinMode(rojo,OUTPUT);
}
/*
* Main function, get and show the temperature
*/
void loop(void)
{
// call sensors.requestTemperatures() to issue a global temperature
// request to all devices on the bus
Serial.print("Requesting temperatures...");
sensors.requestTemperatures(); // Send the command to get temperatures
Serial.println("DONE");
// After we got the temperatures, we can print them here.
// We use the function ByIndex, and as an example get the temperature from the first sensor
only.
float tempC = sensors.getTempCByIndex(0);
}
lcd.clear();
lcd.setCursor(2,0);
lcd.print(" T =");
lcd.setCursor(7,0);
lcd.print(tempC);
lcd.setCursor(14,0);
lcd.print("°C");
delay(500);
if (tempC<30)
{
digitalWrite(verde,1);
digitalWrite(azul,0);
digitalWrite(rojo,0);
Serial.println("verde encendido");
}
else if (tempC>30 &&tempC<40)
{
digitalWrite(azul,1);
digitalWrite(verde,0);
digitalWrite(rojo,0);
Serial.println("azul encendido");
}
else if (tempC>40)
{
digitalWrite(rojo,1);
digitalWrite(verde,0);
digitalWrite(azul,0);
Serial.println("rojo encendido");
}
}
PROCEDIMIENTO
1. Colocar la tarjeta de Arduino
2. Colocar led
3. Colocar resistencia a los leds
4. Conectar I2C
5. Compilar
6. Cargar
SIMULACION
Se conectar el I2C, el foco y una resistencia al Arduino, asi como la pantalla display.
CONCLUSIÓN
Podemos decir que logramos entender el funcionamiento del programa y del elemento para
detectar la temperatura y mandar el mensaje a la pantalla display.
void loop() {
delay(5000);
float humedad = dht.readHumidity();
float temperatura = dht.readTemperature();
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Temper. = ");
lcd.print(temperatura);
lcd.setCursor(0,1);
lcd.print("Humedad = ");
lcd.print(humedad);
int value= digitalRead(PIRPin);
if (value == HIGH)
{
digitalWrite(LEDPin, HIGH);
delay(50);
digitalWrite(LEDPin, LOW);
delay(50);
}
else
{
digitalWrite(LEDPin, LOW);
}
#include <DHT22.h>
#include "DHT.h"
dht.begin();
pinMode(LEDPin, OUTPUT);
pinMode(PIRPin, INPUT);
void loop() {
// Wait a few seconds between measurements.
delay(2000);
if (isnan(h) || isnan(t)) {
Serial.println("Failed to read from DHT sensor!");
return;
}
Serial.print("Humidity: ");
Serial.print(h);
Serial.print(" %\t");
Serial.print("Temperature: ");
Serial.print(t);
Serial.print(" *C ");
int value= digitalRead(PIRPin);
if (value == HIGH)
{
digitalWrite(LEDPin, HIGH);
delay(50);
digitalWrite(LEDPin, LOW);
delay(50);
}
else
{
digitalWrite(LEDPin, LOW);
}
}
PROCEDIMIENTO
• Colocar el display en el protoboard.
• Conectar los cables de corriente a nuestro arduino a la protoboard, al potenciómetro,
al sensor de temperatura t al display, asi como también al sensor de movimiento.
• Conectarle una resistencia 100Ω al display
• Compilar y cargar el código del programa ( hex ) realizado en el IDE de Arduino.
• Realizar el diagrama en Fritzing.
PERO AL MANDARLOS DECIA QUE EL TIEMPO DE ESPERA HABIA ACABADO PARA
AMBOS CODIGOS, NO LOGRAMOS ENCONTRAR LA RAZON DEL PROBLEMA.
• SENSOR DE HUMEDAD Y TEMPERATURA CON 3 ENTRADAS
• SENSOR DE HUMEDAD Y TEMPERATURA CON 4 ENTRADAS
CONCLUSIÓN
En esta practica logramos entender como esque funcionan los distintos sensores, como el de
movimiento, temperatura y humedad, para lograr crear un programa que nos funcione.
ANEXO
Proteus
Las ventajas saltan a la vista. Con Proteus las fases de prueba no suponen la
necesidad de volver a construir nuevos prototipos, con el ahorro de costos y tiempo
que ello supone.
Protoboard
Luces led
El funcionamiento de las luces LED viene dado por el Principio fotoeléctrico ideado
por Albert Einstein. Este principio se basa en la existencia de materiales que al
someterlos a una corriente eléctrica pueden producir luz. En el caso de los LED, la
corriente eléctrica genera luz al pasar por los diodos. Este proceso también recibe
el nombre de electroluminiscencia.
Para que este proceso funcione es necesario que el LED esté polarizado
directamente. Es decir, tiene que existir una corriente circular de un término positivo
(ánodo) a uno negativo (cátodo). Es aquí cuando se produce el llamado “fotón” al
desprenderse los electrones y se produce luz.
Resistencia
La resistencia se mide en ohmios, que se simbolizan con la letra griega omega (Ω).
Se denominaron ohmios en honor a Georg Simon Ohm (1784-1854), un físico
alemán que estudió la relación entre voltaje, corriente y resistencia. Se le atribuye
la formulación de la ley de Ohm.
Todos los materiales resisten en cierta medida el flujo de corriente. Se incluyen en
una de dos amplias categorías:
Familia Arduino
Arduino dispone de una amplia variedad de placas y shields para usar dependiendo
de nuestras necesidades.
Un shield es una placa compatible que se puede colocar en la parte superior de los
arduinos y permite extender las capacidades del arduino. De estas hablaremos en
profundidad más adelante.
Primer Arduino:
IMPORTANCIA DE LA PROGRAMACION
Arduino Uno
La programación va más allá que cualquier idioma, pues también es un gran tutor
cuando se trata de aprender a solucionar problemas, principalmente situaciones de
lógica e ingenio. Es el arte de crear soluciones desde cero a paradigmas complejos
a base de un pensamiento estructurado, lógico y creativo.
Mega ADK es una placa basada en el Mega2560 pero con un USB host adicional
para conectar móviles basados en Android.
Arduino Ethernet
Incorpora un puerto ethernet, está basado en el Arduino Uno y nos permite
conectarnos a una red o a Internet mediante su puerto de red.
Arduino Due
Arduino Leonardo
La diferencia de este arduino con el resto es que trae un único MCU ATmega32u4
que tiene integrado la comunicación USB, lo que elimina la necesidad de un
segundo procesador. Esto tiene otras implicaciones en el compartimento del arduino
al conectarlo al ordenador, lo que no lo hace apto para iniciarse con él.
Arduino Mini
Arduino Yun
Familia MKR
La familia de Arduino MKR son uan serie de placas con un factor de forma diferente
al de Arduino mucho más pequeño y basados todos en el microcontrolador de 32
bits de Atmel SAMD21. Estas placas están pensadas principalmente para IoT.
Arduino MKRZero
Versión para IoT con procesador Atmel ARM Cortex M0+ de 32bits ATSAMW25 que
es el mismo procesador que Genuino Zero pero con wifi integrado, chip de cifrado
y antena integrada.
Aprender a programar puede abrirte las puertas a un mejor empleo, nuevas áreas
de trabajo o incluso a una nueva forma de ver cómo funciona todo a nuestro
alrededor.
En ocasiones una de las grandes barreras para aprender algo nuevo es el miedo.
Pero cuando se trata de algo tan común e importante para la vida cotidiana y que
además nos acerca al entorno tecnológico, se convierte en una oportunidad que no
podemos dejar pasar.
Sin duda alguna, los beneficios que otorga aprender a programar no solo se reflejan
en el mundo digital, sino también en la solución de problemas de la vida cotidiana.
Tan solo durante los últimos años, la programación ha sido la encargada de que la
mayoría de ideas tecnológicas hayan podido ver la luz, facilitando el trabajo diario a
miles de personas.
Es cierto que, durante los primeros años, las ideas aparecían de forma lenta y
costaba desarrollarlas, hasta que hicieron su aparición las máquinas industriales,
permitiendo que este sector generase millones de euros en ganancias,
consiguiendo que se aumentará la producción y que hasta el día de hoy las
empresas sigan interesadas en ellas.
Poco a poco la tecnología fue aumentando su auge y cada día que pasa esté más
desarrollada, con el objetivo de que el hombre pudiera realizar su trabajo con la
menor dificultad posible, sin que repercuta en la eficacia.
La programación en la actualidad
Hoy en día vemos la calculadora como un producto simple, que puede ayudarnos
con nuestro trabajo, pero, cuando apareció por primera vez, el hombre tuvo una
gran reacción al ver como un objeto tan pequeño podía realizar operaciones
matemáticas en cuestión de segundos, algo que un hombre normal tardaría varios
minutos.
La programación en la industria