Medidor de luz con LDR y Arduino

El proyecto consiste en realizar un sencillo medidor de luz con nuestro Arduino, utilizaremos una fotoresistencia LDR y mostraremos el resultado en la computadora así como en un grupo de leds.

El objetivo de este tutorial es aprender como conectar sensores que varían su resistencia dependiendo de una magnitud física. Un ejemplo de este tipo de sensores es el LDR o fotoresistencia, estudiaremos el funcionamiento de este componente y su conexión con la tarjeta Arduino UNO R3 mediante un divisor resistivo.

Conceptos básicos 

Para entender como funciona este circuito y el programa que corre en la tarjeta Arduino debemos conocer 3 conceptos clave:

Fotoresistencia LDR: Componente cuya resistencia varía sensiblemente con la cantidad de luz percibida. La relación entre la intensidad lumínica y el valor de la resistencia no es lineal. Se utiliza ampliamente para medir la iluminación en dispositivos electrónicos que requieren un precio agresivo. Su comportamiento es el siguiente:
  • Mas luz = menor resistencia eléctrica 
  • Menos luz = mayor resistencia eléctrica 

Divisor de tensión: Mediante un par de resistencias en serie con una LDR, es posible repartir la tensión suministrada por la fuente entre los terminales de estas, en nuestro caso, el divisor se utiliza con la LDR para obtener un voltaje variable de acuerdo a la cantidad de luz recibida.



Conversión Analógico-Digital (ADC): Es el proceso mediante el cual se convierte una magnitud física como un voltaje, corriente, temperatura, etc. en un número binario (o señal digital) con el propósito de facilitar su manejo por circuitos digitales como una CPU. El Arduino realiza este proceso para conocer la cantidad de luz percibida por el LDR y poder procesarla numéricamente.

Materiales necesarios

  • Arduino UNO R3 
  • Fotoresistencia (LDR) 
  • Resistencia de 10 Kohm 1/4 W 
  • 3 Resistencias de 220 o 330 ohm 1/4 W 
  • 3 Leds 5mm
  • Cables para protoboard 
  • Protoboard

Esquema eléctrico

Recordar que los LED tienen polaridad y hay que respetarla. El pin más largo va conectado a la tarjeta Arduino, mientras que el pin más corto va con una resistencia a tierra.


Programa realizado (sketch)

La explicación para el código es la siguiente: Primero se preparan los pines de salida donde están conectados los leds, el pin de entrada donde se conecta el divisor resistivo y el puerto serie para la comunicación. A continuación se ejecuta un ciclo infinito en el que se lee el valor del voltaje en el pin del LDR y se accionan los leds según correspondan. También transmitimos el valor leído por el ADC del ATMEGA328 al PC a través del puerto serie de nuestra tarjeta arduino.

Valores leídos por el puerto serie




//Pin donde se conectan los leds
int pinLed1 = 2;
int pinLed2 = 3;
int pinLed3 = 4;
// Pin analógico de entrada para el LDR
int pinLDR = 0;

// Variable donde se almacena el valor del LDR
int valorLDR = 0; 

void setup()
{
  // Configuramos como salidas los pines donde se conectan los led
  pinMode(pinLed1, OUTPUT);
  pinMode(pinLed2, OUTPUT);
  pinMode(pinLed3, OUTPUT);
 
  //  Configurar el puerto serial
  Serial.begin(9600);
}

void loop()
{
  // Apagar todos los leds siempre que se inicia el ciclo
  digitalWrite(pinLed1, LOW);
  digitalWrite(pinLed2, LOW);
  digitalWrite(pinLed3, LOW);

  // Guardamos el valor leído del ADC en una variable
  // El valor leído por el ADC (voltaje) aumenta de manera directamente proporcional con respecto a la luz percibida por el LDR
  valorLDR= analogRead(pinLDR);
 
  // Devolver el valor leído a nuestro monitor serial en el IDE de Arduino
  Serial.println(valorLDR);

  // Encender los leds apropiados de acuerdo al valor de ADC
  if(valorLDR > 590)
  {
    digitalWrite(pinLed1, HIGH);
  }
  if(valorLDR >650)
  {
    digitalWrite(pinLed2, HIGH);
  }
  if(valorLDR > 768)
  {
    digitalWrite(pinLed3, HIGH);
  }
  // Esperar unos milisegundos antes de actualizar
  delay(200);
}

El H Bridge L293D

El L293D, es un pequeño integrado que incluye dos puentes H-Bridge que podemos usar para gobernar simultáneamente dos motores.


Si buscáis el manual del L293D, veréis que aunque el funciona a 5V internamente, puede conmutar tensiones de hasta 36V para tus motores.

El patillaje del chip es así:

