Cronómetro de décimas de segundo - Arduino

/*REALIZAR CRONOMETRO CON DOS DISPLAY DE 7 SEGMENTOS.
 EL CRONOMETRO MOSTRARA LAS DECIMAS DE SEGUNDO Y
 AUTOMATICAMENTE SE REINICIARA*/

#define TIME 100/*Definiremos el tiempo que va a transcurrir entre

cada numero que muestra el display*/

int matriz[10][7]={
  {
    1,1,1,1,1,1,0                        }//numero 0
  ,
  {
    0,1,1,0,0,0,0                        }//1
  ,
  {
    1,1,0,1,1,0,1                        }//2
  ,
  {
    1,1,1,1,0,0,1                        }//3
  ,
  {
    0,1,1,0,0,1,1                        }//4
  ,
  {
    1,0,1,1,0,1,1                        }//5
  ,
  {
    1,0,1,1,1,1,1                        }//6
  ,
  {
    1,1,1,0,0,0,0                        }//7
  ,
  {
    1,1,1,1,1,1,1                        }//8
  ,
  {
    1,1,1,1,0,1,1                        }//9
};

void setup()
{

  for(int i=0; i<14; i++)//todas
  {
    pinMode(i, OUTPUT);//declarar como salida
  }
  pinMode(A5, OUTPUT);/*El punto lo metemos en una entrada analogica

  porque ya no hay mas digitales*/

}void loop()

{
  digitalWrite(A5, HIGH);//El punto del display 1 estara siempre encendido

  /*------------------------DISPPLAY 1-------------------------*/
  for(int num=0; num<10; num++)//repetir 9 veces 
  {
    for(int i=0; i<7; i++)//i representa cada led del display de la izquierda
    {
      if(matriz[num][i]==1)//si en el numero[0] led[2]==1, enciendele si no apagale
        digitalWrite(i, HIGH);
      else 
        digitalWrite(i, LOW);
    }
    /*--------------------------DISPLAY 2-------------------------*/
    for(int num=-1; num<9; num++) 
    {
      for(int i=7; i<14; i++)//i representa cada led del display de la derecha
      {
        if(matriz[num][i]==1)//si en el numero[0] led[2]==1, enciendele si no apagale
          digitalWrite(i, HIGH);
        else 
          digitalWrite(i, LOW);
      }
      delay(TIME);//entre numero y numero espera 1 segundo
    }  
  }
}

Video -> https://www.youtube.com/watch?v=me2d_iVtzKI

Semaforo con segundero - Arduino

/*PROGRAMA EN EL CUAL UN DISPLAY DE 7 SEGMENTOS

 CUENTA LOS SEGUNDOS CUANDO UN SEMAFORO ESTA EN VERDE
 Y EN ROJO*/

/*DISPLAY*/
int matriz[11][7]={
  {
    1,1,1,1,1,1,0          }//numero 0
  ,
  {
    0,1,1,0,0,0,0          }//1
  ,
  {
    1,1,0,1,1,0,1          }//2
  ,
  {
    1,1,1,1,0,0,1          }//3
  ,
  {
    0,1,1,0,0,1,1          }//4
  ,
  {
    1,0,1,1,0,1,1          }//5
  ,
  {
    1,0,1,1,1,1,1          }//6
  ,
  {
    1,1,1,0,0,0,0          }//7
  ,
  {
    1,1,1,1,1,1,1          }//8
  ,
  {
    1,1,1,1,0,1,1          }//9
};

/*SEMAFORO*/
int rojo=10;      //pin al que vamos a conectar el led rojo
int amarillo=11;  //pin al que vamos a conectar el led amarillo
int verde=12;     //pin al que vamos a conectar el led verde

void setup()
{
  /*---------------DISPLAY-----------------*/
  for(int i=2; i<9; i++)//desde entrada 2 a la 9 
  {
    pinMode(i, OUTPUT);//declarar como salida
  }
  /*---------------SEMAFORO-------------------*/
  pinMode(rojo,OUTPUT);   //declaramos pin rojo como salida
  pinMode(amarillo,OUTPUT);//declaramos el pin amarillo como salida
  pinMode(verde,OUTPUT);   //declaramos el pin verde como salida  
}

