Angel L.

Pomares Soliz Practicas Arduino

SALIDAS DIGITALES
pinMode(pin,OUTPUT);

PRACTICA 1 “ENCENDER UN LED conectado al PIN 6”

int LED = 6; // Se asigna a una variable el pin

void setup() // definen como funcionaran los pines

{
pinMode(LED,OUTPUT); // el pin 6 funcionara como salida
}
void loop() // Función donde se ejecuta el programa principal
{
digitalWrite(LED,1); // EL pin LED se le manda un alto para que encienda
}

PRACTICA 2: Encender y apagar un led en un cierto tiempo.

int LED =6;

void setup()
{
pinMode(LED,OUTPUT);
}

void loop()
{
digitalWrite(LED,1); // 1= HIGH
delay(300); // espera 500 ms
digitalWrite(LED,0); // 0= LOW
delay(300); // espera 500 ms
}

1
 Angel L. Pomares Soliz Practicas Arduino

PRACTICA 3: Rotación a la derecha.

Encender y apagar 4 leds secuencialmente, conectados a los pines 5, 6,7 y 8. Con un
tiempo de duración de encendido y apagado de 200 milisegundos.

Solución 1:
Int tiempo=200; // var tipo entero = 200
void setup() void loop()
{ {
pinMode(5,OUTPUT); secuencia();
pinMode(6,OUTPUT); }
pinMode(7,OUTPUT);
pinMode(8,OUTPUT); Solución 3:
} int leds[]={5,6,7,8}; // var tipo lista de valores
int tiempo=200;
void loop() int n=0;
{
digitalWrite(5,HIGH); void setup()
delay(tiempo); {
digitalWrite(5,LOW); for (n=0;n<4;n++)
delay(tiempo); {
digitalWrite(6,HIGH); pinMode (leds[n], OUTPUT);
delay(tiempo); }
digitalWrite(6,LOW); }
delay(tiempo); void secuencia()
digitalWrite(7,HIGH); {
delay(tiempo); for (n=0;n<4;n++) {
digitalWrite(7,LOW); digitalWrite (leds[n], HIGH);
delay(tiempo); delay (tiempo);
digitalWrite(8,HIGH); digitalWrite (leds[n], LOW);
delay(tiempo); delay (tiempo);
digitalWrite(8,LOW); }
delay(tiempo); }
} void loop()
{
Solución 2: secuencia();
int tiempo=200; }
int n;
void setup()
{
for (n=5;n<9;n++)
{
pinMode (n, OUTPUT);
}
}
void secuencia() // función
{
for (n=5;n<9;n++)
{
digitalWrite (n, HIGH);
delay (tiempo);
digitalWrite (n, LOW);
delay (tiempo);
}
}

2
Angel L. Pomares Soliz Practicas Arduino

PRACTICA 4: Rotación derecha /izquierda. Encender y apagar 7 leds secuencialmente con un

tiempo de 50 ms. Los leds deben estar conectados a los pines 5, 6, 7, 8, 9,10 y 11.

Sol1:

int n=0; for (n=6;n>=0;n--)