Veamos que son los diferentes pines del L293D:
  • El pin 16, Vcc1, son los 5V con los que alimentamos el chip y el pin 8, Vcc2, es la tensión con la que alimentamos el motor. 
  • Los pines del 1 al 7 controlan el primer motor y los pines 9 a 15 controlan el segundo motor. 
  • El pin 1, Enable1, Activa el uso del motor 1. Con un valor HIGH, el motor puede girar dependiendo del valor de 1A y 2A. Si es LOW se para independientemente de los valores del resto de pines. Los pines "enable" (1,9) admiten como entrada una señal PWM, y se utiliza para controlar la velocidad de los motores con la técnica de modulación de ancho de pulso.
  • Los pines 2 y 7 son los pines de control para el motor 1, e irán conectados a nuestros Arduino para controlar el sentido de giro.
  • Los pines 3 y 6 son la salida a la que se conecta el motor 1, cuya polaridad se invierte en función los valores de 2 y 7. En el diagrama de arriba veis que hay pines equivalentes para el motor 2 y cuales son. 
  • Los pines 4, 5,12 y 13 van a GND.

Podemos hacer una tabla para mostrar la lógica que sigue el giro del motor en función de los tres pines:

Por tanto tenemos que activar el pin enable para que el motor gire y después usamos los pines Input1 e Input2 con valores opuestos para hacer girar el motor en una dirección o en la contraria. Veamos cómo hacer el montaje con Arduino.

Esquema de protoboard

El diagrama de protoboard del chip L293D a nuestro Arduino será algo así:

El programa que vamos a usar para controlar este motor será el siguiente:

Vamos a usar los 3 pines de la tabla anterior. Arduino Pin 10 es el enable del

Motor 1 y usamos los pines 8 y 9 para controlar el sentido de giro. Por tanto:

//Control del sentido de giro de un motor de CC

#define E1 10 // Enable Pin para el motor 1
#define I1 8 // Control pin 1 para el motor 1
#define I2 9 // Control pin 2 para el motor 1

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

void loop ()
{
digitalWrite (E1, HIGH); //Activar el motor 1
digitalWrite (I1, HIGH);  //Iniciar el giro
digitalWrite (I2, LOW);
delay (3000);

digitalWrite (E1, LOW); //Parar el motor 1
delay (1000);

digitalWrite (E1, HIGH); //Activar el motor 1

digitalWrite (I1, HIGH);  //Iniciar el giro con cambio de dirección
digitalWrite (I2, LOW);
delay (3000);


digitalWrite (E1, LOW); //Parar el motor 1
delay (1000);
}

Descripción del programa

Activar el Enable1 para arrancar Motor 1, y luego usar I1 e I2 con valores invertidos. El motor arranca y se para a los 3 segundos. Transcurrido un segundo se activa de nuevo el Enable1 y al intercambiar los valores de I1 e I2 el giro del motor se inicia y en la dirección contraria.

En el taller de tecnología el control del sentido de giro de un motor de CC, se usa en multitud de ocasiones, he aquí un ejemplo de una grúa construida con barritas de papel reciclado, automatizada con Arduino y un L293D.

Para el control del sentido de giro del motor (subida o bajada), se han utilizado dos pulsadores.



El diagrama de protoboard del chip L293D a nuestro Arduino será así:


Programa


//Control del sentido de giro de un motor de CC

#define E1 10 // Enable Pin para el motor 1
#define I1 8 // Control pin 1 para el motor 1
#define I2 9 // Control pin 2 para el motor 1
int estadoPulsadorSubir=0;
int estadoPulsadorBajar=0;
int pinPulsadorSubir=0;
int pinPulsadorSubir=0;

void setup()
 {
   for (int i=8; i<=11; i++)
   pinMode (i, OUTPUT);

 }
pinMode (pinPulsadorSubir, INPUT);
pinMode (pinPulsadorBajar, INPUT);
}
void loop()
{
estadoPulsadorSubir = digitalRead (pinPulsadorSubir); //Leer estado del pusador de subida
estadoPulsadorBajar = digitalRead (pinPulsadorBajar); //Leer estado del pusador de bajada

if ( estadoPulsadorSubir == HIGH && estadoPulsadorBajar == LOW )
 {
   while (estadoPulsadorSubir==HIGH)
   {
    digitalWrite(E1, HIGH); //Activamos giro de subida
    digitalWrite(I1, HIGH); //Se inicia la subida

    digitalWrite(I2, LOW); //Activamos giro de subida
    estadoPulsadorSubir = digitalRead (pinPulsadorSubir);
   }
 }

if ( estadoPulsadorSubir == LOW && estadoPulsadorBajar == HIGH )
 {
   while (estadoPulsadorSubir==HIGH)
   {
    digitalWrite(E1, HIGH); //Activamos giro de subida
    digitalWrite(I1, LOW); //Se inicia la subida

    digitalWrite(I2, HIGH); //Activamos giro de subida
    estadoPulsadorBajar = digitalRead (pinPulsadorSubir);
   }
 }
 digitalWrite(E1, LOW); //Motor desactivado
}