void loop() //bucle
{ 
  /*--------------SEMAFORO-------------------*/
  digitalWrite(rojo,HIGH); //encendemos el led rojo
  delay(0);  //esperamos 0 segundos

  /*----------DISPLAY-----*/
  for(int num=5; num>=0; num--)
  {
    for(int i=0; i<7; i++)
    {
      if(matriz[num][i]==1)
        digitalWrite(i+2, HIGH);
      else
        digitalWrite(i+2, LOW);
    }
    delay(1000);
  }
  /*------------------------*/
  digitalWrite(rojo,LOW);  //apagamos el led rojo
  delay(0);               //no hay espera

  /*--------------------SEMAFORO-----------------*/
  digitalWrite(verde,HIGH); //encendemos el led verde
  delay(0);             //esperamos 0 segundos
  /*----------DISPLAY------------*/
  for(int num=5; num>=0; num--)
  {
    for(int i=0; i<7; i++)
    {
      if(matriz[num][i]==1)
        digitalWrite(i+2, HIGH);
      else
        digitalWrite(i+2, LOW);
    }
    delay(1000);
  }
  /*-------------------------------*/
  digitalWrite(verde,LOW);  //apagamos el led verde
  delay(0); //no hay espera


  /*----------SEMAFORO--------------*/
  digitalWrite(amarillo,HIGH); //encendemos el led amarillo
  delay(1500);                 //esperamos segundo y medio
  digitalWrite(amarillo,LOW);  //apagamos el led amarillo
  delay(0);                  //esperamos medio segundo
}

Video de funcionamiento: video

Encender un led con un botón - Arduino

//Encender un led con un boton

const int led=13;
const int boton=8;

int estBot=0; //apagado

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

void loop()
{
  estBot=digitalRead(boton);//leer a ver si el boton esta apagado o encendido
  
  if(estBot == HIGH)
    digitalWrite(led, HIGH);
  else
    digitalWrite(led, LOW);
}

Vídeo de funcionamiento: video

Control potenciometro - Arduino

Hoy realizaremos una tarea con un display, esta vez igual que la anterior consistirá en hacer que el display recorra los números del 1 al 9 pero manejándolo con un potencómetro.

Un potienciómetro es una resistencia variable mecánica, esta nos va a permitir mostrar en el display unos determinados números dependiendo del valor que demos a esta resistencia. Por lo tanto el programa será de la siguiente manera:

**NOTA: Al final de la entrada os dejaré un video del funcionamiento**

const int analogPin = A0;
int value;      //variable que almacena la lectura analógica del potienciometro
int num;   //posicion del potenciometro en tanto por ciento

int matriz[10][7]={//leds que se tienen que encender para cada numero (0-9)

  {
    1,1,1,1,1,1,0      }
  ,
  {
    0,1,1,0,0,0,0      }
  ,
  {
    1,1,0,1,1,0,1      }
  ,
  {
    1,1,1,1,0,0,1      }
  ,
  {
    0,1,1,0,0,1,1      }
  ,
  {
    1,0,1,1,0,1,1      }
  ,
  {
    1,0,1,1,1,1,1      }
  ,
  {
    1,1,1,0,0,0,0      }
  ,
  {
    1,1,1,1,1,1,1      }
  ,
  {
    1,1,1,1,0,1,1      }
};

void setup() {
  for(int i=2; i<9; i++)
  {
    pinMode(i, OUTPUT);
  }
}

void loop() {
  value = analogRead(analogPin); // realizar la lectura analógica de potienciometro
  num = map(value, 0, 1023, 0, 9);  // convertir a porcentaje


   for(int i=0; i<7; i++) //i son los pines
    {
      if(matriz[num][i]==1)
      {
        digitalWrite(i+2, HIGH);
      }
      else 
      {
        digitalWrite(i+2, LOW);
      }
    }
  
  //delay(1000);
  Serial.print(num);
}

------------------------------------VIDEO-------------------------------------------

link: https://youtu.be/594WCYPTWDM

Recorrido de números en display - Arduino

Hoy haremos un ejercicio en Arduino pero de forma diferente ya que utilizaremos un "display". Para conseguirlo podeis o bien comprarlo o bien hacerlo casero (como en mi caso), para ello os dejo un link donde aprendí yo a hacerlo: link.

Una vez dicho esto, os explicaré en lo que consiste el ejercicio: el programa a realizar en arduino debe imprimir todos los números (del 1 al 9) en el display mencionado anteriormente.

En el programa utilizaremos una matriz (matrices) donde asignaremos los leds que se deben encender para que aparezca el número en el display.

NOTA: El display que he utilizado lleva la siguiente estructura: Las letras de color negro son donde están colocados los leds y los números de color blanco que están al lado de las letras son os pines donde he conectado cada led al arduino. Dependiendo de donde conectéis estos habrá que modificar en cierta parte el programa.





Podéis ver un vídeo del funcionamiento en el siguiente link: vídeo

PROGRAMA RESUELTO

