Manual de Prácticas en Arduino Uno

INSTRUMENTACIÓN VIRTUAL
ELABORADO POR: ORTIZ MUÑOZ ERIKA DEL CARMEN
PROFESOR: PÉREZ JUAREZ OMARTIN

MENU
Práctica 1: Alto 100, Bajo 100
Práctica 5: Encender 10 veces y dejar apagado
Práctica 6: Encender 20 veces y dejar encendido el led
Práctica 7: Encender en altas de 2000, 1000, 100 y 10
Práctica 8: Habilitar pin 13 y dejar encendido a 2000ms; y pin 12 en 100ms e inversa
Práctica 9: Realizar corrimiento de 5 led´s de la siguiente forma: iniciando de izquierda a
derecha

Práctica 10: Realizar corrimiento de 5 led´s de la siguiente forma: iniciando de derecha
a izquierda
Práctica 11: Realizar corrimiento de 3 led´s de 5, de la siguiente forma: primer led, tercer
led y quinto led
Práctica 12: Realizar corrimiento de 3 led´s de 5, de la siguiente forma: el quinto led,
después el tercero led y por ultimo el primer led
Práctica 13: Realizar la unión de todas las prácticas a partir de la práctica 9 hasta la
práctica 12
práctica 12 pero diferente frecuencia
práctica 12, pero hacer que parpadeen 10 veces cada led
Práctica 16: Estrella fugaz
Práctica 17: Estrella fugaz de manera inversa
Práctica 18: Combinación de dos elementos, práctica 13 junto con la estrella fugaz

“PRÁCTICA #1: ALTO 100, BAJO 100”

OBJETIVO
Saber aprender a utilizar el Arduino Uno y a la vez también
el saber programar y conocer la codificación de la misma,
pero como también se sabe es la misma que se usa al
programar en C++ o C.

DESARROLLO
Fig. N°1: Se observa que el
led´s enciende a un tiempo de
0.1 segundo, o sea que
parpadea constantemente.
Fig. N°2: Se observa la codificación similar al
C++ y también el cambio de los milisegundos
que son de 100ms en alto y 100ms de bajo al
igual que da un total de 0.1 segundo.
Fig. Nº3: Diagrama en
flitzing.

DESARROLLO
CÓDIGO
// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 13;
void setup() {
pinMode(led, OUTPUT);
}
void loop() {
digitalWrite(led, HIGH);
delay(100);
digitalWrite(led, LOW);
delay(100);
}

CONCLUSIÓN
Aprendí y observe lo que hace al momento de que se cambian los
milisegundos en los altos y bajos, en este caso sería de 100ms de
alto y 100ms de bajo.
Observe también que al momento de hacer estos cambios el
parpadeo es consecutivamente, pero en mi caso lo probé con un led´s
para poder apreciar el encendido y apagado de este mismo.

OBJETIVO

DESARROLLO
led´s queda encendido sin
ningún momento de
parpadeo.
que son de 10ms en alto y 10ms de bajo, que
como se vio en la figura anterior, el led queda
sin ningún parpadeo o como quien dice queda
encendido en un tiempo indefinido.
flitzing.

DESARROLLO
CÓDIGO
// give it a name:
int led = 13;
void setup() {
}
void loop() {
delay(10);
delay(10);
}

CONCLUSIÓN
milisegundos en los altos y bajos, en este caso sería de 10ms de alto
y 10ms de bajo, en esta práctica el tiempo queda indefinido para que
se apague y vuelva a encender y como también aplique unas
conversiones, en este momento puede obtener que 10ms es igual a
0.01 segundo y que a la vez este segundo equivale 0.000166666 de
minuto o como se dice algo infinitivo.

OBJETIVO

DESARROLLO
led parpadea en cuestión de
milisegundos, pero al
momento que se activa el alto,
tarda en apagarse el led.
que son de 1000ms en alto y 100ms de bajo,
que como se vio en la figura anterior, el led
parpadea consecutivamente, pero tarda mas
encendido que apagado.
flitzing.