¿Cómo configuramos los pulsadores?

Los  pulsadores

Una señal digital solo tiene dos estados: un valor inferior de tensión 0 V, al que se le asocia el valor lógico LOW o 0; y un valor superior de tensión 5 V, al que se le asocia un valor lógico HIGH o 1.


Los pulsadores producen una entrada digital porque esta puede valer 0 o 1. Su funcionamiento es muy sencillo.

¿Cómo configuramos los pulsadores?

Para utilizar los pulsadores en nuestra placa Arduino, lo primero que hay que hacer es conectar el pulsador a un pin digital por un lado  y a un valor de tensión 0V o 5V por el otro:

Cada vez que accionamos el pulsador el pin 8, queda conectado a un valor alto, 5V.



¿Qué pasa en el pin 8 cuando en ninguno de los dos circuitos accionamos el pulsador?  Si no se acciona el pulsado, el pin 8 se queda sin conexión, al aire y, por tanto, en una situación indeterminada. Unas veces prevalecerá el 1; y otras, el nivel 0.
Esta situación no es deseable y se soluciona añadiendo una resistencia y forzando una tensión en la situación en que el pulsador no está accionado. Si esta resistencia se conecta a 5V,  se llama pull-up; y si se conecta a tierra o a 0V, se llama pull-down.




Las resistencia pull-down y pull-up se conecta entre el  pin digital y una de las tensiones de referencia (0V o 5V) y fuerza el valor de la tensión a 0V o 5V, respectivamente, en caso de no estar activado el pulsador.

Por ejemplo, en la resistencia pull-up, cuando el pulsador está pulsado, no circula intensidad por ella, ya que no hay camino de la corriente hacia tierra. Por ello, en los dos extremos de la resistencia tendremos 5V. Cuando se acciona el pulsador, la corriente atraviesa la resistencia pull-up, los 5V caen en la resistencia, y el extremo que está unido al pin 8 queda conectado a tierra, es decir, a 0V.

Ejemplo

Encender un led con un pulsador

Material necesario

  • Placa protoboard.
  • Diodo led.
  • Resistencia 220 ohmios.
  • Resistencia de 10 k ohmios.
  • Cables de conexión.
  • Pulsador.

1.- Realiza el montaje que se ve en la imagen. Observa que uno de los terminales del pulsador está conectado mediante el cable rojo a 5V; y el otro está conectado a una resistencia de 10K y, a la vez mediante el cable azul, al pin digital 8 de la placa Arduino. La resistencia va conectada a tierra (GND) a través del cable negro.


Por último, el led rojo se conecta con su cátodo ( patilla corta) a una resistencia de 220 ohmios esta a tierra y su ánodo (patilla larga) al pin digital 9.

2.- Conecta la placa al ordenador

3.- Ejecuta el IDE  de Arduino y escribe este código para que, al activar el pulsador se encienda el diodo led:

Código

//Encender un led, al acccionar un pulsador

int pinPulsador=8; // Declaramos la variable pinPulsador con el número del pin en qué está conectado
int pinDiodo=9;  //   Igual para el pin del diodo
int estadoPulsador=0; // Estado del pulsador


void setup() {
pinMode(pinPulsador, INPUT); // Inicializa el pin  8 como entrada
pinMode(9, OUTPUT); //Inicializa el pin 9 como salida
}

void loop()