int tiempo=50; {
void setup() digitalWrite (leds[n],HIGH);
{ delay(tiempo);
for (n=5;n<12;n++) digitalWrite(leds[n-1],HIGH);
{ delay(tiempo);
pinMode(n,OUTPUT); digitalWrite (leds[n],LOW);
} delay(tiempo*2);
} }
void loop() { }
for (n=5;n<12;n++)
{
digitalWrite (n,HIGH);
delay(tiempo); Practica 5: Contadores
digitalWrite (n,LOW);
delay(tiempo); Emular un contador binario de 4 bits
} con salida por los pines 0 - 3
for (n=11;n>=5;n--)
{ int dato[] = {0,1, 2,3};
digitalWrite (n,HIGH); void setup()
delay(tiempo); {
digitalWrite (n,LOW); int i;
delay(tiempo); for(i=0; i<4 ;i++)
} pinMode(dato[i], OUTPUT);
} }
void loop()
Sol 2: Con otro efecto visual {
int i, j;
int leds[]={5,6,7,8,9,10,11}; // listas de valores for(i=0; i<16; i++)
(array) {
int n=0; for(j=0; j<4; j++)
int tiempo=30; {
void setup() if((I >> j)& 1)
{ digitalWrite(dato[j],HIGH);
for (n=0;n<7;n++) else
{ digitalWrite(dato[j],LOW);
pinMode(leds[n],OUTPUT); }
} delay(500);
} }
void loop() }
{
for (n=0;n<7;n++)
{
digitalWrite (leds[n],HIGH);
delay(tiempo);
digitalWrite(leds[n+1],HIGH);
delay(tiempo);
digitalWrite (leds[n],LOW);
delay(tiempo*2);
}

3
Angel L. Pomares Soliz Practicas Arduino

Entradas Digitales
digitalRead(buttonPin)

x = digitalRead(3); //asigna a x el valor lógico que lee en el pin 3

PRACTICA 1 : Encender el led conectado al pin 3, cuando activamos un pulsador pin 8.

const int pulsadorPin = 8; // Pin del pulsador

const int ledPin = 3; // Pin del Led
void setup()
{
pinMode(ledPin, OUTPUT);
pinMode(pulsadorPin, INPUT);
}
void loop()
{
if (digitalRead(buttonPin) == HIGH) // Si el valor del pin del pulsador es HIGH es que esta pulsado
{
digitalWrite(ledPin, HIGH); // Se enciende el LED:
}
else
{
digitalWrite(ledPin, LOW); // Se apaga el LED:
}
}

PRACTICA 2: Encender el led, cuando activamos un pulsador conectado al pin 8.

int estado = 0;
int salida = 0;
void setup()
{
pinMode(8, INPUT); // pin entrada
pinMode(3, OUTPUT); // Pin del Led

}
void loop()
{
estado=digitalRead(2)
if (estado) == HIGH)
{
digitalWrite(3, HIGH); // Se enciende el LED:
}
else
{
digitalWrite(3, LOW); // Se apaga el LED:
}
4
Angel L. Pomares Soliz Practicas Arduino

PRACTICA 3: Con un pulsador encender y apagar el LED.

int estado = 0;
int salida = 0;
void setup()
{
pinMode(8, INPUT); // pin entrada
pinMode(3, OUTPUT); // Pin del Led
}
void loop()
{
estado=digitalRead(8)
if (estado) == HIGH) // si está presionado
{
salida=1- salida; // memoriza el dato
delay(20); //anti rebote
}
If (salida==1)
{
digitalWrite(3, HIGH); // Se enciende el LED
}
else
{
digitalWrite(3, LOW); // Se apaga el LED:
}
}

PRACTICA 5: ENCENDER Y APAGAR UN LED CON 2 PUSH-BOTON

En este programa se encenderá un led y se apagara por medio de dos botones, el primer
botón encenderá el led y el segundo lo apagara. Es necesario 2 push boton

int LED = 4;
int boton = 5;
int boton2 = 6;

int x=0;

void setup()
{
pinMode(LED,OUTPUT);
pinMode(boton,INPUT);
pinMode(boton2,INPUT);
}

void loop() //Función donde se ejecuta el programa

{

if(digitalRead(boton)==1) //Se lee la entrada del pin botón y se compara

{
x=1; //Se asigna un valor a la variable x
}

5
Angel L. Pomares Soliz Practicas Arduino

if(digitalRead(boton2)==1)
{
x=0; //Se asigna un valor a la variable x
}

if(digitalRead(boton)==1 && digitalRead(boton2)==1)

{
x=0; //Se asigna un valor a la variable x
}

if(x==1) //Si la variable x es igual a 1 enciende el led

{
digitalWrite(LED,1); // EL pin LED se le manda un alto para que encienda
}

if(x==0) //Si la variable x es igual a 0 apaga el led

{
digitalWrite(LED,0);
}

6
Angel L. Pomares Soliz Practicas Arduino

Practica: El programa consiste en que al presionar el pulsador los leds cambien de secuencia, las
secuencias son las siguientes (1) Leds Encendidos (0) Leds apagado:
a) c)
00000001 00000001
00000010 00000011
00000100 00000111
. .
. .
10000000 11111111