DESARROLLO
CÓDIGO
// give it a name:
int led = 13;
void setup() {
}
void loop() {
delay(1000);
delay(100);
}

CONCLUSIÓN
alto y 100ms de bajo, en esta práctica el parpadeo es consecutivo,
pero observe que cuando está en alto, la luz del led tarda un segundo
encendido y estando en bajo esta misma lo hace rápidamente el
apagado ya que solo dura 0.1 segundo.

OBJETIVO

DESARROLLO
Fig. N°1: Se observa que el led´s
parpadea en cuestión de
milisegundos, pero al momento
que se activa el alto, la luz se
enciende rápido y al estar
apagado tarda solo un segundo.
Fig. N°2: Se observa la codificación
similar al C++ y también el cambio de
los milisegundos que son de 100ms
en alto y 1000ms de bajo, que como
se vio en la figura anterior, el led
parpadea consecutivamente, pero
tarda más en el momento que se
encuentra apagado.
flitzing.

DESARROLLO
CÓDIGO
// give it a name:
int led = 13;
void setup() {
}
void loop() {
delay(100);
delay(1000);
}

CONCLUSIÓN
alto y 1000ms de bajo, en esta práctica el parpadeo es consecutivo,
pero observe que cuando está en alto, la luz del led no tarda mucho
encendido y estando en bajo tarda un segundo en estar apagado el
led para que pasando esa función se vuelva a poner en alto o
encendido.

“PRÁCTICA #5: HACER PARPADEAR 10 VECES UN LED
Y DEJAR APAGADO”

OBJETIVO
“PRÁCTICA #5: HACER PARPADEAR 10 VECES UN LED Y DEJAR APAGADO”

“PRÁCTICA #5: HACER PARPADEAR 10 VECES UN LED Y QUE QUEDE APAGADO”
DESARROLLO Fig. N°3: Se observa la codificación y
parpadea 10 veces
consecutivamente en cuestión de
milisegundos iguales, y después
quedar apagado el led.
también que esta función lo hace en un
tiempo de un segundo estando en alto y
bajo, o sea a lo que me refiero con esto
es que enciende un segundo y se queda
apagado en ese mismo tiempo, repitiendo
los códigos 10 veces y dándole un bajo al
final de 60000ms (un minuto) para que
esta misma se quede en función de
apagado.
NOTA: En
este caso se
hizo
repitiendo
las veces del
alto bajo.
flitzing.

DESARROLLO
CÓDIGO
int led = 13;
void setup() {
pinMode(led,
OUTPUT);
}
void loop() {
digitalWrite(led,
HIGH);
delay(1000);
digitalWrite(led,
LOW);
delay(1000);
NOTA: Como es largo
el programa, repetir
10 veces este paso,
hay otra forma de
realizar este programa
que es el “for” para
evitar un programa
largo.
delay(60000);
}
NOTA: Después del
proceso anterior, esta
ultima parte es el
tiempo de espera para
que el led quede
apagado y cerrar el
programa.

CONCLUSIÓN
En conclusión es que al momento de que parpadea 10 veces en un
alto y bajo que en este caso fueron de 1000 ms cada uno (un
segundo) esta hace las mismas funciones, y dándole también un
apagado de 1 min, o también conocido como un bajo de 60000ms y
después de esto nuevamente retornar la misma función nuevamente.

“PRÁCTICA #6: HACER PARPADEAR 20 VECES UN LED
Y DEJAR ENCENDIDO”

OBJETIVO
“PRÁCTICA #6: HACER PARPADEAR 20 VECES UN LED Y DEJAR ENCENDIDO”
programar en C++ o C y dejar al final que quede
encendido el led sin necesidad de que quede
parpadeando.

DESARROLLO Fig. N°3: Se observa la codificación y
Fig. N°1: Se observa que el led
parpadee 20 veces
consecutivamente en cuestión de
milisegundos iguales, y después
que quede encendido ese mismo.
bajo, o sea a lo que me refiero con esto
es que enciende un segundo y se queda
apagado en ese mismo tiempo,
repitiendo los códigos 20 veces y
dándole un alto al final de 60000ms (un
minuto) para que esta misma se quede
en función de encendido.
NOTA: En
este caso se
hizo
repitiendo
las veces del
alto bajo.
flitzing.