{

  estadoPulsador = digitalRead(pinPulsador); // Lee el valor del pin del pulsador y lo almacena en la variable pinPulsador
   if(estadoPulsador == LOW// Comprueba el estado del pulsador está pulsado
   {   
    digitalWrite(pinDiodo, HIGH); // Si es así activa el diodo
   }
   else
   {
     digitalWrite(pinDiodo, LOW); // Si no, lo mantiene apagado
   }
}

Control de motor de corriente continua con transistor


En este proyecto vamos a mover un motor de corriente continua, motor DC, usando un transistor. Los pines del Arduino sólo nos pueden proporcionar 5 V y a lo más 40 miliamperios de corriente, lo cual es insuficiente para motores de este tipo. Si intentamos usar un motor DC directamente desde un pin del Arduino, podríamos dañar el microcontrolador, por lo que vamos a usar un transistor para hacerlo.
Vamos a usar el transistor 2N222 que es un transistor que por sus características y precio es muy utilizado como un switch para el manejo de un motor DC y el montaje será el siguiente:

Para activar el motor vamos a usar un pulsador. Cuando presionemos el pulsador, la placa Arduino activará el transistor, con lo cual girará el motor.


Componentes
  • Arduino
  • Placa protoboard.
  • Transistor 2N222.
  • Resistencia de 220 (rojo, rojo, marrón).
  • Diodo rectificador 1N4001.
  • Pulsador.
  • una resistencia de 10 K (marrón, negro, naranja)


Circuito
El transistor es un componente electrónico con tres patas; el colector, el emisor y la base. 

En el 2N222, viéndolo de frente, la patilla izquierda es el emisor, que conectamos a masa (GND). La patilla central es la base, que conectamos al pin de Arduino y la patilla derecha es el colector, que conectamos al borne del motor.
La conexión al pin de Arduino, usado para activar el transistor, la hacemos a través de una resistencia, para limitar la corriente de salida del este pin. Una resistencia de 220 es suficiente, dado que la tensión de alimentación va a ser de 4,5 V.
El circuito del motor tenemos que conectarlo a una fuente externa de alimentación, ya que no podemos usar el Arduino para esto. Conectaremos uno de los cables del motor al positivo de la fuente de alimentación y el otro cable, como ya habíamos dicho, al colector del transistor, la patilla de la derecha.
Como el circuito que estamos controlando es un motor, al detenerse puede generar un voltaje que dañaría nuestro transistor y también el Arduino, por esto es muy conveniente agregar un diodo, tipo 1N4001 entre el colector y el emisor.

El pulsador para activar el motor lo conectaremos al pin 8 del Arduino con una resistencia pull-down a tierra.



Código

// Control de un motor DC con un transistor
// Activamos y desactivamos con un sensor digital

int pinPulsador = 8; // Declaramos la variable pinPulsador con el número del pin en qué está conectado

int pinMotor = 9;  //Igual para el pin del motor


int estadoPulsador = 0; // para guardar el estado del sensor

void setup() {
   pinMode(pinMotor, OUTPUT); //Inicializa el pin del motor como salida
   pinMode(pinSensor, INPUT); //Inicializa el pin del pulsador como entrada
   digitalWrite(pinMotor, LOW); //Activamos el estado de reposo para el motor
}

void loop() {
   estadoPulsador = digitalRead(pinPulsador); // Lee el valor del pin del pulsador y lo almacena en la variable pinPulsador
   if(estadoPulsador== HIGH) { // Comprueba el estado del pulsador está pulsado
     digitalWrite(pinMotor, HIGH); // Si es así activa el motor
   } else {
     digitalWrite(pinMotor, LOW); // Si no, lo mantiene en reposo
   }
}



Cómo encolar piezas de madera

En el aula de tecnología utilizaremos cola blanca para unir las piezas de madera, derivados de la madera y cartón. Después de utilizar diferentes marcas de cola blanca para madera, hemos elegido la cola de Carrefour, por los siguientes motivos: permiten realizar uniones duraderas y resistentes y el envase es ideal para su manejo.

Lo primero que haremos antes de utilizar un adhesivo es leer las indicaciones del fabricante, en el caso de la cola de Carrefour son las siguientes:

La cola de carpintero Carrefour permite unir rápidamente todo tipo de madera y derivados sin dejar huellas. Se usa en madera derivados de la madera, cartón y papel.
Modo de empleo
Los soportes deben estar limpio, secos y ligados.
  1. Aplicar una capa fina de cola en una de las superficies que se quiera unir. En superficies grandes extender con ayuda de un pincel.
  2. Unir las piezas y presionar fuertemente. Se pueden reposicionar las piezas durante 5 min .  Dejar secar 10 min. La resistencia máxima se obtiene después de 24 h

Consejos de limpieza
Si la cola todavía está fresca, lavar con agua con agu, preferiblemente caliente. Siesta sec, lavar con agua caliente y vinagre blanco. .
Conservación: Guardar el producto en un lugar fresco

Cómo encolar piezas de madera


Para realizar un buen  encolado es necesario seguir los siguientes pasos:

1.- Se eliminan los restos que tenga la madera, empleando para ello papel de  hija.
2.- Se extiende la cola uniformemente con un pincel o brocha.





3.- Se prensan las piezas con mordazas o sargentos. Es necesario proteger las piezas para que no queden marcas.


4.- Se eliminan los excedentes de cola con un trapo húmedo. En el caso de la imagen se retira la cola con ayuda de un formón.


Led RGB

Un led RGB es la unión de tres leds de colores básicos: rojo, verde y azul, en un mismo encapsulado común, puedes considerar un led RGB como tres leds de colores rojo, verde y azul.

Led RGB

 Ánodo y cátodo.

Todos los leds constan de ánodo y cátodo. El ánodo es el “polo” positivo y el cátodo el negativo. Esto quiere decir que, en el caso de Arduino, el ánodo será la patilla que esté asociada al pin 5V y el cátodo irá a GND. 

Hay leds de cátodo común o de ánodo común.




Montaje básico del led RGB de ánodo común.

 Ahora que conoces un poco mejor las características de tu led RGB, vamos a ver cómo se realizaría un montaje básico.
  1.  La patilla correspondiente al ánodo la podrás identificar fácilmente porque su tamaño es mayor que las demás. Esta patilla es la que debes conectar al pin 5V de tu placa. Aunque también puedes conectar esta patilla a una salida digital, debes tener cuidado ya que éstas te permiten gestionar hasta 20mA (lo que seguramente sea insuficiente para tu LED RGB).
    Esquema led RGB
  2. El resto de patillas (por las que controlarás los colores de tu LED) debe ir asociada a salidas PWM mediante una resistencia (a priori, una de 220Ω por cada patilla debería ser suficiente). Debes tratar tu LED RGB como si fueran tres LEDs distintos, es decir, no basta con poner una única resistencia en el ánodo (patilla común conectada a 5V), lo suyo es que pongas una en cada cátodo.
  3. Las salidas PWM (ancho de pulso modulado) que vienen representadas en tu Arduino con el símbolo “~”, proporcionan 5V (al igual que el resto de salidas digitales) con la diferencia de que oscilan su valor entre 0V y 5V al ritmo que tú le indiques mediante la instrucción analogWrite(), consiguiendo así simular valores de voltaje intermedios.
  4. Cuanto mayor sea el valor de tus salidas PWM (cuanto más se aproxime a 5V), menor diferencia de voltaje habrá en tu LED RGB, menor será la corriente que lo atraviese y, por tanto, menos brillará (apagándose el color al que vaya asociada esa salida llegado cierto punto).
  5. Debes tener en cuenta que la caída de voltaje que se produce en la patilla asociada al color rojo es menor, por lo que, si la resistencia es la misma en todas las patillas, circulará más corriente (recuerda aquí el límite de los 20mA). Ésto también quiere decir que el rojo brillará más (aunque como el ojo humano es menos sensible al rojo, esto es un factor positivo).
Conexiones del diodo led RGB  a la placa Arduino

 Código básico de funcionamiento

/* Control Básico De Un LED RGB De Ánodo Común */

//Se definen las variables que se van a utilizar para establecer los
//colores. Éstas deben estar asociadas a pines digitales PWM e irán
//unidas a los cátodos de cada uno de los colores.

int Rojo = 9;
int Verde = 10;
int Azul = 11;

void setup(){

//Se establecen los pines definidos como salidas para poder
//la diferencia de voltaje con respecto a la alimentación común.

pinMode(Rojo, OUTPUT);
pinMode(Verde, OUTPUT);
pinMode(Azul, OUTPUT);

}

//Se crea un módulo auxiliar que facilitará la tarea de establecer
//los voltajes asociados a cada color.
//El valor de las variables R, G y B debe ser un entero entre 0 y 255
//siendo 255 el valor relativo a la máxima luminosidad de cada color.
//Debe tenerse en cuenta que hasta que no se supere el voltaje umbral
//de cada color este no se presentará en el LED RGB.

void EstablecerColor(int R, int G, int B){

//Se utiliza la expresión 255-X para "naturalizar los valores". Dado
//que el mayor brillo está asociado a la mayor diferencia de voltaje
//entre la alimentación y las salidas PWM (lo que implica una salida
//de 0V por el pin PWM, esto es, analogWrite(X, 0);).

analogWrite(Rojo, 255-R);
analogWrite(Verde, 255-G);
analogWrite(Azul, 255-B);

}

void loop(){

//Se representan colores pseudoaleatorios en el LED RGB mediante el
//uso de la instrución random(min,max);.

EstablecerColor(random(127,255), random(127,255), random(127,255));

//Se utiliza un delay para que de tiempo algo observador a apreciar
//los colores.

delay(1000);

}


 Fuente: www.educachip.com

¿Cuándo usamos el bucle for?

La declaración for se usa para repetir un bloque de sentencias un número determinado de veces. Cada vez que se ejecutan las instrucciones del bucle se vuelve a testear la condición. La declaración for tiene tres partes separadas por (;)

Para ello, necesita de una variable con un valor inicial, una condición que debe cumplir esta variable para continuar el bucle, y un incrementador que cambie el valor de la variable.
 
for (variable; condición; incrementador)
 {
   bloque de instrucciones
}

Veamos el ejemplo de su sintaxis:
for (int i=0; i<20 i="" p="">
{
digitalWrite(13, HIGH);
digitalWrite(13, LOW);
}

El ejemplo anterior enciende y apaga un led conectado al pin 13 en un bucle de 20 ejecuciones. Al inicio del bucle se declara una variable entera "i" cuyo valor inicial =0. Justo después se indica que el bucle se ejecutará hasta que la variable "i" tenga un valor inferior a 20 y finalmente se indica cuanto se incrementa la variable cada vez que se repita el bucle. (++ en programación equivale a +1, es decir, la variable pasa a valer un entero mas cada vez que se ejecuta el bucle).

Kit de Luces de Auto Fantastico

Monta el circuito según la imagen. Conecta las patillas largas (ánodos) de los leds a los pines 13,12,11,10,9,8,7,6 de la placa Arduino (salidas digitales). Las patillas cortas (cátodos) se conectan con las resistencias  y estas van todas conectadas a tierra (GND).
Circuito luces Kit

El código del programa será el siguiente:


/*
Luces del coche fantástico.

*/

void setup()
 {
// Inicializar los pins digitales como salidas.
  pinMode(13, OUTPUT);
  pinMode(12, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(6, OUTPUT);
}

void loop()
 {
   digitalWrite(13, HIGH);
   delay(10);
   digitalWrite(13, LOW);
   delay(10);
   digitalWrite(12, HIGH);
   delay(10);
   digitalWrite(12, LOW);
   delay(10);
   digitalWrite(11, HIGH);
   delay(10);
   digitalWrite(11, LOW);
   delay(10);
   digitalWrite(10, HIGH);
   delay(10);
   digitalWrite(10, LOW);
   delay(10);
   digitalWrite(9, HIGH);
   delay(10);
   digitalWrite(9, LOW);
   delay(10);
   digitalWrite(8, HIGH);
   delay(10);
   digitalWrite(8, LOW);
   delay(10);
   digitalWrite(7, HIGH);
   delay(10);
   digitalWrite(7, LOW);
   delay(10);
   digitalWrite(6, HIGH);
   delay(10);
   digitalWrite(6, LOW);
   delay(10);
}

Una vez montado el circuito y comprobado que funciona correctamente, se puede probar a modificar el tiempo de espera.

Modificamos el código haciendo uso del bucle for, el código del programa será el siguiente:

/*
Luces del coche fantástico.
*/
int pausa=100;
void setup ()
   for(int pinLed=13;<=6;pinLed--)
   {
     pinMode(pinLed, OUTPUT);
   }
}
void loop()
{
   for(int pinLed=13;<=6;pinLed--)
   {
    digitalWrite(pinLed, HIGH);
    delay (pausa);
    digitalWrite(pinLed,LOW);
   }

   for(int pinLed=6;pinLed <=13;pinLed++)
    digitalWrite(pinLed, HIGH);
    delay (pausa);
    digitalWrite(pinLed,LOW);
   }
}


Optointerruptores (CNY70)

Un optointerruptor, también llamado optoacoplador, es un componente electrónico formado por un LED y un transistor, de forma que la luz emitida por el LED activa la base del transistor.

Optointerruptores
Sus cuatro patillas corresponden a los dos polos del diodo LED, positivo y negativo, y al colector y el emisor del transistor, y vienen normalmente señalados en la carcasa del componente.

Aspecto real del fotodiodo y fototransistor

Símbolo del fotodiodo y fototransistor
Los hay con forma de U, en los que la luz pasa a través de una ranura activando el transistor. Cuando el rayo de luz se interrumpe, el transistor se activa o desactiva, dependiendo del tipo de optointerruptor utilizado.

Entre otras aplicaciones, se utiliza para:
  • La aplicación principal es en aislamiento entre los circuitos de control y los de potencia.
  • Captar el movimiento giratorio de una rueda ranurada y poder controlar el número de vueltas. 
  • Se puede utilizar como interruptor o como final de carrera en determinados proyectos tecnológicos.
  • Otro uso muy común en educación son en coches seguidores de luz.

Detector de presencia CNY70

El sensor CNY70 integra dos componentes en una sola cápsula:
  • Diodo emisor de luz infrarroja, lo que hace que pueda funcionar en cualquier condición de luz.
  • Receptor, que hace las veces de interruptor para dejar que la electricidad circule por el circuito que deseamos activar.
CNY70
 ¿Cómo funciona el sistema óptico?

Si el receptor recibe el reflejo de la luz que está emitiendo el diodo LED actúa dejando pasar la corriente por el circuito.

Superficie del objeto a detectar

Es importante tener en cuenta que este sensor debe estar muy cerca de la superficie que refleja la luz.

Eduloc. Crea itinerios educativos

Eduloc permite que cualquier persona, de forma individual o en equipo pueda crear itinerarios y experiencias de aprendizaje basadas en la geolocalización, haciendo posible realizar trabajos sobre el territorio.

Esta herramienta hace posible añadir, de forma muy sencilla, capas de información (Textos, vídeos, sonidos, etc.) sobre el mundo real. Además permite incluir distintas actividades que hacen posible experiencias interactivas. Por ejemplo podemos incluir un Juego de pistas o de preguntas en los itinerarios creados.

Como todas este tipo de herramientas, Eduloc está constituida por dos componentes: La plataforma web que nos permite crear los itinerarios o actividades geolocalizadas y la app para dispositivos móviles (disponible para Android e Iphone), que hace posible poder seguir, sobre el terreno, los itinerarios y actividades creadas.
En el siguiente video tutorial puedes aprender a utilizar Eduloc en apenas diez minutos.



La app para dispositivos móviles puedes descargarlas desde estos enlaces:
Eduloc ha sido desarrollada por la Fundació Itinerarum, y puedes seguirlos en Facebook: https://es-es.facebook.com/proyectoeduloc

Web del proyecto: http://www.eduloc.net/es

Pines de E/s digitales en Arduino

Una de las funciones más interesantes (si no la más) de Arduino y en general de todos los autómatas es su capacidad de interacción con el mundo físico. Podemos, por ejemplo, realizar mediciones de tensión, obtener lecturas de gran variedad de sensores, encender dispositivos o controlar motores y actuadores. Esta interacción se lleva a cabo en gran parte mediante el uso de las entradas y salidas tanto digitales como analógicas.

¿Qué es una entrada digital?

Una señal digital es una variación de voltaje entre -Vcc a +Vcc sin pasar por los valores intermedios. Por lo tanto, una señal digital dispone solo de dos estados. Al valor inferior de tensión -Vcc le asociamos un valor lógico LOW o ‘0’, mientras que al valor superior +Vcc le asociamos HIGH o ‘1’ lógico.
 
En Arduino los valores de alimentación habituales son 0V y 5V. En este caso la tensión umbral será muy cercana a 2’5V. Por tanto si medimos una tensión con un valor intermedio entre 0 a 2’5V Arduino devolverá una lectura LOW, y si medimos un valor entre 2’5V y 5V, devolverá HIGH. 

Nunca introducir una tensión fuera del rango 0V a 5V en una entrada digital o analógica o podemos dañar el pin correspondiente y dejarlo permanentemente inutilizado.

En Arduino, las entradas y salidas digitales se realizan en las mismas patillas, que se denominan pines de E/S digitales. Eso quiere decir que un mismo pin puede actuar bien como una entrada digital, o bien como una salida digital. por ello es necesario configurar previamente el pin para que funcione de una u otra manera.

Las principales funciones que utilizaremos para las configuración de los pines de E/S como entradas digitales en la placa Arduino son las siguientes:
  • pinMode(n, INPUT). Esta función permite configurar cualquiera de los pines digitales como entradas (INPUT).
  • digitalRead((n_del_pin).  Devuelve un valor digital (HIGH o LOW) leído desde el pin numero_de_pin.  Ejemplo: Leer el estado de un pulsador.
  • punseIn(n-del_pin, valor_HL). Devuelve un número que es el tiempo en microsegundos que ha estado el n_de_pin al valor_HL.

 ¿Cómo configuramos las salidas digitales?

Si queremos conectar un led a la placa Arduino y que se encienda, es necesario configurar los pines E/S digitales como salidas digitales. La configuración de los pines digitales, así como la configuración de otros parámetros se realizan a través del IDE  de Arduino.

Las principales funciones que utilizaremos para la configuración de los pines de E/S digitales en la placa Arduino son las siguientes:

  • pinMode(n, OUTPUT). Esta función permite configurar cualquiera de los pines digitales como salidas (OUTPUT).
  • digitalWrite((n, HIGH). Esta función pone el pin n a 5 V (nivel lógico "1"); es decir encendemos el led.
  • digitalWrite((n, LOW). Esta función pone el pin n a 0 V (nivel lógico "0"); es decir apagamos el led. 
  • analogWrite(n_del_pin, valor). Pone en el pin n_del_pin una señal digital PWM, (valor comprendido entre 0 y 255). Solo algunos pines marcados en la placa soportan PWM.

Semáforo con Arduino

Circuito para simular el funcionamiento de un semáforo.

Material necesario
  • Diodo led rojo.
  • Diodo led amarillo.
  • Diodo led verde.
  • Resistencia de 200 ohmios.
  • Cables de conexión.
Solo vamos a utilizar una resistencia, debido a que los diodos se encienden secuencialmente.

Monta el circuito como se ve en la imagen. Las patillas cortas de los diodos van unidas y conectadas a través de una resistencia a la patilla GND,  el diodo led rojo a la patilla 13, el led amarillo a la patilla 12 y el led verde a la patilla 11.
Semáforo con Arduino

Programa realizado,

void setup() // Función que se ejecuta una sola vez.
{
// Inicializar el pin digital (13) como salida.
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
pinMode(11, OUTPUT);

}

void loop() // Función que se ejecuta una y otra vez, de forma ininterrumpida.
{

digitalWrite(13, HIGH); // Encender el led, haciendo que el voltaje sea alto.
digitalWrite(12, LOW); // Apagar el led, haciendo que el voltaje sea bajo.
digitalWrite(11, LOW); // Apagar el led, haciendo que el voltaje sea bajo.
delay(1000); // Esperar un segundo

digitalWrite(13, LOW); // Apagar el led, haciendo que el voltaje sea bajo.
digitalWrite(12, HIGH); // Encender el led amarillo , haciendo que el voltaje sea alto.
delay(1000); // Esperar un segundo
digitalWrite(12, LOW); // Apagar el led, haciendo que el voltaje sea bajo.
delay(1000); // Esperar un segundo

digitalWrite(11, HIGH); Encender el led, haciendo que el voltaje sea alto.
delay(1000); // Esperar un segundo
}





Llave fija

Definición

Es una pieza de metal que tiene un hueco de forma hexagonal, perfectamente calibrado, para que entre en él la cabeza de una tuerca o de un tornillo con cabeza de tuerca. Se utiliza para apretar (girando hacia la derecha) o aflojar (girando hacia la izquierda) las tuercas y los tornillos con cabezas de tuerca.
El hueco calibrado suele tener una medida, entre caras paralelas, desde 6 hasta 22 mm generalmente.

Juego de llaves fijas
Estas llaves suelen ser de acero aleado al cromo-vanadio para aumentar su dureza y resistencia al desgaste.
Se utilizan agarrándolas con una mano, haciendo coincidir la cabeza de la llave con la cabeza del tornillo y girándolas a derechas o a izquierdas según se quiera apretar o aflojar.
Conviene apretar bien las tuercas con la llave pero tampoco hacerlo demasiado ya que se puede dificultar el aflojado posterior.

Tipos

Existen diferentes tipos de llaves y son los siguientes:
  • Llaves planas: son aquellas que tienen un agujero calibrado en cada extremo. Normalmente llevan agujeros de numeración correlativos, es decir, 6- 7 mm , 8- 9 mm , 10- 11 mm , etc. 
Llave fija plana
  • Llave inglesa: es aquella en el cual el hueco de la cabeza de la llave es móvil de tal forma que permite ajustarse a casi todos los tamaños. Se recomienda ajustar bien la cabeza de la llave inglesa a la tuerca para evitar desgastar las aristas de esta. 
Llave inglesa
  •  Llave de tubo: son aquellas que permiten encajar toda la llave en la tuerca y se utilizan para poder apretar y aflojar tuercas que se encuentran en el interior de huecos. La llave de tubo se hará girar con una llave plana o una llave inglesa. 
Llave de tuvo
  • Llave de carraca: son aquellas que permiten acoplar una llave a una tuerca y hacerla girar sin realizar ningún trabajo en un sentido y con trabajo en el contrario. Es muy útil para apretar y aflojar tuercas de forma rápida y cómoda. 
Llave de carraca
  • Llaves Allen: son llaves cada vez más usadas, que tienen una forma acodada, con un extremo más largo que otro y con una sección hexagonal. Se utilizan para apretar y aflojar tornillos con cabeza Allen. Se utilizan mucho en los muebles de bricolaje y en las bicicletas.
Llaves Allen
 Seguridad

Las principales medidas de seguridad que se deben tomar para el manejo adecuado de las llaves para apretar y aflojar son las siguientes:
  • Utilizar la llave con la medida adecuada a la tuerca que queramos manipular. De esta forma evitaremos el desgaste de la tuerca, de la herramienta y también que ésta pueda escaparse al hacer fuerza y hacernos daño. 
  • Utilizar las llaves solo para el uso para el que están indicadas.
  • Limpiar las llaves después de usarlas, sobre todo si se han manchado de grasa o aceite.
Fuente: El taller virtual de tecnología


Cómo encender un diodo led con Arduino

Materiales necesarios
  • Diodo led.
  • Resistencia de 220 ohmios.
  • Placa protoboard.
  • Cables de conexión.

1.- Monta el led en la placa, como se ve en la imagen.

Cómo encender un led
2.- La patilla corta del led va conectada a GND (0V) de la placa mediante un cable. La patilla larga del led va unida a una resistencia de 220 ohmios y el otro extremo de la resistencia, al pin digital 13 de la tarjeta.

3.- Conecta la placa al ordenador.
4.- Ejecuta el IDE  de Arduino


Encendido y apagado de un diodo led, durante un segundo, de forma intermitente.


void setup() // Función que se ejecuta una sola vez.
{
// Inicializar el pin digital (13) como salida.
pinMode(13, OUTPUT);
}

void loop() // Función que se ejecuta una y otra vez, de forma ininterrumpida.
{
digitalWrite(13, HIGH); // Encerder el led, haciendo que el voltaje sea alto.
delay(1000); // Esperar un segundo
digitalWrite(13, LOW); // Apagar el led, haciendo que el voltaje sea bajo.
delay(1000); // Esperar un segundo
}