Cuadernillo Final

INSTITUTO TECNOLOGICO
SUPERIOR DE MISANTLA
ING. BIOQUÍMICA
ASIGNATURA
INSTRUMENTACION Y CONTROL
GRUPO 305A
UNIDAD 2
TEMA:
PRACTICAS U2
ALUMNA
LEIDI, ANA Y GIL

DOCENTE: ING. MARIO PEREZ ACOSTA
MISANTLA, VERACRUZ OCTUBRE 17, 2022.

Resumen
Una parte importante en el proceso de diseño y desarrollo de circuitos electrónicos es la etapa

de simulación, con esta etapa podemos verificar que el circuito que se está diseñando funcione
correctamente y de no ser así se puede ir depurando el circuito hasta que se logre el resultado
deseado y poder llevar el diseño a una etapa física.
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
tareas de complejidad media para la manipulación de datos y la resolución de
problemas reales en los campos de la biología, la bioquímica, y la biología
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.
A continuación se muestran diversas practicas que se desarrollaron el el curso de

intrumentacion y control con ayuda de estos dos programas, de manera que el ingeniero
desarrolle sus capacidades.
PRÁCTICAS DESARROLLADAS
PRACTICA 1 , 1 LED
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 Tarjeta Arduino UNO
• 1 Cable USB AB para Arduino
• 1 Protoboard
• Software IDE de Arduino
• Software de Fritzing
• Cables para conectar
• 1 led de color Rojo
• 1 Resistencia de 100Ω
DIAGRAMA REALIZADO EN FRITZING

CÓDIGO
//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()
pinMode(led,OUTPUT); //Declaro a la variable led como salida

//pinMode(xxx,INPUT /OUTPUT);
}
void loop()
{
digitalWrite(led,HIGH); // Enciendo led en forma digital
//digitalWrite(xxx,HIGH/LOW);
delay(5000); //retardo en tiempo de 5 seg
digitalWrite(led,LOW); //apago led en forma

digitaldelay(2000);
}
PROCEDIMIENTO
• Montar el circuito requerido como se muestra en la imagen anterior.
• Conectar un led a nuestra protoboard.
• Conectarle una resistencia 100Ω al cátodo del led .
• Conectar la otra terminal (ánodo) del led al Pin 9 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.
• Y finalmente probar el funcionamiento del circuito en Proteus 8.1 .
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.
• 1 Protoboard
• Software de Proteus 8.1
• 5 leds de colores
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);
digitaldelay(t1);
digitaldelay(t1);
digitaldelay(t1);
digitaldelay(t1);
digitaldelay(t1);
digitaldelay(t1);
digitaldelay(t1);
digitaldelay(t1);
digitaldelay(t1);
}
PROCEDIMIENTO
• 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.
• 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.

segundo y seapaga.
segundo y seapaga.

segundo y seapaga.

segundo y seapaga.
CONCLUSIÓN
En este programa se realizo un programa a travez de Arduino en el que se controla la entradas
y salidas de 5 leds, con la cual se confirma el funcionamiento con proteus.
PRACTICA #3 SEGUNDA PARTE OBJETIVO 5 LEDS

de 5 leds de colores, este sera simulado en el software de Proteus para su correcto
funcionamiento.
• 1 Protoboard
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 (9,0);
delay(t1); //retardo en tiempo
digitalWrite (9,0);
delay(t1)
digitalWrite (9,0);
digitalWrite (9,0);
digitalWrite (9,0);
digitalWrite (9,1);
digitalWrite (9,0);
digitalWrite (9,0);
digitalWrite (9,0);
digitalWrite (9,0);
digitalWrite (9,0);
PROCEDIMIENTO
• Conectar cinco leds a nuestra protoboard.
• Conectar la otra terminal (ánodo) del led al Pin 9, 10, 11,12 y 13 del Arduino
• Finalmente se probara el funcionamiento del circuito en Proteus 8.1 .
SIMULACIÓN
1.- El led conectado al pin 13 de Arduino, se enciende y permanece encendido.
2.- El led conectado al pin 12 de Arduino, se enciende y permanece encendido