DESARROLLO
CÓDIGO
int led = 13;
void setup() {
pinMode(led,
OUTPUT);
}
void loop() {
digitalWrite(led,
HIGH);
delay(1000);
digitalWrite(led,
LOW);
delay(1000);
NOTA: Como es largo
el programa, repetir
20 veces este paso,
hay otra forma de
realizar este programa
que es el “for” para
evitar un programa
largo.
delay(60000);
}
NOTA: Después del
proceso anterior, esta
ultima parte es el
tiempo de espera para
que el led quede
encendido y cerrar el
programa.

CONCLUSIÓN
En conclusión es que al momento de que parpadea 20 veces en un
alto y bajo que en este caso fueron de 1000 ms cada uno (un
segundo) esta hace las mismas funciones, y dándole también un
encendido de 1 min, o también conocido como un alto de 60000ms y
después de esto nuevamente retornar la misma función nuevamente.

PRÁCTICAS #7: ENCENDER EN
2000, 1000, 100 Y 10

“PRÁCTICA #7: ENCENDER EN 2000, 1000, 100 Y 10”
OBJETIVO
programar en C++ o C y observar los cambios repentinos
que da el led al hacer las funciones de milisegundos.

DESARROLLO “PRÁCTICA #7: ENCENDER EN 2000, 1000, 100 Y 10”
Fig. N°1: Se observa que el led hace
sus cambios sucesivamente, en
primera en un tiempo de 2000ms en
alto y bajo de 1000, en segunda de un
alto de 1000ms y bajo de 1000ms,
prosiguiendo de un alto 100ms y bajo
de 1000ms y por ultimo un alto de
10ms y bajo de 1000ms. Después de
todo este proceso le marque una
espera de un minuto para que volviera
a iniciar el mismo proceso.
Fig. Nº2: Diagrama
en flitzing.
Fig. N°3: Se observa la codificación y
bajo, o sea a lo que me refiero con esto es
que enciende un segundo y se queda
apagado en ese mismo tiempo, repitiendo
los códigos 20 veces y dándole un alto al
final de 60000ms (un minuto) para que esta
misma se quede en función de encendido.

DESARROLLO
CÓDIGO
int led = 13;
void setup() {
}
void loop() {
delay(2000);
digitalWrite(led,LOW);
delay(1000);
delay(1000);
delay(1000);
delay(100);
delay(1000);
delay(10);
delay(1000);
//Momento en el que se da un tiempo de un minuto apagado
delay(60000);
}

CONCLUSIÓN
En conclusión es que al momento de que programa cada paso en la secuencia de
2000ms, 1000ms, 100ms y 10ms, esta hace el proceso al principio un poco
tardado, pero empezando del 100ms y 10ms lo procesa mas rápidamente, pero al
final también como usuario le di un tiempo estimado de un minuto ósea 60000ms
de espera para que nuevamente me iniciara el mismo funcionamiento o proceso.

PRÁCTICAS #8: HABILITAR PIN 13 Y DEJAR
ENCENDIDO A 2000ms; Y PIN 12 EN 100ms E
INVERSA

PRÁCTICAS #8: HABILITAR PIN 13 Y DEJAR ENCENDIDO A 2000MS; EN EL PIN 12 EN 100MS E INVERSA
OBJETIVO
programar en C++ o C y observar los cambios repentinos
que da el led al hacer las funciones de milisegundos y en
una misma codificación hacerlo inversamente.

DESARROLLO
Fig. N°1: Se observa que
el led hace sus cambios,
al principio es lento, pero
al momento que hace el
cambio al 100ms en el
pin 12 el parpadeo es
súper más rápido.
Fig. Nº2. Se nota el momento
en que el led que del pin 12 su
función de encendido y
apagado es más rápido que
en el pin 13.
Fig. N°3: Se observa la
codificación del como se
programo los dos pines
en altos y bajos.
Fig. N°4: Diagrama en flitzing.

