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

3
 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()
{

4
 Practicas Arduino

estado=digitalRead(2)
if (estado) == HIGH)
{
digitalWrite(3, HIGH); // Se enciende el LED:
}
else
{
digitalWrite(3, LOW); // Se apaga el LED:
}
}

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);

5
 Practicas Arduino

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
}

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
 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
}

7
 Practicas Arduino

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();
}
}

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);

8
 Practicas Arduino

}
}

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);
}

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

9
 Practicas Arduino

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

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

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

y1

10
 Practicas Arduino

(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);
}

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); 

11
 Practicas Arduino

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);
}

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

12
 Practicas Arduino

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);   
}
}

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].

13
 Practicas Arduino

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)
analogWrite(led, valor);
}

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

serial

14
 Practicas Arduino

(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):
}

15
 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

16
 Practicas Arduino

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

LOW.

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);   
}
 

17
 Practicas Arduino

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

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

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);

18
 Practicas Arduino

  PORTD=0x7F;        //8
delay(1000);
  PORTD=0x7B;      //9
delay(1000);
}

19