junto con elanterior.
3.- Así sucesivamente se van encendiendo los leds y finalmente, el led conectado
al pin 9 deArduino, se enciende y permanece encendido junto con todos los demás
para después apagarse del ultimo al primer led.
PRACTICA 4 ,3 LEDS
OBJETIVO
de 3 leds de colores rojo, amarillo y verde. Será simulado en el software de Proteus
para su correcto funcionamiento.
• 1 Protoboard
CODIGO
//PROGRAMA #3 semaforo sencillo
/* REALIZADO EL 19 DE SEPTIEMBRE
* EL PROGRAMA CONSISTE EN EL CONTROL DE UNA SERIE DE LEDS
*/
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);
delay(5*t1); //retardo en tiempo
PROCEDIMIENTO
• Conectar tres leds a nuestra protoboard.
• Conectar la otra terminal (ánodo) del led al Pin 10, 11 y 12 del Arduino.
• Finalmente probar el funcionamiento del circuito en Proteus 8.1 .
SIMULACIÓN
1.- El led conectado al pin 12 de Arduino, se enciende y permanece encendido,

mientras quedespués pasan unos segundo se enciende el amarillo y finalmente el
led verde. Finalmente seapaga y se vuelven a encender consecutivamente después
de unos determinados segundos.
IMPLEMENTACION FISICA
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.
• 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
// Programa 05 "Chaleco ciclista"

/*derecha
* izquierda
* paro
* libre
*/
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);
}
void izquierda()
{
//rutina izquierda
}
void paro()
{
//rutina alto
}
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
• Montar el circuito requerido como se indica la imagen anterior

• Conectar las 10 led como se muestra en proteus
• Conectarle la respectiva resistencia a cada una de las led
• Conectar un cable por cada led a la terminal respectiva en arduino, de
igual manera se hara con los otros 9.
• Conectar el botón al protoboard
• Conectar los cables corriente y tierra de nuestro arduino a la
protoboard
• Conectar el cable usb del arduino a nuestra pc
• Compilar y cargar el programa de arduino
• Y finalmente probar el funcionamiento del circuito en proteus.
SIMULACION
1. Leds conectadas a los pines 4,5,6,7,8,9,10,11,12 y 13 , permanecen

apagados
2. Leds conectadas a los pines 4,5,6,7,8,9,10,11,12 y 13 , al aplastar el botón
permanecen prendidas
2. Leds conectadas a los pines 4,5,6,7,8,9,10,11,12 y 13 , al aplastar de nuevo