DESARROLLO
CÓDIGO
int led = 13;
int led2 = 12;
void setup() {
pinMode(led2,
OUTPUT);
}
void loop() {
delay(2000);
delay(1000);
pinMode(led,OUTPUT);
digitalWrite(led2, HIGH);
delay(100);
digitalWrite(led2,LOW);
delay(1000);
pinMode(led2,OUTPUT);
//Inversa
delay(100);
digitalWrite(led2,LOW);
delay(1000);
delay(2000);
delay(1000);
pinMode(led,OUTPUT);
}

CONCLUSIÓN
En conclusión es que al momento de que se programan
los dos pines, en este caso el 13 y el 12, al principio es
lento el proceso en el 13 y en el pin 12 es rápido ya que
se maneja a un tiempo de 100ms o como se dice a 0.1s y
de la misma manera al inverso.

PRÁCTICA 9: REALIZAR CORRIMIENTO DE 5 LED´S
DE LA SIGUIENTE FORMA: INICIANDO DE
IZQUIERDA A DERECHA

PRÁCTICA 9: REALIZAR CORRIMIENTO DE 5 LED´S DE LA SIGUIENTE FORMA: INICIANDO DE IZQUIERDA A DERECHA
OBJETIVO

DESARROLLO
Fig. N°1: Se observa que
el led´s enciende a un
tiempo de 1 segundo, y
se apaga al segundo a la
vez para que encienda el
segundo led, y así
sucesivamente hasta
llegar al quinto led pero
de izquierda a derecha.
Fig. Nº2: Diagrama
elaborado en el
flitzing.
los milisegundos que son de 1000ms
en alto y 1000ms de bajo al igual que
da un total de 1 segundo.

DESARROLLO
CÓDIGO
const int led1 = 13;
const int led3 = 8;
const int led4 = 7;
const int led5 = 4;
void setup() {
delay(1000);
digitalWrite(led1, LOW);
delay(1000);
pinMode (led1, OUTPUT);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
}

CONCLUSIÓN
Observe lo que hace al momento de que se cambian los milisegundos en los altos y
bajos, en este caso sería de 1000ms de alto y 1000ms de bajo, o como quien dice
de un segundo.
Observe también que al momento de hacer estos cambios de izquierda a derecha y
de ahí sucesivamente empezar la misma frecuencia.

PRÁCTICA 10: REALIZAR CORRIMIENTO DE 5 LED´S DE LA
SIGUIENTE FORMA: INICIANDO DE DERECHA A IZQUIERDA

PRÁCTICA 10: REALIZAR CORRIMIENTO DE 5 LED´S DE LA SIGUIENTE FORMA: INICIANDO DE DERECHA A IZQUIERDA
OBJETIVO

DESARROLLO
enciende a un tiempo de 1 segundo,
y se apaga al segundo a la vez para
que encienda el segundo led, y así
sucesivamente hasta llegar al quinto
led pero de derecha a izquierda.
Fig. Nº2: Diagrama
elaborado en el
flitzing.
codificación similar al C++ y
también el cambio de los
milisegundos que son de 1000ms
en alto y 1000ms de bajo al igual
que da un total de 1 segundo.

DESARROLLO
CÓDIGO
const int led5 = 4;
const int led4 = 7;
const int led3 = 8;
void setup() {
pinMode(led5,
OUTPUT);
pinMode(led4,
OUTPUT);
pinMode(led3,
OUTPUT);
pinMode(led2,
OUTPUT);
pinMode(led1,
OUTPUT);
}
void loop() {
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
}

CONCLUSIÓN
de un segundo.
Observe también que al momento de hacer estos cambios de derecha a izquierda y

PRÁCTICA 11: REALIZAR CORRIMIENTO DE 3 LED´S DE
5, DE LA SIGUIENTE FORMA: 1º LED, 3er LED Y 5º LED

PRÁCTICA 11: REALIZAR CORRIMIENTO DE 3 LED´S DE 5, DE LA SIGUIENTE FORMA: 1º LED, 3er LED Y 5º LED
OBJETIVO