int matriz[10][7]={
  {
    1,1,1,1,1,1,0      }//numero 0
  ,
  {
    0,1,1,0,0,0,0      }//1
  ,
  {
    1,1,0,1,1,0,1      }//2
  ,
  {
    1,1,1,1,0,0,1      }//3
  ,
  {
    0,1,1,0,0,1,1      }//4
  ,
  {
    1,0,1,1,0,1,1      }//5
  ,
  {
    1,0,1,1,1,1,1      }//6
  ,
  {
    1,1,1,0,0,0,0      }//7
  ,
  {
    1,1,1,1,1,1,1      }//8
  ,
  {
    1,1,1,1,0,1,1      }//9
};

void setup()
{

  for(int i=2; i<9; i++)//desde entrada 2 a la 9 
  {
    pinMode(i, OUTPUT);//declarar como salida
  }

}
void loop()
{

  for(int num=0; num<10; num++)//repetir 9 veces 
  {
    for(int i=0; i<7; i++)//i representa cada led
    {
      if(matriz[num][i]==1)//si en el numero[0] el led [2]==1 enciendele si no apagale
      {
        digitalWrite(i+2, HIGH);//i+2 porque he conectado el primer led en el pin 2
      }
      else 
      {
        digitalWrite(i+2, LOW);
      }
    }
    delay(1000);//entre numero y numero espera 1 segundo

  }
}

Matrices - Arduino / C

Una matriz es un conjunto de elementos (números) ordenados en filas y columnas, es decir un vector multidimensional (podríamos verlo también como varios vectores del mismo tamaño).  Las matrices se definen por su tamaño, que normalmente suele se de dos dimensiones. A los elementos de las matrices se accede por subíndices (si la matriz es bidimensional necesitaremos dos subíndices, tridimensional tiene tres subíndices...)

El ejemplo mas típico de una matriz es una imagen, cada pixel va  a tener un valor que corresponde al color o nivel de gris y a esos valores podemos acceder por los subindices. por ejemplo en la imagen de a continuación si tratamos de visualizar el elemento imagen[0][3] sería el 44. Siempre el primer elemento son las filas y luego las columnas y siempre, como en los vectores, se empieza en 0

                                                     

Como podemos observar,  una dimensión seria de 8 filas y la segunda dimensión seria de 8 columnas.

La estructura de una matriz es:

int matriz[dimension1][diemnsion2];

En el caso del imagen:

int imagen[8][8]; //irá de 0 a 7

INICIALIZACIÓN DE UNA MATRIZ:

Las matrices se pueden inicializar al igual que un vector, para hacerlo se seguirá la siguiente estructura:

int matriz[dimension1][dimension2] = {{elemento1,elemento2,...}, {...}};

A continuación os muestro un programa donde empleamos una matriz, su primera dimensión es de 4 elementos y la segunda dimensión de 3.

#include <stdio.h>
int main()
{
    int i,j;
    int matriz[4][3] = {{1,0,8}, {1.4,2}, {2,7,4}, {3,9,6}};

    for (i = 0; i<4; i++)
    {
        for (j=0; j<3; j++)
        {
            printf("matriz[%d][%d] = ", i, j);
            printf("%d \t", matriz[i][j]);
        }
        printf("\n");
    }
}

La pantalla de salida será:

Emisor / receptor infrarrojo controlado desde arduino

En esta práctica controlaremos un emisor y un receptor infrarrojo desde arduino. La práctica consiste en acercar el emisor al receptor y cuando este detecte la luz emitida por el emisor se encienda un led, ya que los rayos infrarrojos no son perceptibles por el ojo humano.

A continuación os dejo el programa y un vídeo en el que podéis apreciar el funcionamiento:

Video: https://www.youtube.com/watch?v=2KfdGZI2arw

Programa:

const int analogInPin = A1; // Pin analogico A1 para la lectura del Fototransistor
const int OutPin = 13;      // Pin para el indicador led 

int sensorValue = 0;        // Inicializamos el valor del sensor a 0

void setup() 

{
  pinMode(OutPin, OUTPUT);
}

void loop()  

{
  // leemos el pin y asignamos el valor a la variable.  

  sensorValue = analogRead(analogInPin);           
  
  // Si el valor obtenido es mayor a 1022 se activa el LED  

  if(sensorValue > 1022)
  {
    digitalWrite(OutPin, HIGH);
  }
  else
  {
    digitalWrite(OutPin, LOW);
  }
                    
}

Cruce de semáforos con Arduino

Este ejercicio se trata de realizar un cruce de semáforos con Arduino, de tal forma que la secuencia tiene que ser:
verde1-rojo2 durante 3 segundos
ambar1-rojo2 durante 500ms
rojo1-verde2 durante 3 segundos
rojo1-ambar2 durante 500ms

A continuación os dejaré un vídeo donde podréis ver el funcionamiento, el esquema electrónico y el programa resuelto.