b) d)
00011000 00001111
00111100 11110000
01111110 .
11111111 .

int saltar=0; // Variable que indica el numero de la secuencia a ejecutarse

void setup() {
pinMode(A0, INPUT); // pin de entrada
for(int i=2;i<=9;i++){ // pines de salida
pinMode(i, OUTPUT);
}
}

void loop() {
if (digitalRead(A0)==HIGH){ //Al presionar el pulsador
saltar++; // Cambia de secuencia
if (saltar >3){ //Solo hay 4 secuencias 0,1,2 y 3 al ser 3 . .
saltar=0; // Vuelve a secuencia 0
}
while (digitalRead(A0)==HIGH){ } // Mientras se pulsa no haga nada mas
}

if(saltar==0){ //Si es 1 inicie funcion de secuencia1

secuencia1();
}
if(saltar==1){ //Si es 2 inicie funcion de secuencia2
secuencia2();
}
if(saltar==2){ //Si es 3 inicie funcion de secuencia3
secuencia3();
}
if(saltar==3){ //Si es 4 inicie funcion de secuencia4
secuencia4();
}
}

7
Angel L. Pomares Soliz Practicas Arduino

void secuencia1(){
for (int i=2; i<=9; i++){ //Pin 2 al 9
digitalWrite(i, HIGH); // Prenda pin actual
digitalWrite(i-1,LOW); // Apage el Anterior
delay(50); // retardo
}
for (int i=9; i>=2; i--){ //Al contrario de la
digitalWrite(i, LOW); // anterior secuencia va de 9 a 2
digitalWrite(i-1,HIGH);
delay(50);
}
}

void secuencia2(){
int k=11; // inicializo una variable auxiliar K
for(int i=6; i<=9;i++){ //leo de 6 a 9
digitalWrite(i, HIGH); // prendo pin actual
digitalWrite(k-i, HIGH); // prendo pin de la diferencia 11-6 = 5
delay(50); //retardo
}
for(int i=9; i>=2;i--){ // Al contrario de lo anterior
digitalWrite(i, LOW);
digitalWrite(k-i, LOW);
delay(50);
}
}

void secuencia3(){
for(int i=2; i<=9; i++){
digitalWrite(i,HIGH);
delay(50);
}
for(int i=9; i>=2;i--){
digitalWrite(i,LOW);
delay(50);
}
}

void secuencia4(){
int k=11;
for(int i=2; i<=5;i++){
digitalWrite(i,HIGH);
digitalWrite(k-i,LOW);
}
delay(150);
for(int i=2; i<=5;i++){
digitalWrite(i,LOW);
digitalWrite(k-i,HIGH);
}
delay(150);
}

8
Angel L. Pomares Soliz Practicas Arduino

Operaciones lógicas
operaciones OR, AND e XOR en 3 leds

int pin_INa = 6; //
int pin_INb = 7; //
int LEDXOR = 8;
int LEDOR = 9;
int LEDAND = 10;

boolean INa, INb, OUT;

void setup() {
pinMode(pin_INa, INPUT); //pin como entrada
pinMode(pin_INb, INPUT); //pin como entrada
pinMode(LEDXOR, OUTPUT); //pin como salida
pinMode(LEDOR, OUTPUT); //pin como salida
pinMode(LEDAND, OUTPUT); //pin como salida
}
void loop() {
INa = digitalRead(pin_INa);
INb = digitalRead(pin_INb);

digitalWrite(LEDXOR, pin_INa ^ pin_INb ); // prenda el LEDXOR

digitalWrite(LEDOR, pin_INa | pin_INb ); // prenda el LEDOR
digitalWrite(LEDAND, pin_INa & pin_INb ); // prenda el LEDAND
}

9
Angel L. Pomares Soliz Practicas Arduino