DESARROLLO
enciende a un tiempo de 1
segundo, y se apaga a la vez para
que encienda el tercer led, y así
hasta llegar al quinto led pero de
izquierda y derecha.
Fig. Nº2: Diagrama elaborado
en el flitzing.
codificación similar al C++ y
también el cambio de los
milisegundos que son de 1000ms
en alto y 1000ms de bajo al igual
que da un total de 1 segundo.

DESARROLLO
CÓDIGO
int led = 13;
int led2 = 8;
int led3 = 4;
void setup() {
pinMode(led,
OUTPUT);
}
void loop() {
delay(1000);
delay(1000);
pinMode (led, OUTPUT);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
}

CONCLUSIÓN
de un segundo.
Observe también que al momento de hacer estos cambios de izquierda a derecha
pero de manera en la cual solo encendiera los led´s 1,3 y 5; y de ahí sucesivamente
empezar la misma frecuencia.

PRÁCTICA#12: REALIZAR CORRIMIENTO DE 3 LED´S DE
5, DE LA SIGUIENTE FORMA: 5º LED, 3er LED Y 1º LED

PRÁCTICA#12: REALIZAR CORRIMIENTO DE 3 LED´S DE 5, DE LA SIGUIENTE FORMA: 5º LED, 3er LED Y 1º LED
OBJETIVO

DESARROLLO
enciende a un tiempo de 1 segundo, y
se apaga a la vez pero en esta ocasión
empezando con una secuencia a partir
del quinto led hacia el primero, o sea
de derecha a izquierda, y como quien
dice un led enciende, uno no, uno si, y
uno no, hasta llegar al último.
Fig. Nº2: Diagrama
elaborado en el
flitzing.
similar al C++ y también el cambio
de los milisegundos que son de
1000ms en alto y 1000ms de bajo al
igual que da un total de 1 segundo.

DESARROLLO
CÓDIGO
int led = 4;
int led2 = 8;
int led3 = 13;
void setup() {
pinMode(led,
OUTPUT);
}
void loop() {
delay(1000);
delay(1000);
pinMode (led, OUTPUT);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
}

CONCLUSIÓN
de un segundo.
Observe también que al momento de hacer estos cambios de derecha a izquierda
pero de manera en la cual solo encendiera los led´s 5, 3 y 1 o los pines 4, 8 y 12; y

PRÁCTICA 13: REALIZAR LA UNIÓN DE TODAS LAS
PRÁCTICAS A PARTIR DE LA PRÁCTICA 9 HASTA LA
PRÁCTICA 12

PRÁCTICA 13: REALIZAR LA UNIÓN DE TODAS LAS PRÁCTICAS A PARTIR DE LA PRÁCTICA 9 HASTA LA PRÁCTICA 12
OBJETIVO

DESARROLLO
Aquí como bien se dijo se
empezaría desde la práctica 9
hasta llegar a la 12, pero en una
sola, y con la misma frecuencia
que en este caso de 1 segundo
igual a 1000ms de tiempo en una
de las prácticas.
Práctica 9: De izquierda a
derecha.
Práctica 10: De derecha a
izquierda.
derecha pero encendiendo los
led´s 1, 3 y 5 o los pines 13, 8
y 4.

DESARROLLO
izquierda pero encendiendo
los led´s 5, 3 y 1 o los pines 4,
8 y 13.
Fig. Nº9: Diagrama
elaborado en el
flitzing.
frecuencia de los milisegundos que son
de 1000ms en alto y 1000ms de bajo al
igual que da un total de 1 segundo en
las 4 prácticas.

DESARROLLO
Continuació
n…
CÓDIGO
//Práctica 9
const int led3 = 8;
const int led4 = 7;
const int led5 = 4;
void setup() {
pinMode(led2,
OUTPUT);
pinMode(led3,
OUTPUT);
pinMode(led4,
OUTPUT);
pinMode(led5,
OUTPUT);
}
Void loop () {
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);