el botón cambiaran de dirección
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.
1 tarjeta rduino
1 cable usb para arduino
5 led de colores
5 resistencia 100Ω
7 cables para conectar
Sofware de arduino
Software de proteus
1 protoboard
2 botones
En este caso la pc no pudo instalar fritzing y por tanto no se pudo realizar
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);
delay(t1);
delay(3*t1);
delay(t1);
delay(8*t1);
delay(3*t1);
delay(t1);
else
{
PROCEDIMIENTO
• Montar el circuito como se muestra en el proteus

• Conectar 5 led a la protoboard
• Conectar 1 resistencia de 100Ω al catodo de cada led
• Conectar la otra terminal del led al pin 13,12,11,10 y 9 del Arduino.
• Conectar los cables de corriente y tierra de nuestro Arduino a la protoboard
• Conectar el botón al protoborad
• Compilar y cargar del código del programa
• Conectar el usb a la pc
• Y finalmente probar el funcionamiento del circuito en protus.
SIMULACION
1.- el semáforo aparece cambiando de color normalmente, cuando se oprimo el

botón, el led verde del semáforo 1 pasara a ser el rojo, y el semáforo 2 a color
verde.
CONCLUSION
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.
• 1 Resistencias de 100Ω
• Software de Proteus
• 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()
{
void DOS()
{
}
void TRES()
{
}
void CUATRO()
{
}
void CINCO()
{
void SEIS()
{
}
void SIETE()
{
void OCHO()
{
void NUEVE()
{
}
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
• 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.
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
PRÁCTICA 8. DISPLAY DE 7 SEGMENTOS Y LEDS
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.

• Display
• 1 Protoboard
• Sensor de movimiento
• Sensor de húmedas y temperatura
• Potenciómetro

CÓDIGO
//PRACTICA #8
/* Display de 7 segmentos y leds
*/
int ledA=13; int ledB=12; int ledC=11; int ledD=10; int ledE=9; int ledF=8; int
ledG=7; int led1=5; int led2=4; int led3=3; int led4=2; int led5=A0; int led6=A1; int
led7=A2; int led8=A3; int led9=A4; int t1=500; int n;
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()
{
}
oid UNO()
{
void DOS()
{
void TRES()
{
}
void CUATRO()
{
}
void CINCO()
{
void SEIS()
{
void SIETE()
{
void OCHO()
{
void NUEVE()
{
PROCEDIMIENTO
• Empezamos por conectar el display en el protoboard y los leds.

• Conectar los cables de corriente a nuestro arduino a la protoboard.
• Conectarle una resistencia al display
• Compilar y cargar el código del
SIMULACIÓN
1. Cuando el display marca 0 ningún led se enciende.
CONCLUSIÓN
Para esta practica logramos hacer uso de la pantalla de numero relacionada con
las luces led, de tal manera que estas estén vinculadas mutuamente
PRACTICA #9-POTENCIOMETRO
OBJETIVO
Mediante la interfase de Arduino (IDE) escribir un programa a partir de

potenciómetro para medir el voltaje respecto a la rotación del potenciómetro.
• 1 cable USB para arduino
• 1 protoboard
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
• Conectar el potenciómetro en el protoboard.

• Conectar los cables de corriente a nuestro arduino a la protoboard
• Compilar y cargar el código del programa ( hex ) realizado en el IDE de
Arduino.
SIMULACION
1.- Respecto al rodaje del potenciómetro se va a calcular el voltaje, a una

velocidad de t=1000
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.
PRACTICA #10-POTENCIOMETRO, PANTALLA Y LUCES LED
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
• 1 protoboard
• 1 pantalla
• 1 potenciometro
• 5 luces led
• 5 resistencias
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)
{
}
if (voltaje>0.5&&voltaje<=1.5)
{
}
{
}
{
}
{
}
if (voltaje>=4.5)
{
}
}
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
En esta práctica se pudo realizar el manejo de una pantalla para transportar

números a partir de un programa de Arduino y esta fusionado con las
herramientas antes usadas de las luces led, De tal manera que respecto a
cambian los números cambiaran las luces.
PRACTICA #11 INDICADOR DIA Y NOCHE
OBJETIVO
A partir de una foto celda nos indica la cantidad de luz de tal manera que
indentifica si es de dia o noche.
• 1 protoboard
• 1 pantalla
• 1 potenciometro
• 1 resistencias
• 1 fotoresistencia
CODIGO EN ARDUINO
float foto2, foto;
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);
if (foto2>=700 && foto2<=900)
Serial.print("Es de noche "); Serial.println(foto2); delay(1000);

}
if (foto2>=400 && foto2<=600)
Serial.print("Esta nublado "); Serial.println(foto2); delay(1000);

}
if (foto2>=100 && foto2<=200)
Serial.print("Esta soleado "); Serial.println(foto2);

delay(1000);
PROCEDIMIENTO
• Colocar la fotocelda en el protoboard.
• Conectar los cables de corriente
• Compilar y cargar el código del programa
SIMULACION
Se conecta la fotoresistencia al arduino

IMPLEMENTACIÓN FIICA
CONCLUSIÓN
En esta práctica se pudo realizar el manejo de una fotoresistencia para el

programa que nos servirá como reconocerdor de la luz solar , por lo tanto sabra
cuando es dia y noche.
PRACTICA #12 POTENCIOMETRO CON RESISTENCIA
OBJETIVO
Se creara un programa que logre medir la resistencia a partir del voltaje
• 1 protoboard
• 1 potenciometro
• 1 resistencias
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
SIMULACION
Se coloca el potenciómetro y posteriormente se le conecta la resistencia, estos

van a estar conectados con cables al Arduino.
CONCLUSIÓN
En esta práctica se pudo realizar la elaboración de un programa para calcular la

resistencia a partir del voltaje con ayuda de Arduino.
PRACTICA #13 sensor ultrasonico
OBJETIVO
Se realiza un programa con el fin de que detecte el sonico con ayuda de Arduino.
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
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
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
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.
o 1 tarjeta de Arduino UNO

o Cable USB AB para Arduino
o 1 Protoboard
o Software de proteus 8.1
o Software de Frintzing
o Cables para conectar
o 6 Leds de diferentes colores
o 1 sensor ultrasónico
o 1 POT-HG
o 6 resistencias
o 2 tierra
o 1 voltaje
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);
}
else if (d1>=59&&d1<118)
{
digitalWrite(led06,LOW);
}
else if (d1>=118&&d1<177)
{
}
else if (d1>=177&&d1<236)
{
}
else if (d1>=236&&d1<295)
{
}
else if (d1>=295)
{
}
}
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 .
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
CODIGO EN ARDUINO
/* practica 15
LiquidCrystal Library - Hello World
Demonstrates the use a 16x2 LCD display. The LiquidCrystal

library works with all LCD displays that are compatible with the
Hitachi HD44780 driver. There are many of them out there, and you
can usually tell them by the 16-pin interface.
This sketch prints "Hello World!" to the LCD

and shows the time.
The circuit:
* LCD RS pin to digital pin 12
* LCD Enable pin to digital pin 11
* LCD D4 pin to digital pin 5
* 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)
Library originally added 18 Apr 2008

by David A. Mellis
library modified 5 Jul 2009
by Limor Fried (http://www.ladyada.net)
example added 9 Jul 2009
by Tom Igoe
modified 22 Nov 2010
by Tom Igoe
modified 7 Nov 2016
by Arturo Guadalupi
This example code is in the public domain.
http://www.arduino.cc/en/Tutorial/LiquidCrystalHelloWorld
*/
// include the library code:

#include <LiquidCrystal.h>
// initialize the library by associating any needed LCD interface pin

// with the arduino pin number it is connected to
const int rs = 8, en = 9, d4 = 4, d5 = 5, d6 = 6, d7 = 7;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
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
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.
PRACTICA #16 sensor ultrasonico con modulo LCD I2C
OBJETIVO
A partir de un sensor ultrasónico, un I2C y una pantalla display lograr enviar el

mensaje a la pantalla para transmitir lo que se desea
• 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>
UltraSonicDistanceSensor distanceSensor(13, 12); // Initialize sensor that uses

digital pins 13 and 12.
LiquidCrystal_I2C lcd(0x27,16,2); // set the LCD address to 0x27 for a 16 chars
and 2 line display
void setup () {
lcd.init();
lcd.backlight();
lcd.setCursor(6,0);
lcd.print("HOLA");
lcd.setCursor(3,1);
lcd.print("BIOQUIMICOS");
Serial.begin(9600);
delay(5000);
}
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
Se conecta el I2C, el ultrasónico y la pantalla display al arduino
CONCLUSIÓN
En esta práctica se realizo un programa con el uso de un sensor de temperatura,

de sonido, el cual mandaran sus mensajes a una pantalla display.
PRACTICA #17 LCD, sensor de temperatura y foco
OBJETIVO
Escribir un programa que incluya el uso del sensor I2C, el LCD y un foco led, para hallar la
emperatura y sonido.
o 1 tarjeta de Arduino UNO

o Cable USB AB para Arduino
o 1 Protoboard
o I2C
o Luz led
o Resistencia
o Cables
o Pantalla display
CODIGO EN ARDUINO
// Include the libraries we need
#include <OneWire.h>
#include <DallasTemperature.h>
// Data wire is plugged into port 2 on the Arduino

#define ONE_WIRE_BUS 2
// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas
temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature.

DallasTemperature sensors(&oneWire);
#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);
// Check if reading was successful

if(tempC != DEVICE_DISCONNECTED_C)
{
Serial.print("Temperature for the device 1 (index 0) is: ");
Serial.println(tempC);
}
else
{
Serial.println("Error: Could not read temperature data");
}
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)
{
Serial.println("azul encendido");
}
else if (tempC>40)
{
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.
PRACTICA 18 USO DEL SENRO DE MOVIMIENTO, HUMEDAD Y

T6EMPERATURA
NOTA PARA EL PROFESOR: PARA ESTA PRACTICA NECESITAMOS DECIR QUE
NOSOTROS NO TENEMOS SENSOR DE TEMPERATURA Y HUMEDAD DEL KIT INICIAL,
POR LO QUE TUVIMOS QUE COMPRAR DOS DIFERENTES, YA QUE EL ORIGINAL I2C NO
LO ENCONTRAMOS EN MISANTLA NI MARTINEZ, POR LO QUE SOLO ENCONTRAMOS
OTROS DOS DIFERENTES, LOS CUALES SE ULTILIZARON A CONTINUACION, DE IGUAL
MANERA LA COMPRENSION DE QUE SOLO UNO DE NOSOTROS TIENE LAPTOP POR LO
QUE ALGUNAS APLICACIONES NO FUERON POSIBLES ABRIRSE EN ESTA LAPTOP,
PERO NOS ESFORZAMOS POR CUMPLIR EL OBJETIVO DE CREAR EL PROGRAMA A
PARTIR DE LO QUE TUVIMOS A NUESTRO ALCANCE.
El objetivo de esta práctica es realizar un programa que nos permita obtener la humedad,
temperatura y movimiento del ambiente a partir de varios elementos de Arduino.
• Display
• 1 Protoboard
Diagrama realizado en fritzing
CÓDIGOS (EN ESTE CASO REALIZAMOS DOS TRES CODIGOS)

PRIMER CODIGO (CONEXIÓN DE SENSOR DE TEMPERATURA Y HUMEDAD CON 3
ENTRADAS)
#include <LiquidCrystal.h>
#include "DHT.h"
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
#define PinSensor 2
#define Tipo DHT11
DHT dht(PinSensor, Tipo);
const int LEDPin= 13;
const int PIRPin= 3;
void setup() {
lcd.begin(16, 2);
dht.begin();
pinMode(LEDPin, OUTPUT);
pinMode(PIRPin, INPUT);
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
{
}
CODIGO CON SENSOR DE HUMEDAD Y TEMPERATURA DE 4 ENTRADAS

#include <DHT.h>
#include <DHT_U.h>
#include <DHT22.h>
#include "DHT.h"
// Uncomment whatever type you're using!

//#define DHTTYPE DHT11 // DHT 11
#define DHTTYPE DHT22 // DHT 22 (AM2302), AM2321
//#define DHTTYPE DHT21 // DHT 21 (AM2301)
// Connect pin 1 (on the left) of the sensor to +5V

// NOTE: If using a board with 3.3V logic like an Arduino Due connect pin 1
// to 3.3V instead of 5V!
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 4 (on the right) of the sensor to GROUND
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor
const int DHTPin = 5; // what digital pin we're connected to
DHT dht(DHTPin, DHTTYPE);

const int LEDPin= 13;
const int PIRPin= 2;
void setup() {
Serial.begin(9600);
Serial.println("DHTxx test!");
dht.begin();
pinMode(LEDPin, OUTPUT);
pinMode(PIRPin, INPUT);
void loop() {
// Wait a few seconds between measurements.
delay(2000);
// Reading temperature or humidity takes about 250 milliseconds!

float h = dht.readHumidity();
float t = dht.readTemperature();
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);
delay(50);
}
else
{
}
}
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
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
Proteus es una aplicación para la ejecución de proyectos de construcción de

equipos electrónicos en todas sus etapas: diseño del esquema electrónico,
programación del software, construcción de la placa de circuito impreso, simulación
de todo el conjunto, depuración de errores, documentación y construcción.
Sin la utilización de la suite Proteus, el proceso para construir un equipo electrónicobasado en
un microprocesador se compone de cinco etapas. Sólo al final del proceso somos capaces
de detectar los errores y cualquier problema exige volver aejecutar el ciclo completo:
El depurado de errores puede convertirse en una labor ardúa en tiempo y recursos,

lo que conlleva un alto coste económico.
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.
Los diferentes módulos que componen Proteus se pueden adquirir de forma

independiente añadiendo nuevas funcionalidades a medida que aumentan nuestras
necesidades de desarrollo y producción. Además, la capacidad de simular cada una
de las familias de microprocesadores también es objeto de adquisición por
separado. De esta manera podemos empezar adquiriendo unas funcionalidades
básicas e ir adquiriendo prograsivamente nuevas características aprovechando al
máximo nuestras inversiones en la herramienta y asegurar al máximo los costes de
inversión en el software.
Protoboard
Una placa de pruebas o placa de inserción (en inglés protoboard o breadboard) es

un tablero con orificios que se encuentran conectados eléctricamente entre sí de
manera interna, habitualmente siguiendo patrones de líneas, en el cual se pueden
insertar componentes electrónicos, cables para el armado, prototipado de circuitos
electrónicos y sistemas similares. Está hecho de dos materiales, un aislante,
generalmente un plástico, y un conductor que conecta los diversos orificios entre sí.
Uno de sus usos principales es la creación y comprobación de prototipos de circuitos
electrónicos antes de llegar a la impresión mecánica del circuito en sistemas de
producción comercial.
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.
El proceso de electroluminiscencia es mucho más eficiente que el proceso de

incandescencia de una bombilla con filamento ya que la energía se destina
directamente a generar luz y no a generar calor.
Resistencia
La resistencia es una medida de la oposición al flujo de corriente en un circuito

eléctrico.
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:
• Conductores: materiales que ofrecen muy poca resistencia, donde los

electrones pueden moverse fácilmente. Ejemplos: plata, cobre, oro y
aluminio.
• Aislantes: materiales que presentan alta resistencia y restringen el flujo de
electrones. Ejemplos: goma, papel, vidrio, madera y plástico.
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
Programar no es solo ingresar un código con ciertas especificaciones y esperar que

realice las acciones requeridas. Más allá de eso, la programación es un idioma más
y aprenderlo nos beneficia y ayuda a lograr una comunicación directa con el
ambiente tecnológico que nos rodea.
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.
Es la placa estándar y la más conocida y documentada. Salió a la luz en septiembre

de 2010 sustituyendo su predecesor Duemilanove con varias mejoras de hardware
que consisten básicamente en el uso de un USB HID propio en lugar de utilizar un
conversor FTDI para la conexión USB. Es 100% compatible con los modelos
Duemilanove y Diecimila. Viene con un Atmega328p con 32Kbytes de ROM para el
programa.
Este es el Arduino que vamos a usar en el curso.

Arduino Mega
Es con mucha diferencia el más potente de las placas con microcontrolador de 8

bits y el que más pines i/o tiene, apto para trabajos ya algo más complejos aunque
tengamos que sacrificar un poco el espacio. Cuenta con el microcontrolador
Atmega2560 con más memoria para el programa, más RAM y más pines que el
resto de los modelos.
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 con la mayor capacidad de procesamiento, basado en un microcontrolador

de 32 bit y arquitectura ARM: Atmel SAM3X8E ARM Cortex-M3 CPU. Este arduino
está alimentado a 3.3V y dado que gran parte de los shields, sensores, actuadores
para Arduino y compatible son a 5V lo limita, pero cada vez se ven más elementos
donde se puede elegir el voltaje entre 3.3 y 5V.
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.
Los Arduinos basados en el microcontrolador 32u4 permiten aparecer al Arduino

conectado al ordenador como un ratón o teclado nativo, simulando un dispositivo de
este tipo.
Arduino Leonardo ETH
Es un Arduino Leonardo con ethernet proporcionado por el controlador W5500. Se

trata de la versión actualizada del Arduino Ethernet.
Arduino Micro
También basado en el ATmega32u4 pero mucho más compacto.
Arduino Mini
Versión miniaturizada de la placa Arduino UNO basado en el ATMega328. Mide tan

sólo 30x18mm y permite ahorrar espacio en los proyectos que lo requieran. Las
funcionalidades son las misma que Arduino UNO. Necesita un programador para
conectarlo al ordenador
Arduino Yun
El Arduino Yun es un Arduino que es diferente a lo que son el resto de Arduino

porque además de llevar un microcontrolador, incorpora un Microprocesador MIPS
con un Sistema Operativo Linux embebido. La ventaja que aporta Arduino Yun y sus
derivados es que el microcontrolador y el microprocesador están conectado
mediante un puerto serie y además Arduino nos ofrece una serie de
herramientas/librerías que facilita la interconexión entre ellos.
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
Primero modelo de la familia MKR y heredero del Arduino Zero.
Arduino MKR1000 WIFI
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.
El ATSAMW25 está compuesto por tres principales bloques:
• SAMD21 Cortex-M0+ 32bit low power ARM MCU

• WINC1500 low power 2.4GHz IEEE® 802.11 b/g/n Wi-Fi (mismo que el wifi
101 shield)
• ECC508 CryptoAuthentication
¿Qué beneficios tiene para mí aprender a programar?
Imagina tener el poder de crear herramientas que te ayuden a hacer tu vida, y la de

otras personas que comparten tu necesidad, más sencilla. Eso es exactamente lo
que sucede con las aplicaciones, sitios, programas y todos aquellos software
exitosos: satisfacen una necesidad común.
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.
¿En qué ha ayudado la programación?
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
Podemos decir, sin miedo a equivocarnos, que la programación es la base del

futuro, la encargada de que la tecnología se siga desarrollando y de que aparezcan
inventos nuevos.
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 evolución de la programación nos permite disfrutar de calculadoras mejoradas

(como un ordenador), sino de miles de inventos nuevos que dejan con la boca
abierta cada vez que se ven. Un ejemplo es la inteligencia artificial, que es llevada
a cabo mediante el lenguaje de códigos utilizados en la programación.
Millones de informáticos en todo el mundo siguen estudiando y trabajando para

mejorar la inteligencia artificial. Para ello, sacan a la luz nuevos prototipos de toda
clase de dispositivos, como robots de cocina o máquinas que parecen disponer de
vida propia.
La programación en la industria
Se puede encontrar la programación en todo tipo de industrias, desde el

entretenimiento hasta la musical, sin dejar a un lado las que desarrollan softwares.
Saber utilizar bien un programa te permite darles a tus fotografías un toque
profesional o que un robot se encargue de realizar tu trabajo.
Las compañías más grandes a nivel mundial la utilizan a diario en el sector de la
logística o para ofertar sus productos y/o servicios por medio de diferentes métodos,
llegando a ser una de las grandes causas de ingresos.
La programación ha cambiado la forma en la que se ve el mundo. No solo promueve

la creatividad de las personas que la utilizan, sino que es de gran interés para toda
la población.

Cuadernillo Final

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Cuadernillo Final

Cargado por

Copyright:

Formatos disponibles

INSTITUTO TECNOLOGICO

LEIDI, ANA Y GIL

MISANTLA, VERACRUZ OCTUBRE 17, 2022.

Una parte importante en el proceso de diseño y desarrollo de circuitos electrónicos es la etapa

tareas de complejidad media para la manipulación de datos y la resolución de

problemas reales en los campos de la biología, la bioquímica, y la biología

A continuación se muestran diversas practicas que se desarrollaron el el curso de

• 1 Tarjeta Arduino UNO

• 1 Cable USB AB para Arduino

• Software IDE de Arduino

• Cables para conectar

• 1 led de color Rojo

DIAGRAMA REALIZADO EN FRITZING

pinMode(led,OUTPUT); //Declaro a la variable led como salida

delay(5000); //retardo en tiempo de 5 seg

digitalWrite(led,LOW); //apago led en forma

• Montar el circuito requerido como se muestra en la imagen anterior.

• Conectar un led a nuestra protoboard.

• Conectarle una resistencia 100Ω al cátodo del led .

• Conectar la otra terminal (ánodo) del led al Pin 9 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.

• Y finalmente probar el funcionamiento del circuito en Proteus 8.1 .

• 1 Tarjeta Arduino UNO

• 1 Cable USB AB para Arduino

• Software IDE de Arduino

• Software de Proteus 8.1

• Cables para conectar

2.- El led conectado al pin 12 de Arduino, permanece encendido durante un

4.- El led conectado al pin 10 de Arduino, permanece encendido durante un

5.- El led conectado al pin 9 de Arduino, permanece encendido durante un

PRACTICA #3 SEGUNDA PARTE OBJETIVO 5 LEDS

• 1 Tarjeta Arduino UNO

• 1 Cable USB AB para Arduino

• Software IDE de Arduino

• Software de Proteus 8.1

• Cables para conectar

delay(t1); //retardo en tiempo

delay(t1); //retardo en tiempo

delay(t1); //retardo en tiempo

delay(t1); //retardo en tiempo

delay(t1); //retardo en tiempo

delay(t1); //retardo en tiempo

delay(t1); //retardo en tiempo

delay(t1); //retardo en tiempo

delay(t1); //retardo en tiempo

delay(t1); //retardo en tiempo

1.- El led conectado al pin 13 de Arduino, se enciende y permanece encendido.

2.- El led conectado al pin 12 de Arduino, se enciende y permanece encendido

• 1 Tarjeta Arduino UNO

• 1 Cable USB AB para Arduino

• Software de Proteus 8.1

• Cables para conectar

DIAGRAMA REALIZADO EN FRITZING

//PROGRAMA #3 semaforo sencillo

* EL PROGRAMA CONSISTE EN EL CONTROL DE UNA SERIE DE LEDS

delay(5*t1); //retardo en tiempo

delay(2*t1); //retardo en tiempo

delay(7*t1); //retardo en tiempo

• Montar el circuito requerido como se muestra en la imagen anterior.

• Conectar tres leds a nuestra protoboard.

• Conectarle una resistencia 100Ω al cátodo de cada uno de los leds.

• Conectar los cables de corriente y tierra de nuestra Arduino a la protoboard.