Monitor Serial
Para iniciar la comunicación serial con Arduino utilizando el Monitor Serial debemos establecer
algunos comandos. Antes de nada, debemos configurar

void setup( ) {
Serial.begin(9600); //se especifica los baudios, normalmente 9600
}
dentro del void loop() podemos utilizar las siguientes funciones:

Serial.print(val); //imprime el valor de la variable val

Serial.println(val); //imprime el valor de val e inserta una línea nueva
Serial.print(“hola, amigos”); //imprime el texto hola, amigos
Serial.print('\t'); //imprime una tabulación
Serial.print(val,BASE); /*imprime el valor de la var val pero pasando la var en la base
que le especifiquemos: DEC,HEX, OCT, BIN, BYTE, del código ASCII */
x = Serial.available(); /*asigna a x el número de bytes disponibles en el puerto serie
que aún no han sido leídos.
Serial.available() ; devuelve un valor 0 hasta que lleguen nuevos datos al puerto
serie
y = Serial.read(); /*asigna a y el valor disponible en el puerto serie, que lo introducimos
desde el teclado del pc en la zona de textos del Serial Monitor */
Serial.flush(); /*porque los datos pueden llegar al puerto serie a más velocidad que
la del proceso del programa, Arduino */.

Cuando Arduino establece comunicación con el PC necesita utilizar los pines 0 y 1

(RX y TX), por lo tanto no debemos utilizarlos como entradas o salidas para nuestro
circuito.

PRACTICA Imprimir un caracter a través del puerto serie

a) void setup()
{
Serial.begin(9600);
}
void loop()
{
Serial.println(" HOLA MUNDO ");
}

b) void setup()
{
Serial.begin(9600);
}
void loop()
{
Serial.println(‘65’);
delay(1000);
}

10
Angel L. Pomares Soliz Practicas Arduino

PRACTICA: Lectura del pulsador con el monitor Serial

#define sw 2 //Define sw como 2