DESARROLLO
CÓDIGO
delay(1000);
delay(1000);
//Práctica 10
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
}
delay(1000);
delay(1000);
//Práctica 11
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
//Práctica 12
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);

CONCLUSIÓN
Aprendí todo lo que puede hacer este sistema de programación ya que en
este caso vi el cómo es posible juntar varios pasos en un solo programa y
haciendo la separación por medio de comentarios para también dar la
separación y no confundirse al momento en que se va realizando. Aunque
como también pude ver, la frecuencia es de un segundo en cada paso, la
velocidad viene dando lo mismo en el sentido que cada paso es rápido.

PRÁCTICA 12 PERO DIFERENTE FRECUENCIA

PERO, DIFERENTE FRECUENCIA
OBJETIVO

DESARROLLO
empezaría desde la
práctica 9 hasta llegar a la
12, pero en una sola, y con
la misma frecuencia que
en este caso de 1500ms
de alto y 150ms de bajo.
derecha.
izquierda.
y 4.

DESARROLLO
8 y 13.
Fig. Nº9: Diagrama
elaborado en el
flitzing.
similar al C++ y también el cambio
de frecuencia de los milisegundos
que son de 1500ms en alto y 150ms
de bajo.

CÓDIGO
//Práctica 9
const int led3 = 8;
const int led4 = 7;
const int led5 = 4;
void setup() {
pinMode(led2,
OUTPUT);
pinMode(led3,
OUTPUT);
pinMode(led4,
OUTPUT);
pinMode(led5,
OUTPUT);
}
Void loop () {
delay(1500);
delay(1500);
delay(150);
delay(1500);
delay(150);
delay(1500);
delay(150);
DESARROLLO
delay(1500);
delay(150);
//Práctica 10
delay(1500);
delay(150);
delay(1500);
delay(150);
delay(1500);
delay(150);
delay(1500);
delay(150);
delay(1500);
delay(150);
}

DESARROLLO CÓDIGO
delay(1000);
delay(1000);
//Práctica 11
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
//Práctica 12
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);

CONCLUSIÓN
separación y no confundirse al momento en que se va realizando. Aunque
como también pude ver, la frecuencia diferente en cada paso, la velocidad
viene dando lo mismo en el sentido que cada paso es rápido.

PRÁCTICA 12 PERO DEBEN DE PARPADEAR 10 VECES
CADA LED

PERO DEBEN DE PARPADEAR 10 VECES CADA LED
OBJETIVO
programar en C++ o C y también ver el cambio de cada
led o los parpadeos de esos mismos.

DESARROLLO
empezaría desde la práctica 9 hasta
llegar a la 12, pero en una sola y
con diferente velocidad o tiempo y a
la vez dándole a cada paso 10
parpadeos y de ahí pasar a la otra
frecuencia, que en este caso tiene
un alto de 1500ms de alto y 150ms
de bajo (1 seg y medio de alto y
0.15 de seg. De bajo).
Práctica 9: De izquierda a derecha.
izquierda.
y 4.

8 y 13.
Fig. Nº9: Diagrama
elaborado en el
flitzing.
DESARROLLO
frecuencia de los milisegundos que son
de 1500ms en alto y 150ms de bajo al
igual que da un total de 1 seg y medio
de alto y 0.15 de seg. en bajo en las 4
prácticas.
NOTA: En este
caso para no
poner la
codificación
larga puedes
repetir el
numero de
veces a cada led
y la otra forma
seria usando el
“for”.

DESARROLLO
Continuació
n…
NOTA: En cada led se le dará las veces de
copiado de altas y bajas.

DESARROLLO CÓDIGO
//Práctica 9
const int led3 = 8;
const int led4 = 7;
const int led5 = 4;
void setup() {
pinMode(led2,
OUTPUT);
pinMode(led3,
OUTPUT);
pinMode(led4,
OUTPUT);
pinMode(led5,
OUTPUT);
}
Void loop () {
//Led1
delay(1500);
//Led 2
delay(1500);
delay(150);
//Led 3
delay(1500);
delay(150);
delay(1500);
delay(150);
delay(1500);
delay(150);
//Práctica 10
delay(1500);
delay(150);
delay(1500);
delay(150);
delay(1500);
delay(150);
delay(1500);
delay(150);
delay(1500);
delay(150);
}

DESARROLLO CÓDIGO
delay(1000);
delay(1000);
//Práctica 11
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
//Práctica 12
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
NOTA: En cada led se le repite
todo el procedimiento, por
ejemplo cuando se pone el
comentario por ejemplo;
“//Led1
delay(1000);
delay(1000);
Repitiéndole 10 veces este paso
hasta pasar al led2 y

CONCLUSIÓN
misma y no confundirse, pero como en esta ocasión en cada led tuvo su
parpadeo de 10 veces para hacer el cambio a otra práctica en el momento
en que se va realizando. Aunque como también pude ver, la frecuencia es
de cambio de velocidad en los altos y bajos.

“PRÁCTICA #16: ESTRELLA FUGAZ”

OBJETIVO
led o los parpadeos de esos mismos y conocer la función
de una estrella fugaz por medio de los led´s.

DESARROLLO
Aquí la ilustración que se presenta es que tiene
la función de mostrar una cierta cantidad de
led´s o en este de caso de 11 led´s y hacer que
se hagan que los primeros led´s enciendan con
diferentes intensidades, o por decirse que el
final de la estrella sea baja la intensidad.
Fig. 1: Representa la imagen de los 11 led´s con
diferentes intensidades, o sea de menor a
mayor.
Fig. 2: Se observa la
codificación similar al
C++.
Fig. 3: Diagrama en
flitzing.