Vídeo de funcionamiento: https://youtu.be/cIxb1l1drLw

Programa resuelto:

int leds[] = {3, 4, 5, 6, 7, 8}; //verde1=3, ambar1=4...
int tiempo1 = 3000;
int tiempo2 = 500;
int i;

void setup() {
  for (i = 0; i < 6; i++)
  {
    pinMode(leds[i], OUTPUT);
  }
}

void loop() {
  digitalWrite (leds[2], HIGH);//ro1
  digitalWrite (leds[3], HIGH);//ver2
  delay(tiempo1);
  digitalWrite (leds[3], LOW);//apaga ver2
   digitalWrite (leds[2], LOW);

  digitalWrite (leds[4], HIGH);//ambar2
  digitalWrite (leds[2], HIGH);//rojo1
  delay(tiempo2);
  digitalWrite (leds[4], LOW);//amabar2
  digitalWrite (leds[2], LOW);//ro1

  digitalWrite (leds[0], HIGH);//ver1
  digitalWrite (leds[5], HIGH);//rojo2
  delay(tiempo1);
  digitalWrite (leds[0], LOW);//ver1
  digitalWrite (leds[5], LOW);//rojo2

  digitalWrite (leds[1], HIGH);//amb1
  digitalWrite (leds[5], HIGH);//roj2
  delay(tiempo2);
  digitalWrite (leds[1], LOW);
  digitalWrite(leds[5], LOW);
}

Esquema electrónico:

Semáforo con arduino

¿Quieres iniciarte a la programación en arduino pero no sabes cómo hacerlo? Hoy os traigo un proyecto con la placa arduino, realizar un semáforo. Puede parecer complicado pero si ya hemos conseguido encender un led (Entrada de como encender un led) hacer un semáforo es parecido, aprenderás algunas funciones necesarias como pueden ser las de apagar o encender una salida durante un determinado tiempo.  A continuación os mostrare el programación algunas indicaciones.

int rojo=2;      //pin al que vamos a conectar el led rojo
int amarillo=4;  //pin al que vamos a conectar el led amarillo
int verde=7;     //pin al que vamos a conectar el led verde

void setup() 
{ 
  pinMode(rojo,OUTPUT);   //declaramos pin rojo como salida
  pinMode(amarillo,OUTPUT);//declaramos el pin amarillo como salida
  pinMode(verde,OUTPUT);   //declaramos el pin verde como salida  
}

void loop() //bucle
{ 
 digitalWrite(rojo,HIGH);  //encendemos el led rojo
 delay(3000);              //esperamos 3 segundos
 digitalWrite(rojo,LOW);   //apagamos el led rojo
 delay(0);                 //no hay espera
 
 digitalWrite(verde,HIGH); //encendemos el led verde
 delay(3000);              //esperamos 3 segundos
 digitalWrite(verde,LOW);  //apagamos el led verde
 delay(0);                 //no hay espera
 
 digitalWrite(amarillo,HIGH); //encendemos el led amarillo
 delay(1500);                 //esperamos segundo y medio
 digitalWrite(amarillo,LOW);  //apagamos el led amarillo
 delay(0);                    //esperamos medio segundo
}

Ahora os mostrare un esquema de cómo colocar las luces, las resistencias y los cables (realizado por Gumersindo Fernández)

Aquí os dejo un vídeo de como me ha funcionado mi semáforo: https://www.youtube.com/watch?v=Qh8FMXjCUXw

Encendido y apagado de un led con arduino

Arduino es una plataforma de hardware libre, basada en una placa con un microcontrolador y un entorno de desarrollo, diseñada para facilitar el uso de la electrónica en proyectos multidisciplinares.
                                                 
Ahora os voy a enseñar cómo encender y apagar un led con arduino.

Materiales a utilizar:
En este caso como solo hay un led lo conectaremos al pin 13 y no necesitaremos una resistencia ya que este pin la trae incluida, asi que solo necesitamos una placa arduino, un cable USB a la entrada de Arduino o impresora, y un led.

Pasos:

1.- Descargar el programa de arduino e instalarlo siguiendo los pasos que nos van señalando
2.-  Copias el siguiente programa:

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

void loop() 
{
digitalWrite (13, HIGH);
delay (1000);
digitalWrite (13, LOW);
delay (1000);
}

3.- Se conecta la placa mediante el cable USB - Arduino

4.- En la barra superior compruebas que te ponga: placa "Arduino" (como se llame tu placa). En el caso que no lo ponga seleccionas la opción posterior "puerto" y seleccionas tu placa.




5.- Colocar el led de tal forma que la "pata" larga este en el pin 13 y la corta en GND.

6.- Por último en la parte superior le das a subir




Y en un principio el led comenzará a parpadear, tal que así: