TUTORIAL CÓDIGO ARDUINO

EJERCICIO 1. UN SÓLO LED PARPADEA, el LED 12

Se puede hacer de varias formas, aquí vemos una:

// Le damos un nombre al pin 12, nombre: led, es una variable enterna, creamos
variable
int led = 12;
void setup() {
// determinamos que nuestra variable led será de salida
pinMode(led, OUTPUT);
}

// escribimos el sketch, que lo hace en bucle loop

void loop() {
digitalWrite(led, HIGH); // enciende el LED (HIGH)
delay(1000); // espera durante un segundo (las unidades son
milisegundos)
digitalWrite(led, LOW); // apaga el LED haciendo nula la tensión
delay(1000); // espera de nuevo un segundo
}

ESTA SERÍA LA SEGUNDA MANERA

void setup() {

// initialize digital pin LED_BUILTIN as an output, , no creamos variable

pinMode(12, OUTPUT);

// the loop function runs over and over again forever

void loop() {

digitalWrite(12, HIGH); // turn the LED on (HIGH is the voltage level)

delay(1000); // wait for a second

digitalWrite(12, LOW); // turn the LED off by making the voltage LOW

delay(1000); // wait for a second

}
EJERCICIO 2. PONEMOS DOS LEDS A FUNCIONAR

Hacer un programa en Arduino que tenga dos LEDS (pin 12 y 13), y vayan haciendo
intermitencias entre sí: Es decir, un LED se enciende 1,5 segundos, el otro LED se
enciende otros 1, 5 segundos.

Si lo hacemos de la primera manera, entonces creamos dos variables enteras, que

se llamarán ledPin y ledPin2

int ledPin = 13; // LED que se encuentra en el pin 13

int ledPin2 = 12; // LED que se encuentra en el pin 12

void setup(){

pinMode(ledPin, OUTPUT); // El pin 13 será una salida digital

pinMode(ledPin2, OUTPUT); // El pin 12 será una salida digital

void loop(){

digitalWrite(ledPin, HIGH); // Enciende el LED en 13

delay(1500); // Pausa de 1,5 segundos

digitalWrite(ledPin, LOW); // Apaga el LED en 13

delay(1500);

digitalWrite(ledPin2, HIGH); // Enciende el LED en 12

delay(1500); // Pausa de 1,5 segundoS

digitalWrite(ledPin2, LOW); // Apaga el LED en 12

delay(1500); // Pausa de 1,5 segundos

}
También lo podemos hacer de otra manera, sin crear variables.

void setup() {

pinMode(13, OUTPUT);

pinMode(12, OUTPUT);

void loop() {

digitalWrite(13, HIGH);

delay(1500);

digitalWrite(13, LOW);

delay(1500);

digitalWrite(12, HIGH);

delay(1500);

digitalWrite(12, LOW);

delay(1500);

}
PROGRAMA 3.

Semáforo de LEDS

const int rojo=13; //el ánodo del led rojo irá al pin 13
const int amarillo=11; //el ánodo del led amarillo irá al pin 11
const int verde=9; //el ánodo del led verde irá al pin 9
void setup() {
pinMode(rojo,OUTPUT); //el pin al que va el ánodo del rojo es de salida
pinMode(amarillo,OUTPUT); //el pin al que va el ánodo del amar es de salida
pinMode(verde,OUTPUT); //el pin al que va el ánodo del verde es de salida
digitalWrite(rojo,LOW); //apagamos el led rojo por si estuviera encendido
digitalWrite(amarillo,LOW); //apagamos el led amar por si estuviera
encendido
digitalWrite(verde,LOW); //apagamos el led verde por si estuviera
encendido
}
void loop() {
digitalWrite(rojo,HIGH); //encendemos el led rojo...
delay(2000); //durante 2 s...
digitalWrite(rojo,LOW); //y lo apagamos
digitalWrite(verde,HIGH); //encendemos el led verde...
delay(2000); //durante 2 s...
digitalWrite(verde, LOW); //y lo apagamos
digitalWrite(amarillo,HIGH); //encendemos el led amarillo...
delay(500); //durante 0,5 s...
digitalWrite(amarillo,LOW); //y lo apagamos
}

MIRAD EN LA PÁGINA SIGUIENTE, QUE ESTÁ LA

IMAGEN DE CÓMO CONECTAR EL CIRCUITO
Ampliación. ¿Cómo harías para que el rojo permaneciese encendido 3 s, el
verde 2 s y el amarillo 0,3 s?

PROGRAMA 4.

VAMOS HACER UNA PAREJA DE LEDS QUE LUZCAN CON INTENSIDAD

LUMINOSA DIFERENTE, Y RANDOM, DURANTE UN TIEMPO aquí lo
ponemos 0,2 segundos (200 milisegundos, pero tú lo puede cambiar si
quieres)

tenéis que pillar dos LEDS, uno amaillo y otro rojo, si puede ser, y
conectarlo ambos a los pines analógicos esos que tienen un símbolo ~,
proponemos el 11 y el 9, pero puede ser otro

Mete este algoritmo (pasa la página)

const int ledAm = 11; //tiene que ser PWM~
const int ledRo = 9; //tiene que ser PWM~

void setup() {
pinMode(ledAm, OUTPUT);
pinMode(ledRo, OUTPUT);
}

void loop() {
analogWrite(ledAm,random(0,255));
analogWrite(ledRo,random(0,255)); delay(200);
}
PROGRAMA 5. EL SEMÁFORO COMPLEJO (condicional IF)

Con el mismo circuito físico que en la práctica anterior, deberemos cambiar el sketch de
Arduino para que funcione de la siguiente manera. La primera vez que se ejecute el void
loop(), los tres leds se- guirán la secuencia: verde (1 s), amarillo (1 s) y rojo (1 s). Cada
vez que se ejecute el bucle, el tiempo que permanecerá encendido cada led disminuirá
en 0,1 s. Cuando cada led permanezca encendido solo 0,1 s, el retardo permanecerá con
ese valor de 0,1 s, no disminuyendo más.
 Sketch.

const int rojo=13; //el ánodo del led rojo irá al pin 13
const int amarillo=11; //el ánodo del led amarillo irá al pin 11
const int verde=9; //el ánodo del led verde irá al pin 9
int retardo=1000; //cada led estará encendido inicialmente 1 s

void setup() {

pinMode(rojo,OUTPUT); //el pin al que va el ánodo del rojo es

de salida

pinMode(amarillo,OUTPUT); //el pin al que va el ánodo del amar

es de salida

pinMode(verde,OUTPUT); //el pin al que va el ánodo del verde es

de salida

digitalWrite(rojo,LOW); //apagamos el led rojo por si

estuviera encendido

digitalWrite(amarillo,LOW); //apagamos el led amar por si

estuvie encendido

digitalWrite(verde,LOW); //apagamos el led verde por si

estuviera encendido

void loop() {

digitalWrite(rojo,HIGH); //encendemos el led rojo…

delay(retardo); //durante el valor de retardo en ms…

digitalWrite(rojo,LOW); //y lo apagamos

digitalWrite(verde,HIGH); //encendemos el led verde…

delay(retardo); //durante el valor de retardo en ms…

digitalWrite(verde, LOW); //y lo

apagamos digitalWrite(amarillo,HIGH);
//encendemos el led amarillo…

delay(retardo); //durante 0,5 s…

digitalWrite(amarillo, HIGH); //encendemos el amarillo

digitalWrite(amarillo,LOW); //y lo apagamos

 if(retardo>100){

retardo=retardo-100;

PROGRAMA 6. COCHE FANTÁSTICO SIMPLIFICADO

Explicación. Se pretende que los 7 leds se vayan encendiendo y apagando de forma

cíclica, como en el co- che fantástico, según esta secuencia: 1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2.
El led 1 estará conectado al pin 1, el led 2 al pin 2 y así sucesivamente. La duración de
encendido de cada led será de 0,1 s. Si bien el sketch se puede realizar sin usar la
sentencia FOR, nosotros nos aprovecharemos de esta sentencia para que el sketch
ocupe bastantes menos líneas de código.
 Si escribimos:

for(i=5;i>=2;i--){ sentencias }
en la primera pasada del bucle i vale 5, en la segunda i vale 4, en la tercera i vale 3,
en la cuarta i vale 2 y después nos saldremos del bucle.

Si escribimos:

for(i
=1;
i<=
6;i
++)
{ d
igi
tal
Wri
te(
i,H
IGH
);
del
ay(
100
);
dig
ita
lWr
ite
(i,
LOW
);

en la primera pasada del bucle el pin 1 se pone en alto, se espera 0,1 s y el pin 1 se pone
en bajo. En la se- gunda pasada el pin 2 se pone en alto, se espera 0,1 s y el pin 2 se pone
en bajo. Así, hasta la sexta pasada, donde el pin 6 se pone en alto, se espera 0,1 s y el pin
6 se pone en bajo. Después salimos del bucle

Sketch
int i; //esta variable valdrá para numerar los pines y los
leds,...
//pues al pin 1 conectaremos el ánodo del led 1 y así.
void setup() {
for(i=1;i<=6;i++){ //vamos a realizar este bucle
6 veces
pinMode(i,OUTPUT); //el pin i es de salida
digitalWrite(i,LOW); //apagamos el led i en caso
de estar encendido
} //al terminar el bucle hemos declarado los pines del 1
al 6 ...
//como de salida y hemos apagado los seis leds
}
void loop() {
for(i=1;i<=6;i++){
digitalWrite(i,HIGH); //encendemos el led i ...
delay(100); //durante 0,1 s ...
 digitalWrite(i,LOW); //y luego lo apagamos
} // al terminar el bucle hemos hecho la secuencia de leds
1, 2, ..., 6
for(i=5;i>=2;i--){
digitalWrite(i,HIGH); //encendemos el led i ...
delay(100); //durante 0,1 s ...
digitalWrite(i,LOW); //y luego lo apagamos

} //al terminar el bucle hemos hecho la secuencia de leds

5,4, 3, 2.
}
 PRÁCTICA 7. Led a distinta intensidad (función analogWrite)

Explicación. Se pretende que un led pase de no lucir nada hasta lucir al máximo, luego
volverá a ir luciendo cada vez menos hasta que se pague y se vuelva a repetir el ciclo.
Los tiempos que tarde en pasar de apagado a totalmente encendido y viceversa son
irrelevantes siempre que lo podamos percibir claramente.

const int led = 11; //conectaré el ánodo del led al pin 11, que es
PMW~
int i; //usaremos la variable i para contar

void setup() {
pinMode(led, OUTPUT); //el pin al que conecto el ánodo del led es de
salida
analogWrite(led, 0); //apagamos el led inicialmente
}

void loop() {
for(i=0;i<=255;i++){
analogWrite(led,i); //escribimos en el led el valor i
delay(10); //sin este retraso no nos daríamos cuenta de que el led
…
//se está encendiendo paulatinamente

} //al término del bucle el led pasa de estar casi totalmente

encendido ...
for(i=254;i>=1;i--){
analogWrite(led,i);
delay(10);
} //al término del bucle el led pasa de estar apagado a totalmente
encendido

//a estar casi totalmente apagado

}

Ampliación. ¿Cómo harías para que una vez que esté totalmente encendido espere medio
segundo antes de empezar a apagarse y lo mismo para cuando esté totalmente apagado?

PRÁCTICA 8. Control de la luminosidad de un LED (función analogRead)

Explicación. Se pretende controlar la luminosidad de un led mediante un

potenciómetro usando Arduino. Si bien esto se puede hacer sin Arduino, al
incorporarlo vamos a poder saber qué voltaje le llega al led en cada momento. La idea
es que vamos a leer el voltaje de la pata central del potenciómetro, incluso pode- mos
sacar por pantalla dicho voltaje, y vamos a darle ese voltaje al led.
const int led = 11; //el ánodo del led al pin 11
const int pot = A0; //el terminal medio del potenciómetro al pin A0
int brillo; // nos dará el brillo del led (entre 0 y 255)

void setup() {
[Link](9600); //esta sentencia es necesaria para usar la
pantalla
pinMode(11, OUTPUT); //el pin al que conecto el ánodo del led
es de salida
//no es necesario declarar que el pin A0 es de entrada…
//pues los pines analógicos son de entrada automáticamente
}

void loop() {
brillo=analogRead(pot)/4; //convertimos el valor de lectura del
potenc…
//(entre 0 y 1023) en el valor de
escritura analógica…
//en el led (entre 0 y 255) y lo
guardamos en brillo
analogWrite(led,brillo); //encendemos el led con la luminosidad
brillo

[Link](brillo); //sacamos por la pantalla el valor de

brillo …
delay(100); //cada 0,1 s
}
Práctica 9. Luminosidad de led aleatoria (función RANDOM)

Explicación. En esta práctica vamos a hacer que la luminosidad con la que lucen los
dos led sea aleatoria, asemejándose a la luz de una vela. Para ello, usaremos la
función random, cuya sintaxis es:

random(mín, máx);
donde mín es el valor mínimo que puede tomar nuestro número aleatorio y máx es el
número máximo que puede valer nuestro número aleatorio

const int ledAm = 11; //tiene que ser PWM~

const int ledRo = 9; //tiene que ser PWM~

void setup() {
pinMode(ledAm, OUTPUT);
pinMode(ledRo, OUTPUT);

void loop()
{ analogWrite(ledAm,rand
om(0,25);
analogWrite(ledRo,random(0,255);
delay(200);

}
Ampliación. ¿Cómo modificarías el sketch para poder visualizar también por el serial los dos números
aleatorios generados en cada loop?

Práctica 10. Control de un piezo o altavoz (función TONE)

Explicación. Pretendemos controlar tanto el tono que suena en el piezo, como los sonidos y los silencios. En
particular, queremos que el piezo haga una escala con las notas: do, re, mi, fa, sol, la, si. Para
ello, tendremos que consultar en internet la frecuencia de cada nota.
const int piezo = 8;
void setup() {
pinMode(piezo, OUTPUT);

void loop() {
tone(piezo,261.63,100); //Do durante 0,1 s
delay(500);
tone(piezo,293.66,100); //Re durante 0,1 s
delay(500);
tone(piezo,329.63,100); //Mi durante 0,1 s
delay(500);
tone(piezo,349.23,100); //Fa durante 0,1 s
delay(500);
tone(piezo,392.00,100); //Sol durante 0,1 s
delay(500);
tone(piezo,440.00,100); //La durante 0,1 s
delay(500);
tone(piezo,493.88,100); //Si durante 0,1 s
delay(500);
}

PRÁCTICA 10. MÚSICA STAR WARS

Este montaje lo he sacado de aquí

Conectamos el zumbador al PIN 11, en lugar del 8, como antes.

int ZumbadorPin = 11; // definimos el pin al que conectaremos el zumbador.

/*definimos cada una de las frecuencias de las notas musicales.

c, d, e... son las notas en notación inglesa.
Cuando van acompañadas de la letra S significa que esa nota es sostenido.
Cuando van acompañadas de la letra H significa que esa nota está en una
octava superior (High).
*/

int c=261;
int d=294;
int e=329;
int f=349;
int g=391;
int gS=415;
int a=440;
int aS=455;
int b=466;
int cH=523;
int cSH=554;
int dH=587;
int dSH=622;
int eH=659;
int fH=698;
int fSH=740;
int gH=783;
int gSH=830;
int aH=880;

void setup()
{

pinMode(ZumbadorPin, OUTPUT); // definimos la variable ZumbadorPin como una salida.

void loop()
{
/* Empieza la melodia, para ello utilizamos la función tone con los
parámetros:
- el pin de salida, en nuestro caso el 11.
- la nota para la que ya hemos definido su frecuencia.
- la duración de la nota en ms.
Después de la función tone utilizamos la función delay para crear
un silencio del valor igual a la nota y así separar las notas unas
de otras (si no, no se marca bien la nota).
Añadimos los 50 ms simplemente porque nos parece que ese pequeño
aumento del silencio hace que se escuche mejor la melodía pero se
puede quitar sin problemas.
*/
tone(ZumbadorPin, a, 500);
delay(500+50);
tone(ZumbadorPin, a, 500);
delay(500+50);
tone(ZumbadorPin, a, 500);
delay(500+50);
tone(ZumbadorPin, f, 350);
delay(350+50);
tone(ZumbadorPin, cH, 150);
delay(150+50);

tone(ZumbadorPin, a, 500);
delay(500+50);
tone(ZumbadorPin, f, 350);
delay(350+50);
tone(ZumbadorPin, cH, 150);
delay(150+50);
tone(ZumbadorPin, a, 1000);
delay(1000+50);

tone(ZumbadorPin, eH, 500);

delay(500+50);
tone(ZumbadorPin, eH, 500);
delay(500+50);
tone(ZumbadorPin, eH, 500);
delay(500+50);
tone(ZumbadorPin, fH, 350);
delay(350+50);
tone(ZumbadorPin, cH, 150);
delay(150+50);

tone(ZumbadorPin, gS, 500);

delay(500+50);
tone(ZumbadorPin, f, 350);
delay(350+50);
tone(ZumbadorPin, cH, 150);
delay(150+50);
tone(ZumbadorPin, a, 1000);
delay(1000+50);

tone(ZumbadorPin, aH, 500);

delay(500+50);
tone(ZumbadorPin, a, 350);
delay(350+50);
tone(ZumbadorPin, a, 150);
delay(150+50);
tone(ZumbadorPin, aH, 500);
delay(500+50);
tone(ZumbadorPin, gSH, 250);
delay(250+50);
tone(ZumbadorPin, gH, 250);
delay(250+50);

tone(ZumbadorPin, fSH, 125);

delay(125+50);
tone(ZumbadorPin, fH, 125);
delay(125+50);
tone(ZumbadorPin, fSH, 250);
delay(250+50);
delay(250);
tone(ZumbadorPin, aS, 250);
delay(250+50);
tone(ZumbadorPin, dSH, 500);
delay(500+50);
tone(ZumbadorPin, dH, 250);
delay(250+50);
tone(ZumbadorPin, cSH, 250);
delay(250+50);

// virtuosismo :)))

tone(ZumbadorPin, cH, 125);

delay(125+50);
tone(ZumbadorPin, b, 125);
delay(125+50);
tone(ZumbadorPin, cH, 250);
delay(250+50);
delay(250);
tone(ZumbadorPin, f, 125);
delay(125+50);
tone(ZumbadorPin, gS, 500);
delay(500+50);
tone(ZumbadorPin, f, 375);
delay(375+50);
tone(ZumbadorPin, a, 125);
delay(125+50);

tone(ZumbadorPin, cH, 500);

delay(500+50);
tone(ZumbadorPin, a, 375);
delay(375+50);
tone(ZumbadorPin, cH, 125);
delay(125+50);
tone(ZumbadorPin, eH, 1000);
delay(1000+50);

tone(ZumbadorPin, aH, 500);

delay(500+50);
tone(ZumbadorPin, a, 350);
delay(350+50);
tone(ZumbadorPin, a, 150);
delay(150+50);
tone(ZumbadorPin, aH, 500);
delay(500+50);
tone(ZumbadorPin, gSH, 250);
delay(250+50);
tone(ZumbadorPin, gH, 250);
delay(250+50);

tone(ZumbadorPin, fSH, 125);

delay(125+50);
tone(ZumbadorPin, fH, 125);
delay(125+50);
tone(ZumbadorPin, fSH, 250);
delay(250+50);
delay(250);
tone(ZumbadorPin, aS, 250);
delay(250+50);
tone(ZumbadorPin, dSH, 500);
delay(500+50);
tone(ZumbadorPin, dH, 250);
delay(250+50);
tone(ZumbadorPin, cSH, 250);
delay(250+50);
 tone(ZumbadorPin, cH, 125);
delay(125+50);
tone(ZumbadorPin, b, 125);
delay(125+50);
tone(ZumbadorPin, cH, 250);
delay(250+50);
delay(250);
tone(ZumbadorPin, f, 250);
delay(250+50);
tone(ZumbadorPin, gS, 500);
delay(500+50);
tone(ZumbadorPin, f, 375);
delay(375+50);
tone(ZumbadorPin, cH, 125);
delay(125+50);

tone(ZumbadorPin, a, 500);
delay(500+50);
tone(ZumbadorPin, f, 375);
delay(375+50);
tone(ZumbadorPin, c, 125);
delay(125+50);
tone(ZumbadorPin, a, 1000);
delay(1000+50);

delay(2000); // dos segundos para volver a empezar.

}

PRÁCTICA 11: ACTIVAMOS ALARMA SONORA Y VISUAL CON UN BOTÓN

Materiales. 1 piezo, 1 led rojo, 1 resistencia de 220 Ω (rojo-rojo-marrón), 1 resistencia de 10 kΩ

(marrón- negro-rojo)

Explicación. Pretendemos que al pulsar instantáneamente un pulsador comience a sonar

alternativamente el piezo y a encenderse alternativamente el led. Cuando el piezo suene el led se
enciende y cuando el piezo no suene el led se apaga. Cada ciclo de piezo será así: el piezo suena a
una frecuencia de 220 Hz durante 0,1 s, luego deja de sonar durante 0,4 s. Como vemos, cada ciclo
dura 0,5 s. Al terminar diez ciclos, tanto el piezo como el led se apagan indefinidamente

En cada loop nos preguntaremos si el pulsador está accionado (función IF); si lo está, entonces
tendrán lugar los diez ciclos tal como se han descrito (función FOR), para lo que tendremos que
conectar un extremo del piezo a un pin digital, por ejemplo el 13, y el otro a tierra, el ánodo del led a
otro pin digital, por ejemplo el 9, y el cátodo a tierra protegido por la resistencia de 220 Ω.
const int piezo = 13; //piezo al pin 13

const int led = 9; //ánodo del led al pin 9

const int puls = 2; //pulsador al pin 2

void setup() {
pinMode(piezo, OUTPUT);
pinMode(led, OUTPUT);

pinMode(puls, INPUT);

void loop() {
if (digitalRead(puls)==HIGH){
for(int i=1;i<=10;i++){
tone(piezo,220);
digitalWrite(led,HIGH);
delay(100);
noTone(piezo);
digitalWrite(led,LOW);
delay(400);
}
}
 }

Ampliación. ¿Cómo harías para que en vez de 10 ciclos fuesen 15 ciclos y cada ciclo durase 20 ms
menos?
Práctica 12. Farola (resistencia LDR)

Materiales. 1 resistencia LDR, 1 resistencia de 10 kΩ (marrón-negro-rojo), 3 leds rojos y 3

resistencias de 220 Ω (rojo-rojo-marrón).

Explicación. Pretendemos que cuando haya muy poca luz se enciendan los tres leds, que
cuando haya poca luz se enciendan dos leds, que cuando haya un poco más de luz se
encienda solo uno y cuando haya mucha luz no se encienda ninguno. Para ellos necesitaremos
una resistencia LDR, pues su valor óhmico depende de la luz que incida sobre ella

const int led1 = 13;

const int led2 = 10;
const int led3 = 7;
int lectura;

void setup() {
pinMode(led1,OUTPUT);
pinMode(led2,OUTPUT);
pinMode(led3,OUTPUT);
}
void loop() {
lectura=analogRead(A0);
if (lectura<50){
digitalWrite(led1,HIGH);
 digitalWrite(led2,HIGH);
digitalWrite(led3,HIGH);
}
else if (lectura<200){
digitalWrite(led1,HIGH);
digitalWrite(led2,HIGH);
digitalWrite(led3,LOW);
}
else if (lectura<400){
digitalWrite(led1,HIGH);
digitalWrite(led2,LOW);
digitalWrite(led3,LOW);
}
else {
digitalWrite(led1,LOW);
digitalWrite(led2,LOW);
digitalWrite(led3,LOW);
}
delay(500);
}

PRÁCTICA 12. EMPEZAMOS A USAR UN SERVO

Todos deben tener 3 cables. Uno irá a tierra, otro a la alimentación de 5 Voltios y el tercero a
un pin PWM
Para incorporar la librería tenemos que ir a Programa/Include Library/Servo.
// Incluímos la librería para poder controlar el servo
#include <Servo.h>

// Declaramos la variable para controlar el servo

Servo servoMotor;

void setup() {
// Iniciamos el monitor serie para mostrar el resultado
[Link](9600);

// Iniciamos el servo para que empiece a trabajar con el pin 9

[Link](9);
}

void loop() {

// Desplazamos a la posición 0º
[Link](0);
// Esperamos 1 segundo
delay(1000);
 // Desplazamos a la posición 90º
[Link](90);
// Esperamos 1 segundo
delay(1000);

// Desplazamos a la posición 180º

[Link](180);
// Esperamos 1 segundo
delay(1000);
}
PRÁCTICA 13. MANEJAMOS UN SERVO CON UN POTENCIÓMETRO

Vamos a mover 180 grados un servo moviendo un potenciómetro

PRIMERO HACEMOS ESTE PROGRAMA, EN EL QUE EL SERVO SE MUEVE SÓLO

#include <Servo.h> // Incluir la librería Servo
Servo servo1; // Crear un objeto tipo Servo llamado servo1
int angulo = 0 ;

void setup()
{
[Link](9) ; // Conectar servo1 al pin 9
}

void loop()
{
for(angulo = 0; angulo <= 180; angulo += 1) //incrementa angulo 1 grado
{
[Link](angulo);
delay(25);
}
for(angulo = 180; angulo >=0; angulo -=1 ) //decrementa angulo 1 grado
{
[Link]( angulo );
delay(25);
}
}
Y , AHORA SÍ, HACEMOS ESTE DONDE EL SERVO SE MUEVE MUY POCO A POCO CUANDO YO
MUEVO EL POTENCIÓMETRO

#include <Servo.h>
Servo servo1;

int servopin = 9; // pin 9 para el servo

int angulo = 0; // de inicio del ángulo es 0 del servo
int pot = A0; // pin A0 para el potenciómetro
int potvalue=0; // de inicio el valor el potenciómetro es 0
void setup() {
[Link](servopin);
pinMode (pot,INPUT); //determinamos que el potenciómetro es una variable de entrada
[Link](angulo); // determinamos que el servo va a describir ángulos
}

void loop() {
potvalue= analogRead(pot); // determinamos que el valor del potenciómetro es analógico
angulo=map(potvalue,0,1023,0,180); // con eta función convertimos los valores del
potenciometro a los valores de ángulo del servo
[Link](angulo);
delay(10); // delay de 10 ms
}
PRÁCTICA 14. MOVEMOS UN SERVO CON UN SENSOR ANALÓGICO

En este caso la señal la conectamos al pin A0, las otras dos patillas son evidentes

Y el servo lo conectamos

Y el servo lo conectamos al pin 9 así

#include <Servo.h>

Servo miservo;

void setup() {
// put your setup code here, to run once:
pinMode(A0, INPUT); // inicia el pin A0
[Link](9); // servo conectado al pin 9
}

void loop() {
// put your main code here, to run repeatedly:
int val = analogRead(A0);//leer el sensor analógico conectado al PIN 0
int angle = map(val, 0, 1023, 0, 180); // convertir la lectura en grados
[Link](angle); //moverse el servo esos grados
}
PRÁCTICA 15. MOVEMOS UN SERVO CON DOS BOTONES

CON EL DE LA DERECHA SUBIMOS Y CON EL DE LA IZQUIERDA BAJAMOS

#include <Servo.h>
Servo servo1;

int servopin = 8;
int angulo = 0;
int buttonPin1 = 6;
int buttonPin2 = 7;
int buttonState1 = 0;
int buttonState2 = 0;

void setup() {
[Link](servopin);
pinMode(buttonPin1, INPUT);
pinMode(buttonPin2, INPUT);
[Link](angulo);
}

void loop() {
buttonState1 = digitalRead(buttonPin1);
buttonState2 = digitalRead(buttonPin2);
if (buttonState1 == HIGH)
{
angulo++;
if (angulo >= 180)
{
angulo = 180;
}
}

if (buttonState2 == HIGH)
{
 angulo--;
if (angulo <= 0)
{
angulo = 0;
}
}
[Link](angulo);
delay(10);

PRÁCTICA 16.- SERVO CON JOYSTICK

#include <Servo.h> // Librería para controlar el servomotor

Servo servo; // variable que tomará el valor de la posición del servomotor
void setup() {
[Link](2); // Se coloca el servo en el pin 2
}
void loop() {
int val = analogRead(0); // se agrega variable que tomará el valor que le mandara el joystick a
través de la entrada analógica A0
val = map(val, 0, 1023, 0, 180); // Conversión de valores
[Link](val); // se manda la señal al servo
delay(15); // espera en milisegundos para que detecte la señal
PRÁCTICA 17. Control de un servo 2

Materiales. 1 servo, 1 condensador electrolítico de 100 µF, 2 pulsadores y 2 resistencias de 10

kΩ (marrón- negro-naranja).

Explicación. Pretendemos controlar un servo a través de dos pulsadores. Cuando pulsemos el

primero pero no el segundo, el servo irá a la posición de la izquierda (0°). Cuando pulsemos el
segundo pero no el primero, el servo irá a la posición de la derecha (180°). En caso contrario a
los dos anteriores, el servo irá a la posición central (90°).
#include <Servo.h> //Carga la librería para trabajar con servos
const int pinIzdo = 2; //el pulsador que mueve a 0º va al pin de lectura 2
const int pinDcho = 3; //el pulsador que mueve a 180º va la pin de lectura 3
Servo servito; //Declaramos un objeto tipo Servo llamado servito
int movIzdo=LOW; //Valdrá HIGH cuando apretemos el pulsador que mueve a 0º
int movDcho=LOW; //Valdrá IGH cuando apretemos el pulsador que mueve a 180º

void setup() {

[Link](9); //servito está conectado al pin 9

pinMode(pinIzdo, INPUT);
pinMode(pinDcho, INPUT);
 }
void loop() {
movIzdo=digitalRead(pinIzdo);
movDcho=digitalRead(pinDcho);
if ((movIzdo==HIGH)&&(movDcho==LOW)){
[Link](0);
}
else if ((movIzdo==LOW)&&(movDcho==HIGH)){
[Link](180);
}
else {
[Link](90);
}
delay(20);
}

PRÁCTICA 18. Control del sensor de ultrasonidos II

Materiales. 1 sensor de ultrasonidos HC-SR04, 1 piezo.

Explicación. Esta práctica es una continuación de la anterior. Aquí vamos a simular la alarma que
tienen los coches en su parte trasera cuando perciben un objeto cerca. Seguiremos usando nuestro
sensor de ultrasonidos HC-SR04.

Lo que se pretende es que cuando un objeto esté a una distancia de 20 cm empiece a sonar el piezo
intermitentemente con una frecuencia de 261.63 Hz durante 50 ms y que pause durante 600 ms.
Cuanto más cerca esté el objeto más cortas serán las pausas, de manera que cuando el objeto esté a 2
cm la pausa sea tan solo de 50 ms. Así, para calcular los retardos usaremos la función map verificando
que cuando la distancia sea de 20 cm la pausa sea de 600 ms y cuando la distancia sea de 2 cm la pausa
sea de 50 ms.
const int pecho = 2; //la pata echo del CI va al pin 2
const int ptrig = 3; //la pata trigger del CI va al pin 3
const int piezo = 13; //el piezo al pin 13
int duracion, distancia; //para calcular distacia
void setup() {
[Link](9600); //inicia el puerto serial
pinMode(pecho, INPUT); //define el pin 2 como entrada (pecho)
pinMode(ptrig, OUTPUT); //define el pin 3 como salida (ptrig)

void loop() {
digitalWrite(ptrig, LOW); //al comenzar el loop el trigger debe estar en
LOW
delay(2);
digitalWrite(ptrig, HIGH); //genera el pulso de trigger por 0,01 ms
delay(0.01);

digitalWrite(ptrig, LOW);

duracion = pulseIn(pecho, HIGH); //tiempo de ida y vuelta en

microsegundos
distancia = (duracion/2)*0.034; //distancia al objeto en centímetros

delay(2); //para darle tiempo

if ((distancia >= 500)||(distancia < 0)){ //si la distancia es mayor de 5 m

[Link]("----------"); //... o menor a 0 no mide nada

else{

[Link](distancia
);
[Link](" cm");
if(distancia<=20){
tone(piezo,261.63,50);
delay(map(distancia,2,20,50,600));

Ampliación. ¿Cómo harías para que cuando la distancia fuese menor o igual a 10 cm también se
encendiera un led?
PRÁCTICA 19. PROGRAMAMOS EL DISPLAY DE 7 SEGMENTOS

[Link]

PRÁCTICA 20. PROGRAMAMOS EL DISPLAY DE 4 DÍGITOS

[Link]

PRÁCTICA 21. práctica con la matriz LED 8 x 8

[Link]

PRÁCTICA 22. DISPLAY LCD PANTALLA DE CRISTAL LÍQUIDO

[Link]
[Link]