DESARROLLO
CÓDIGO
int pinArray [] = {
2,3,4,5,6,7,8,9,10,11,12 };
int controlLed = 13;
int waitNextLed = 100;
int tailLength = 4;
int lineSize = 11;
void setup()
{
int i;
pinMode (controlLed, );
for (i=0; i< lineSize; i++)
if (tailCounter == 0)
{
digitalWrite(pinArray[i-tailLength],LOW);
}
else
if (tailCounter > 0)
tailCounter--;
}
for (i=(lineSize-tailLength); i<lineSize; i++)
{
digitalWrite(pinArray[i],LOW);
delay(waitNextLed);
}
}
{
pinMode(pinArray[i], OUTPUT);
}
}
void loop()
{
int i;
int tailCounter = tailLength;
digitalWrite(controlLed, HIGH);
for (i=0; i<lineSize; i++)
{
digitalWrite(pinArray[i],HIGH);
delay(waitNextLed);

CONCLUSIÓN
Aprendí todo lo que puede hacer este sistema de programación ya
que en este caso observe el cómo se pueden realizar nuevos
sistemas de presentación que hay en el uso de la vida, como en este
caso que es una estrella fugaz con su cambio de intensidades donde
al final la luz se destellaba con menor intensidad y al principio es un
destello mayor pero con una inicialización de derecha a izquierda.

“PRÁCTICA #17: ESTRELLA FUGAZ DE MANERA INVERSA”

OBJETIVO
led o los parpadeos de esos mismos y conocer la función
de una estrella fugaz por medio de los led´s en forma
inversa.

DESARROLLO
se hagan que los primeros led´s enciendan con
diferente intensidades, o por decirse que el final
se similar a un rayo incandescente.
Fig. 1: Representa la imagen de los 11 led´s con
diferentes intensidades, o sea de menor a
mayor pero de manera inversa.
Fig. 2: Se
observa la
codificación
similar al C++.
Fig. 3: Diagrama
en flitzing.

DESARROLLO
CÓDIGO
int pinArray [] = {
12,11,10,9,8,7,6,5,4,3,2 };
int tailLength = 4;
int lineSize = 11;
void setup()
{
int i;
pinMode (controlLed, );
{
digitalWrite(pinArray[i-tailLength],LOW);
}
else
if (tailCounter > 0)
tailCounter--;
}
for (i=(lineSize-tailLength); i<lineSize; i++)
{
digitalWrite(pinArray[i],LOW);
delay(waitNextLed);
}
}
{
pinMode(pinArray[i], OUTPUT);
}
}
void loop()
{
int i;
int tailCounter = tailLength;
digitalWrite(controlLed, HIGH);
{
digitalWrite(pinArray[i],HIGH);
delay(waitNextLed);

CONCLUSIÓN
Aprendí todo lo que puede hacer este sistema de programación ya
que en este caso observe el cómo se pueden realizar nuevos
sistemas de presentación que hay en el uso de la vida, como en este
caso que es una estrella fugaz con su cambio de intensidades donde
al final la luz se destellaba mas resplandeciente y al principio es un
destello menor, dando una inicialización de izquierda a derecha.

“PRÁCTICA #18: COMBINACIÓN DE DOS ELEMENTOS,
PRÁCTICA 13 CON ESTRELLA FUGAZ”

“PRÁCTICA #18: COMBINACIÓN DE DOS ELEMENTO PRÁCTICA 13 CON ESTRELLA FUGAZ
OBJETIVO
programar en C++ o C, ver la dilatación de tiempo en la
que genera cada paso hasta llegar a la estrella fugaz en
un solo mando.

DESARROLLO
primero haga todo un proceso en un solo
mando, empezando desde el encendido de led a
partir de izquierda a derecha e inversamente,
después que solo se enciendan los led´s que
están en los pines 13, 8 y 4 e a la inversa,
después nuevamente el proceso con
velocidades diferentes y de ahí programado
nuevamente con 10 parpadeos en cada led,
para ahí finalizar con la estrella fugaz y a la
inversa a la vez.
Fig. 1: Representa la imagen de los 12 led´s,
realizando todo el proceso desde el principio en
un solo paso.
Fig. 2: Se observa la codificación similar al C++.

DESARROLLO “PRÁCTICA #18: COMBINACIÓN DE DOS ELEMENTO PRÁCTICA 13 CON ESTRELLA FUGAZ
Fig. 3: Diagrama en flitzing.

DESARROLLO
CÓDIGO int pinArray [] =
{2,3,4,5,6,7,8,9,10,11,12
};
const int led = 13;
const int led3 = 8;
const int led4 = 7;
const int led5 = 4;
int i;
int tailLength = 4;
int lineSize = 11;
void setup() {
pinMode(led2, OUTPUT);
pinMode (controlLed,
OUTPUT);
}
*Empieza la parte de la Estrella fugaz
pinMode (controlLed,
OUTPUT);
{
pinMode(pinArray[i],
OUTPUT);
}
{
int i;
int tailCounter =
tailLength;
digitalWrite(controlLed,
HIGH);
{
digitalWrite(pinArray[i],HI
GH); delay(waitNextLed);
{
digitalWrite(pinArray[i-void
loop() {
//Practica 9
digitalWrite(led,
HIGH);
delay(1000);
delay(1000);
pinMode(led,
OUTPUT);
digitalWrite(led2,
HIGH);
delay(1000);
digitalWrite(led2,
LOW);
delay(1000);
pinMode(led2,
OUTPUT);
digitalWrite(led3,
HIGH);
delay(1000);
Sucesivamente hasta
llegar a la práctica 13
else
if (tailCounter >
0)
tailCounter--;
}
for (i=(lineSize-tailLength);
i<lineSize; i++)
{
digitalWrite(pinArr
ay[i],LOW);
delay(waitNextLed
);
}
}
}

CONCLUSIÓN
Aprendí todo lo que puede hacer este sistema de programación en un
solo mando o programación sin la necesidad de hacer variedad de
programas, simplemente que en este caso varia las variables y en el
final fue que logre ver que por ejemplo en el pin 13, antes de realizar
el proceso de la estrella fugaz, esta misma queda encendida porque
ya no se declara la variable de que se apague.

Manual de Prácticas en Arduino Uno

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (18)

Destacado

Destacado (20)

Similar a Manual de Prácticas en Arduino Uno

Similar a Manual de Prácticas en Arduino Uno (20)

Último

Último (20)

Manual de Prácticas en Arduino Uno