void setup()
{
pinMode(sw, INPUT); //Configura pin 2 como entrada
Serial.begin(9600); //Habilita el port Serial con 9600 bps
}
void loop()
{
if(digitalRead(sw)) //Si el botón fue presionado
{
Serial.println("Botón Presionado\n"); //Imprime en Monitor serial "Botón Presionado"
}
else
{
Serial.println("Botón libre\n"); // Imprime "Botón libre"
}
delay(250);

PRACTICA “CONTADOR CON PUSH-BOTON”

Contador por medio de un pulsador que incrementara el valor de una variable y este valor se
visualizara en el monitor de Arduino.

int conta=0; //Inicializacion del contador

void setup()
{
Serial.begin(9600); //Comunicacion Serial arduino
pinMode(4,INPUT); //Se define el pin 4 como entrada
}
void loop()
{
if(digitalRead(4)==1) // si es presionado el pulsador
{
conta=conta+1;
delay(200); // para que cuando se presione el pulsador este no incremente de mas
}
if(digitalRead(4)==0) //Cuando el botón es soltado mantiene el valor de la variable
conta=conta;
Serial.println(conta,DEC); //Impresion de la variable en el monitor de arduino
delay(300);
}

11
Angel L. Pomares Soliz Practicas Arduino

PRACTICA: Hacer que Arduino reciba datos seriales del PC y los interprete. Dichos datos los
enviaremos a través del monitor serial utilizando el teclado de nuestra computadora.

int datoinput;
void setup(){
Serial.begin(9600);
}
void loop(){
if (Serial.available()>0) //
{
datoinput=Serial.read();
// datoinput=datoinput-48;
Serial.println(datoinput);
}
}

PRACTICA: Activando LEDs por el puerto Serial Monitor

Utilizar el Monitor Serial para alterar o estado de los LEDs. Enviando a letra:
“R” (rojo) se activa el LED Rojo,
“G” (verde) se activa el el LED Verde
“Y”(amarillo) se activa el LED Amarillo.

char lectura;
#define ledRojo 8
#define ledVerde 9
#define ledAmarillo 10
void setup() {
Serial.begin(9600);
pinMode(ledRojo , OUTPUT);
pinMode(ledVerde, OUTPUT);
pinMode(ledAmarillo,OUTPUT);
digitalWrite (ledRojo, LOW);
digitalWrite (ledVerde, LOW);
digitalWrite ( ledAmarillo, LOW);
}
void loop() {
while (Serial.available() > 0) { //Verifica si háy algun dato en el puerto serial
lectura = Serial.read(); //Lee el dato y almacena

if (lectura == 'r' || lectura =='R' ) { //Si l a var lectura fuera igual a 'r' o 'R' Invierte el valor del LED Rojo
digitalWrite(ledRojo, !digitalRead(ledRojo ));
}
else if (lectura == 'v' || lectura =='V'){
digitalWrite(ledVerde, !digitalRead(ledVerde ));
}

else if (lectura == 'a' || lectura =='A'){

digitalWrite(ledAmarillo, !digitalRead(ledAmarillo ));
}
serial.println(lectura);
}
}
12
Angel L. Pomares Soliz Practicas Arduino

E/S Analógicas
Para leer: analogRead(pin), para escribir: analogWrite(pin, valor), se declaran por defecto.

Función analogRead(pin)
Lee el valor de voltaje en el pin analógico especificado por la variable pin (A0 a A5) y dependiente
del voltaje, devuelve un número entero entre 0 y 1023, siendo éste último el valor que se
le asigna a un voltaje de 5[V].

Función analogWrite(pin, valor)

Esta función genera un voltaje pseudo-analógico en el pin digital especificado, mediante una
onda cuadrada constante con el ciclo de trabajo especificado (0 = “off” y 255= “on”). Esta técnica
se conoce como onda PWM.

Permite generar un voltaje en los pines digitales marcadas como PWM (3, 5, 6, 9, 10 y 11).
Un valor 255 genera un voltaje de 5[V] y una valor 0, genera 0[V]

Practica : Variar continuamente el brillo del led conectado al pin 9 (PWM)

int ledPin = 9; // LED conectado al pin digital 9

int valor; // variable que representa el voltaje del led
void setup() {
pinMode (ledPin, OUTPUT);
}
void loop() {
for(valor=0; valor<=255; valor += 10)
{
analogWrite(ledPin, valor);
delay(100);
}
for(valor=255; valor>=0; valor -= 10){
analogWrite(ledPin, valor);
delay(100);
}
}

Practica : Entrada Analógica a partir de un potenciómetro

Se controla la frecuencia de parpadeo de un LED.

int pot = 0; // Pin A0 entrada para el potenciómetro

int led = 3; // Pin de salida para el LED
int valor=0;
void setup() {
pinMode(led, OUTPUT); // Declara el pin del LED como de salida
}
void loop() {
digitalWrite(led, HIGH); // Enciende el LED
valor=analogRead(pot)/4; // devuelve un valor entre 0 -1023 (dividir por 4 para ajustar la escala)

13
Angel L. Pomares Soliz Practicas Arduino

analogWrite(led, valor);
}

Practica: Determinar el valor introducido por el potenciómetro mediante la función serial

(enn paint buscar los valores , editar colores RGB)

const int ledR=3 / /pin salida digital

const int ledV=5
const int ledA=6

const int potR=0 // A0 pin entrada anológica

const int potV=1
const int potA=2

int R, V, A ;
void setup() {
serial.begin(9600);
pinMode(ledR, OUTPUT); // Declara el pin del LED como de salida
pinMode(ledV, OUTPUT);
pinMode(ledA, OUTPUT);
}
void loop() {

R=analogRead(potR)/4; // devuelve un valor entre 0 -1023 (dividir por 4 para ajustar la escala)
V=analogRead(potV)/4;
A=analogRead(potA)/4;

analogWrite(ledR, R);
analogWrite(ledV, V);
analogWrite(ledA, A);

serial.print(“Rojo :”);
serial.print(R);
serial.println(“ , “);

serial.print(“Verde :”);
serial.print(V);
serial.println(“ , “);

serial.print(“Azul :”);
serial.print(A);
serial.println(“ , “);

delay(500):
}

14
Angel L. Pomares Soliz Practicas Arduino

El Registro PORT (Puerto) en Arduino

Manejaremos en bajo nivel y de manera más rápida los contactos de entrada/salidas de Arduino.

Los pines usados en la placa Arduino (el ATmega8 y el ATmega168) poseen tres puertos (El
ATmega328 (Arduino Uno) usa la misma configuración de pines que el ATmega168):

 B (pines digitales del 8 al 13): Controla las salidas D8 a D13

 C (entradas analógicas) : Entradas analógicas A0 a A5
 D (pines digitales del 0 al 7): Controla las salidas D0 a D7

Cada puerto es controlado por tres registros, los cuales también están definidos como variables en
el lenguaje del Arduino.

 El registro DDRX, permite configurar si el pin es una entrada o una salida. X= B,C,D
 El registro PORTX controla si el pin está en nivel alto o en nivel bajo. X= B,C,D
 El registro PINX permite solo leer el estado de un pin que se ha configurado como entrada
usando la función pinMode(). X= B,C,D

Ej: DDRX

1 = OUTPUT 0 = INPUT

DDRX = B11111110; donde X es la letra del puerto a usar (BCD).

Si deseamos tener comunicación Serial debemos configurar:

DDRD = DDRD | B11111100;

Esta manera es más segura ya que configura los pines del 2 al 7 como salidas sin cambiar los
pines 0 y 1, que como mencionamos son RX y TX.

Ej: PORTX

1 =HIGH 0 = LOW

PORTX= B11111110; Los pines del 1 al 7 permanecerán encendidos (HIGH) y el pin 0 LOW.

15
Angel L. Pomares Soliz Practicas Arduino

Practica: Encender los leds del PORTD, durante dos segundos todos los leds enciendan, durante
dos segundos más se enciendan los impares, luego de dos más todos se apaguen.

void setup(){
DDRD= B11111100; //Utilizamos D porque es del 0 al 7 y B porque es Binario.
/*Esta instrucción es lo mismo que hacer esto:
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT); */
}
void loop(){
for (int contador=0; contador <3; contador ++){ // 3 casos.
switch(contador){
case 0:
PORTD= B11111111;//aquí encenderemos todos los leds
delay(2000);
case 1:
PORTD= B10101010;//aquí encenderemos solo los impares.
delay(2000);
case 2:
PORTD= B00000000;//aquí los apagaremos todos.
delay(2000);
}
}
}

Practica: Contador binario 0 al 15 por el portD, 4 leds

void setup()
{
DDRD=255; //se declara todo el puerto como salida
}
void loop()
{
for(int x=0;x<=15;x++) // contador ascendente
{

PORTD=x;
delay(500);
}

for(int y=15;y>=0;y--) // contador descendente

{
PORTD=y;
delay(500); // espera 500ms entre cada numero
}
}

16
Angel L. Pomares Soliz Practicas Arduino

Practica: Contador PORTB Y PORTD NIBLES

int contador = B00000000;

void setup()
{
DDRB = B00001111; //Configura los pines del 8 a 11 como salída (pin 8 lsb )
DDRD = B11110000; //Configura los pines del 4 a 7 como salída (pin 0 lsb)
}
void loop()
{
contador++; //Incrementa la variable
PORTD = B00001111 | contador;
PORTB = B11110000 | contador;
delay(200);
}

Display 7 segmentos
abc defg (g menos significativo, cátodo común)
000 0000

void setup()
{
DDRD=255; //se declara todo el puerto como salida
}
void loop()
{
PORTD=0x7E; //0
delay(1000);
PORTD=0x30; //1
delay(1000);
PORTD=0x6D; //2
delay(1000);
PORTD=0x79; //3
delay(1000);
PORTD=0x33; //4
delay(1000);
PORTD=0x5B; //5
delay(1000);
PORTD=0x5F; //6
delay(1000);
PORTD=0x70; //7
delay(1000);
PORTD=0x7F; //8
delay(1000);
PORTD=0x7B; //9
delay(1000);
}

17