Interruptor crepuscular con LDR y Arduino

Hola a todos. Espero que hayáis tenido una buena entrada de año. Una vez pasadas las fiestas retomamos el hilo de este blog.

Esta vez nuestra propuesta es construir un interruptor que active nuestro led en función de la luz ambiental. Un proyecto sencillo pero que nos sirve para empezar a trabajar con sensores.

Hasta ahora hemos dado siempre a nuestro Arduino las órdenes de forma manual, ya sea a través de pulsadores, interruptores o potenciómetros.

Ahora nuestro circuito será capaz de decidir "solito" en función de una variable ambiental. Así que paso a describir del componente que nos hará posible realizar el proyecto.

Fotorresistor o LDR ("ligth-dependent resistor")

El fotorresistor es un componente electrónico, del tipo semiconductor, cuya resistencia varía en función de la luz que recibe.

Los valores resistivos que alcanza van de los 100Ω a los 10kΩ bajo una luz brillante, hasta valores en la oscuridad que típicamente están entre los 500kΩ y los 10MΩ .

Para nuestro ejemplo usaremos el  VT90N2. Aquí lo tenéis junto a una tarjeta SD para comparar el tamaño.

Este modelo en concreto se encuentra en muchos kits de Arduino, tiene una resistencia en la oscuridad de 0,5MΩ y unos 100Ω, bajo luz intensa.

Para usarla en este montaje necesita una resistencia convencional para montar un divisor de tensión a modo de resistencia pull-down. El esquema del circuito que utilizaremos es el siguiente:

Mi propuesta para el montaje en la protoboard es esta:

Es totalmente necesario el uso de la resistencia pull para poder tener variación de tensión en la entrada analógica del Arduino, pues si conectaremos la resistencia directamente a la entrada analógica, entre VCC y masa, tendríamos variación en la intensidad que fluye a través de la resistencia, pero no variaciones de tensión que es lo que podemos analizar con el conversor AD.

El algoritmo del sketch sería muy sencillo, pues tan solo queremos que lea el valor de la resistencia, lo compare con un valor de consigna, y decida si debe apagar o encender el led.

Os invito a intentar encontrar la solución antes de continuar leyendo... tic tac tic tac.

De acuerdo pues aquí os dejo el sketch. Y podéis descargarlo desde aquí.

/* Ejemplo !_), recreamos un interruptor
crepuscular que actua en funcion del valor leido
por una LDR. Ver el video para ver como ajustar
en http://arduinopractico.blogspot.com.es */

int LDR_Pin = 0;  //pin conectado al fotoresistor LDR
int ledPin=9;     //pin conectado al led
int luminosidad;  // variable para registrar la lectura del LDR
int umbral=330;   // valor umbral de luminosidad
void setup()
{
    Serial.begin(9600);  //Begin serial communcation
    pinMode( ledPin, OUTPUT );//  Lo usaremos para ver la lectura real
    digitalWrite(ledPin,LOW);// y ajustar si necesario
}

void loop()
{
   
    luminosidad= analogRead(LDR_Pin); 
    Serial.println(analogRead(luminosidad)); //Escribimos el valor en monitor serie
    //monitorizando este valor podemos  ajustar el umbral para encender el led
    //en funci´n de la luminosidad
    if (luminosidad > umbral)// valor experimental
    {
      digitalWrite(ledPin,LOW);// si la luminosidad es mayor apagamos el led
    }    
    else
    {
      digitalWrite(ledPin,HIGH);// en caso contrario encendemos el led
    }
      
   delay(10); // A mayor valor mas lenta sera la respuesta a los cambios de luminosidad
}

Si os fijais, he incluido una línea para poder monitorizar el valor que obtenemos, ( entre 0 y 1023) de la resistencia LDR en el pin A0 del micro. Para activarlo debereis ir al monitor serial desde el IDE de Arduino.

Serial.println(analogRead(luminosidad));

La explicación del funcionamiento es muy sencilla, primero declaramos las cuatro variables que intervienen en el ejemplo:

int LDR_Pin = 0;  //pin conectado al fotoresistor LDR
int ledPin=9;     //pin conectado al led
int luminosidad;  // variable para registrar la lectura del LDR
int umbral=330;   // valor umbral de luminosidad

Una vez comienza el ejemplo, realizamos la lectura analógica en el pin 0, y lo almacenamos en la la variable luminosidad.

luminosidad= analogRead(LDR_Pin); 

En el siguiente bloque usamos una forma condicional, IT THEN, ( lo podéis repasar aquí), para comparar el valor leído con lo que queremos que sea nuestro umbral de luminosidad.

if (luminosidad > umbral)

Si es mayor, apagaremos el led ( entendemos que hay suficiente luz ambiental).

Por otro lado cuando cae por debajo de nuestra consigna encendemos nuestro led.

if (luminosidad > umbral)// valor experimental
    {
      digitalWrite(ledPin,LOW);// si la luminosidad es mayor apagamos el led
    }    
    else
    {
      digitalWrite(ledPin,HIGH);// en caso contrario encendemos el led
    }
      

El valor que que he usado es experimental. Dependerá del valor que uséis en la resistencia para hacer el PULL, del LDR, de la temperatura, etc.

Por eso es interesante el uso del monitor serial para monitorizar los valores obtenidos y ajustar de forma empírica.

Como procederíamos?

Cargamos el sketch,

y activamos el monitor serial (Heramientas > Monitor serie):

Simulando la luminosidad que queremos obtener y observando el monitor serial tendremos una idea de que valor aproximado podemos usar para nuestro circuito.

Un último consejo, para un ajuste de "campo" más sencillo, en el caso que quisiéramos cambiar este valor de forma más sencilla sin necesidad de conectarnos, sería sustituir la resistencia de 10kΩ por un potenciómetro.

Un video de ejemplo:

Trabajando con pulsadores II.

Hola de nuevo.

Quedó pendiente de la anterior entrada dos ejercicios propuestos. Vamos a trabajar el segundo de ellos, pulsar para activar el ciclo y pararlo con otra pulsación sobre el mismo interruptor, que es donde reside la gracia.

Para poder activar y desactivar el led, necesitaremos recordar en qué estado se encontraba la salida, de manera que el Arduino cambie su valor en función de cual fuese su estado anterior.

Para almacenar este estado haremos uso de una variable. Las variables,se almacenan en la memoria del Arduino y pueden contener diferentes tipos de datos. Una variable puede ser del tipo número, texto, booleana, un array, etc. El tipo de contenido que quieres almacenar tienes que decidirlo antes de empezarla a usar, y es importante no sobredimensionarla, puesto que en el momento de declararla, reservará ese espacio en la memoria lo uses o no, y como ya hemos comentado nuestro Arduino tiene una memoria RAM realmente limitada.

Las variables de tipo numérico que se pueden utilizar son:

• byte: almacena un número natural entre 0 y 255 (1 byte).
• int: almacena un número entero entre -32768 y 32767 (2 bytes).
• unsigned int: almacena un número natural entre 0 y 65536 (2 bytes).
• long: almacena un número entero entre -2147483648 y 2147483647 (4 bytes).
• unsigned long: almacena un número entero entre 0 y 4294967295 (4 bytes).
• float: almacena un número decimal con un rango entre -3.4028235·1038 y 3.4028235·1038 (4 bytes).
• const: especifica que la variable definida no podrá ser cambiada durante el programa, siendo siempre un valor constante:

                                      const float pi=3.1415;

Para este ejemplo también usaremos otro tipo de constante de tipo boolean. La variable de tipo booleana solo puede contener dos estados TRUE o FALSE (verdadero o falso), en función de si se cumple o no la condición. La explicaremos más adelante.

Volviendo al ejemplo, debemos definir en este punto cual queremos que sea el comportamiento. Hemos decidido que ,

• El montaje empiece con el led apagado,
• El Arduino "vigila" la entrada en espera de una pulsación. Cuando se produce pone                  el LED a "1".
• A partir de aquí cambiará el estado del led en cada pulsación que se aplique sobre el pulsador.

Para conseguir este comportamiento, el Arduino debe recordar varias cosas. Una es el estado actual del pulsador. Necesitará comparar con el estado anterior, y comprobar si ha habido una pulsación( o si todavía durase la misma).
Y el estado del led, puesto que deberá apagarlo o encenderlo en función de cómo estaba anteriormente.
Por tanto las variables de nuestro montaje podrían ser las siguientes:

• valor_actual: leerá y almacenará el estado del pulsador
• valor_anterior: almacenará cada cambio de estado el estado previo
• estado_led: almacenará el estado del led, encendido o apagado

El sketch quedaría de la siguiente manera:

// Ejemplo 1_6 _Uso de un pulsador para ON-OFF
// Una pulsación activa el LED, que quedará enecendido
// hasta recibir otra pulsación

const int LED = 9; // pin de salida
const int PULSADOR = 2; //pin para el pulsador

int valor = 0; // variable que almacenará la lectura del pulsador
int old_valor = 0; //variable que almacenará la lectura anterior
// del pulsador. Comparandolas sabremos si ha cambiado
int estado_led = 0; // Variable que almacena el estado del LED
// de salida
void setup() 
{
pinMode(LED, OUTPUT); // Programamas el LED como salida
pinMode(PULSADOR, INPUT); // el PULSADOR como entrada
}
void loop()
{
valor = digitalRead(PULSADOR); // leemos el pulsador
// y comprobamos si ha habido un cambio de estado
// comparandolo con el valor anterior

if ((valor == HIGH) && (old_valor == LOW)){
estado_led = 1 - estado_led;
delay(10);
}
old_valor = valor; // El valor leído ahora ya es el "viejo"
// así que lo almacenamos para la siguiente pulsación

if (estado_led == 1)
{
digitalWrite(LED, HIGH); // Encendemos el led si el estado_led es "1"
} else {
digitalWrite(LED, LOW);
}
}

 Puedes descargar el sketch aquí.

El montaje es el habitual hasta ahora, pero lo recuerdo por si acaso:

La parte que tiene la"chicha" del programa es esta:

if ((valor == HIGH) && (old_valor == LOW)){
estado_led = 1 - estado_led;

Que estamos haciendo, comparamos la lectura del pulsador con la anterior lectura realizada. Si la lectura actual es "1", y la anterior "0", hay una transición o flanco de subida, por lo tanto una pulsación.

Cómo queremos que a cada pulsación conmute el estado de nuestra salida  usamos un truco de programación para  invertir esa variable. Es la línea:

estado_led = 1 - estado_led;

¿Cómo actuaría si sustituyes estado_led por 0 o por 1?,¿o viceversa? Verás que la fórmula invierte, el valor en los dos casos.

¿Funciona? Sí, este programa lo puedes encontrar muy parecido en algún libro sobre el Arduino. Pero hay una forma más "elegante" de hacerlo. Para ello explicaremos las variables Booleanas.

Variables tipo boolean

Este tipo de variable, que ocupa un byte, sólo puede tomar dos valores TRUE o FALSE, (verdadero o falso). Como en nuestro caso  el led solo puede estar encendido o apagado , podríamos definir la variable estado_led como boolena y reescribir el código de la siguiente manera:

// Ejemplo 1_6boolean _Uso de un pulsador para ON-OFF
// Una pulsación activa el LED, que quedará encendido
// hasta recibir otra pulsación

const int LED = 9; // pin de salida
const int PULSADOR = 2; //Entrada para el pulsador

int valor = 0; // variable que almacenará la lectura del pulsador

int old_valor = 0; //variable que almacenará la lectura anterior
// del pulsador. Comparandolas sabremos si ha cambiado

boolean estado_led = false;//En este caso cambiamos la variable int por
// una del tipo boolean. Es la que almacena el estado del LED.La ponemos

// =, o FALSE

void setup() 
{
pinMode(LED, OUTPUT); // Programamas el LED como salida
pinMode(PULSADOR, INPUT); // el PULSADOR como entrada
}
void loop()
{
valor = digitalRead (PULSADOR); // leemos el pulsador
// y comprobamos si ha habido un cambio de estado
// comparandolo con el valor anterior

if ((valor == HIGH) && (old_valor == LOW)){
estado_led = !estado_led;// El símbolo ! invierte el estado
//de la bariable de tipo boolean
delay(20);
}
old_valor = valor; // El valor leído ahora ya es el "viejo"
// así que lo almacenamos para la siguiente pulsación

if ( estado_led == true)//El otro cambio, ahora verificamos si el 
//estado es TRUE que equivale a "1" o HIGH
{
digitalWrite(LED, HIGH); // Enecendemos el led si estado_led TRUE
} 

else {
digitalWrite(LED, LOW);
}
}

Lo puedes descargar desde aquí.

¿Donde están las diferencias?
1.- En la definición de las variables, ahora estado_led es boolean.
      boolean estado_led = false;
2.- En como se invierte la variable estado_led, ahora sé usa el simbolo !.
      estado_led = !estado_led;
3.- Cuando se analiza la condición, ahora se comprueba si es TRUE or FALSE. en lugar de "1" o "0".
      if ( estado == true)

Una nota más antes de dejaros con el video.

Veréis que hay un delay por ahí en medio. Este delay hace las veces de condensador en el montaje de las resistencias PULL-DOWN. Es decir, si lo montáis sin condensador, y no ponéis este delay, notaréis que tiene un funcionamiento errático, puesto que el Arduino es tan rápido en la ejecución del programa que puede leer los rebotes del pulsador. Por tanto lo "entretenemos" con un delay para que pase el rebote del pulsador antes de la siguiente lectura. Si queréis comprobarlo, anular el delay o bajar el tiempo y lo podréis valorar.

Yo he tenido rebotes con valores de delay por debajo de 10ms.

Ahora sí, hasta la siguiente entrada. Nos vemos.

Otro ejemplo con PWM. Fade-in y fade-out en un led.

Veamos otro ejemplo con el uso de PWM.

El enunciado del ejemplo sería programar un bucle que encienda un led de manera progresiva hasta su máxima luminosidad y lo apague de la misma manera. Pretendemos simular algo parecido al comportamiento de un led en standby de un portátil.

Para ello, utilizaremos el bucle for que ya vimos en pasadas entradas y la función analogWrite().

Usaremos el mismo montaje de la entrada anterior.

El algoritmo del programa  sería algo como esto:

• Inicializar entradas y salidas.
• Hacer un bucle ascendente de 0 a 255 (valor máximo y mínimo) que incremente la salida analógica.
• Hacer un bucle descendente que de 255 a 0 que vaya apagando el led.
• Repetir indefinidamente...

El programa, perdón el sketch, quedaría:

//Ejemplo 1_5. Encendido y apagado progresivo de un led
// Modificaremos su luminosidad actuando sobre el ciclo de carga
// de la seña de salida

const int LED = 9; // Pin conectado al LED
int i = 0; // Variable que usaremos para el bucle for

void setup() 
{
  pinMode(LED, OUTPUT); // Configuramos el pin como salida
}
void loop()
{
  for (i = 0; i < 255; i++) // bucle de 0 a 254 (fade in).Vamos
                            // incrementando el ciclo de trabajo
  {                         //de 0 a 255     
  analogWrite(LED, i); // esta línea configura el brillo del LED
  delay(10); // Colocamos una espera de 10ms para poder apreciar
             // el efecto. De otro modo sería tan inmediato que
             //no lo veríamos
  }//fin del primer for.   
  for (i = 255; i > 0; i--) { // bucle de 255 a 1 (fade out)
  analogWrite(LED, i); // esta línea configura el brillo del LED
  delay(10); // Espera de 10ms
  }
}

Lo podéis encontrar para descargarlo aquí:

El código es bastante sencillo, así que vamos a añadir un mínimo de complejidad. Vamos a modificar el ejemplo para que sea la activación de un pulsador la que inicie el ciclo.

Cómo sería el algoritmo en esta ocasión:

• Inicializar entradas y salidas.
• Leer el estado del pulsador e iniciar el ciclo si se pone a “1”, (se pulsa)
• Hacer un bucle ascendente de 0 a 255 (valor máximo y mínimo) que incremente la salida analógica.
• Hacer un bucle descendente que de 255 a 0 que vaya apagando el led.
• Repetir indefinidamente…

Ok, sencillo ¿no? Solo hemos añadido una línea  en el algoritmo, y ¿en el sketch? Dad le una vuelta antes de seguir leyendo…

…Una vuelta más…

… ¿Ya? Bien pues aquí mi propuesta:

//Ejemplo 1_5b. Encendido y apagado progresivo de un led
// modificando su luminosidad actuando sobre el ciclo de carga
// de la seña de salida. El ciclo lo inicia una pulsación

const int LED = 9; // Pin conectado al LED
const int pulsador = 2 ; //Pin conectado al pulsador
int i = 0; // Variable que usaremos para el bucle for

void setup() 
{
  pinMode(LED, OUTPUT); // Configuramos el pin como salida
  pinMode(pulsador, INPUT); //Configuramos el pin como entrada
}
void loop()
{
    digitalWrite (LED, LOW); //Fijamos la condición inicial del LED
if ( digitalRead(pulsador) == HIGH ) 
  {
    for (i = 0; i < 256; i++) // bucle de 0 a 255 (fade in).Vamos
                            // incrementando el ciclo de trabajo
    {                         //de 0 a 255     
    analogWrite(LED, i); // esta línea configura el brillo del LED
    delay(10); // Colocamos una espera de 10ms para poder apreciar
               // el efecto. De otro modo sería tan inmediato que
               //no lo veríamos
     }//fin del primer for.   
     for (i = 255; i > 0; i--) 
     { // bucle de 255 a 1 (fade out)
     analogWrite(LED, i); // esta línea configura el brillo del LED
     delay(10); // Espera de 10ms
     } // fin del segundo for
    }//Fin condición de la pulsación
    digitalWrite (LED, LOW); //Apagamos el LED en espera de otro pulso
}

¿En qué varía el código? Bien de entrada fijamos que cuando se ejecuta el bucle, el LED esté apagado en espera de recibir una pulsación.

       digitalWrite (LED, LOW);

Seguidamente ponemos una condición con un IF, (ya lo trabajamos aquí), para detectar un flanco positivo en la entrada, (vamos una pulsación):

        if ( digitalRead (pulsador == HIGH ))

Y pasamos a copiar el código anterior. Tan solo debemos recordar salir del bucle volviendo a apagar el LED en espera de otra pulsación.

         digitalWrite (LED, LOW);

El sketch para descarga lo puedes encontrar aquí.

Este montaje tiene muchas posibilidades. Podríamos intentar por que tras la pulsación repita el ciclo n número de veces y se apague.

Otra aún más interesante, que una pulsación comience el ciclo y otra lo apague (con un solo pulsador).  Os dejo con el vídeo del funcionamiento de los dos ejemplos, y en la próxima entrada la solución a estas dos propuestas. Nos vemos.

Modulación por ancho de pulsos. PWM en Arduino

Hola de nuevo,

Bueno una semana sin ordenador, así que una semana casi en blanco. Vamos al lío.

Hoy vamos a explicar un nuevo concepto. Para realizar esta entrada necesitaremos:

- 1 x arduino UNO o compatible,
- 1  x Resistencia de 220ohms, si empezáis podéis comprar un lote de varios valores, por ejemplo como este lote de 400 resistencias, por poco más de 2 €
- 1 x Led, del color que más os guste. Os recomiendo un kit de varios colores si todavía estáis empezando,
- 1 x Protoboard, o placa de prototipos, para realizar los montajes de forma sencilla y sin soldaduras.

PWM, (pulse-width modulación), o modulación por ancho de pulsos.

Esta técnica modifica el ciclo de trabajo de una señal periódica, es decir la relación entre el tiempo que está en su parte positiva y el que está en su parte negativa. La fórmula que lo rige:

Donde:

D es el ciclo de trabajo

 es el tiempo en que la función es positiva (ancho del pulso)

T es el período de la función

Un gráfico de ejemplo:

¿Qué usos se le da a este tipo de señales? Algunos de ellos son:

- Generar señales de audio.
- Variar la velocidad de los motores
- Generar una señal analógica , si se filtra la salida digital
- Generar una señal modulada, para por ejemplo pilotar un LED infrarrojo de un control remoto,
- Variar la luminosidad de un led,

Hay muchas aplicaciones que se puede dar a este tipo de modulación de señales.

Para nuestro ejemplo vamos a diseñar un "dimmer" muy sencillo que ilumine el led al 10%, variando el ciclo de carga de la señal que haremos llegar al led. Lo que hará nuestro algoritmo es encender y apagar el LED, pero con una frecuencia tan alta, que nuestro ojo no percibe el parpadeo, sino una menor luminosidad. Variando el ancho del pulso incrementaríamos el ciclo de carga, pasaría mayor tiempo encendido y por tanto dará la sensación de mayor luminosidad.

El hardware del ejemplo, será nuestro archiconocido LED rojo, conectado al Arduino en su pin 9 a través de una resistencia de 220Ω. Por si hay alguna duda, algo como esto:

El algoritmo de lo que queremos hacer sería:

- programar el led 9 como salida
- Encender el led, ponerlo a "1"
- Esperar durante 100  μs,
- Apagar el led,
- Esperar durante 900 μs,
- Repetir indefinidamente,

Una propuesta para nuestro programa sería esta:

void setup()
{
  pinMode(9, OUTPUT); // Definimos el pin 9 como salida
}
void loop() {
  digitalWrite(9, HIGH); // Ponemos el pin a 1
  delayMicroseconds(100);// Aprox un ciclo de carga del 10% para un 1KHz
  digitalWrite(9, LOW);
  delayMicroseconds(900);
}

Puedes descargarlo aquí.

Ejemplo 1_4 dimmer con delays

El programa es muy sencillo, y podemos realizar pruebas con la luminosidad final del led, tan solo variando los tiempos de delay.

Así si queremos una luminosidad del 50%, generaríamos una onda cuadrada con un ciclo de carga del 50%, es decir colocando 500 y 500 en cada delay.  Para un 25%, 250 y 750 respectivamente , y así para cualquier combinación que queramos. Recuerda volver a cargar el programa después de cada cambio para hacerlo efectivo.

Pros y contras

Dejando de lado la incomodidad de cambiar el ciclo a mano y volver a cargar el programa, esta manera de trabajar generando la onda de esta manera, tiene varios inconvenientes:

- El ciclo de trabajo está calculado aproximadamente  y se vería afectado por cualquier interrupción en el programa, a no ser que las anulemos, y si las deshabitamos...

- El Arduino no podrá hacer otra cosa mientras se ocupe del tren de impulsos, por lo que no resulta excesivamente práctico.

Algo positivo que se me ocurre de esta manera de proceder, es que podemos implementarlo en cualquier salida digital del Arduino.

Veamos entonces otra forma de implementarlo.

analogWrite()

Esta función tiene la siguiente sintaxis:

analogWrite (pin,valor)

Donde los parámetros son:

pin: el pin que usaremos,
valor: ciclo de carga, entre 0 y 255. (0 siempre apagado, 255 siempre encendido, 127 al 50%, etc...)

Esta función genera en el pin especificado una señal cuadrada cuyo ciclo de carga variará entre entre 0 y el 100% (valores entre 0 y 255). En el Arduino UNO los pins que pueden ejecutar esta función son los pins 3, 5, 6, 9, 10 y 11. 

La frecuencia de la señal cuadrada es de aproximadamente 490 Hz, excepto en los pies 5 y 6 que será de aproximadamente 980 Hz.  

Como quedaría el programa entonces:

const int ledPin = 9;
const int DutyCicle = 255;/* Usaremos un valor de 25 para un 10%, 
67 para un 25%, 127 para un 50% y 255 para un 100% */

void setup()
{   
  pinMode(ledPin, OUTPUT); // Definimos el pin 9 como salida 
}
void loop()
{
  analogWrite(ledPin,DutyCicle);//asignamos pin 9 un ciclo carga del 10% aprox
                    //el valor de un 10% estaría entre un valor de 25
}

Puedes descargarlo aquí:

Ejemplo 1_4b dimmer con analogWrite

Ahora podemos variar nuestra luminosidad (ciclo de carga o duty cicle), tan solo variando un parámetro. Prueba los siguientes valores:

- 0, siempre apagado,

- 63, un 25% de luminosidad,

- 127, un 50%

- 255, un 100% siempre encendido,

Recuerda volver a cargar el programa tras el cambio de valor.

Un apunte más, este tipo de control sobre la luminosidad de un LED, (o cualquier tipo de carga) es mucho más eficiente que hacerlo intercalando un potenciómetro, puesto que aquí no hay perdida de potencia en forma de disipación de calor que si se daría en un potenciómetro o carga resistiva.

Un video de ejemplo:

Trabajando con pulsadores. Uso de If ..

Hola de nuevo.

Ahora que sabemos como funciona el hardware necesario para implementar un pulsador, vamos a ver un ejemplo de programación sencillo para leer el estado de un pulsador.

En este punto necesitaremos introducir una nueva referencia del lenguaje de programación de Arduino .El condicional if.

Esta sentencia siempre va acompañada de unos comparadores, que son los que verifican que la condición expuesta se cumpla. Un ejemplo:

if (x == 10)                // condición que debe comprobar

{ 

digitalWrite(pin1, HIGH);

}  // Entre estos corchetes introducimos todas las acciones que queremos que se ejecuten si se cumple la condición                    

Este sencillo ejemplo verifica si la variable X es igual a 10. En caso de que se cumpla, pondrá a "1" el pin 1. Si la condición se cumple el programa ejecutará la parte de programa que se encuentra       entre { }.

¿Qué clase de comparaciones podemos realizar? Las siguientes:

x = = y , (x es igual que y)

x ! = y,   (x no es igual que y )

x > y ,    (x es mayor que y)

x < y,     (x es menos que y)

x >= y,   (x es igual o mayor que y)

x <=y,    (x es igual o menor que y)

Es importante no confundir x=y, con x==y. En el primer caso , no es tamos comparando x con y, sino dando directamente a x el calor de y. Con lo que si estuviésemos dentro de la comparación ,ésta siempre se cumpliría.

Un ejemplo completo, que active una salida durante dos segundos cuando pulsamos el pulsador.

//Ejemplo 1.3a Ejemplo para programar una entrada de Arduino que obedece a un 

//pulsador

//La salida permanecera activa durante 2 segundos despues de cada pulsacion

int pulsador = 2; //entrada de arduino a la que conectaremos nuestro pulsador

int led = 8; // salida de Arduino en la que conectaremos el led

void setup()
{
  pinMode(pulsador,INPUT); //Definimos el pulsador como entrada. Esta conectado                               //a resistencia pull-down  

  pinMode(led,OUTPUT);     //Definimos el led como salida
}

void loop()

{
if ( digitalRead(pulsador) == HIGH )
{

digitalWrite(led,HIGH);
delay (2000);               // lo mantenemos encendido 2 segundos

digitalWrite(led,LOW);
}
}

El esquema eléctrico del ejemplo es el siguiente:

Un ejemplo de disposición en la protoboard podría ser:

El sketch verificado lo puedes descargar de:

Ejemplo 1.3a Pulsador simple


Ahora, sí ha quedado claro el ejemplo podríamos darle una vuelta más al ejemplo de "la ola", y hacer que se iniciase con la pulsación del pulsador. Intentadlo antes de copiar el ejemplo. Mi propuesta para conseguirlo sería esta:

//Ejemplo1.3b Modificacion del ejemplo de la ola//para conseguir que la activacion responda a la pulsacion

int d=200; // variable de tipo integer, que define el tiempo de delay

int pulsador = 2; //entrada de arduino a la que conectaremos nuestro pulsador

int led = 8; // salida de Arduino en la que conectaremos el led

void setup()
{
  pinMode(pulsador,INPUT); //Definimos el pulsador como entrada. Esta conectado                               //a resistencia pull-down  

  pinMode(led,OUTPUT);     //Definimos el led como salida  

  pinMode(2,OUTPUT);       //Pin 2 conectado al led 1, definido como salida  

  pinMode(3,OUTPUT);       //Pin 3 conectado al led 2, definido como salida  

  pinMode(4,OUTPUT);       //Pin 4 conectado al led 3, definido como salida  

  pinMode(5,OUTPUT);       //etc...
}
void loop()
{
  if ( digitalRead(pulsador) == HIGH )
    {
     for ( int a = 2; a < 6; a++ )
      {
      digitalWrite(a,HIGH);
      delay (d);
      digitalWrite(a,LOW);
      delay (d);
      }
    }
delay(10);
}

Lo podeis descargar verificado del siguiente enlace:

Ejemplo 1.3b Pulsador en ejemplo de "La ola"

Podéis observar que en este ejemplo la sangría de cada bucle o parte de programa es diferente.          Es solo una norma de estilo, pero ayuda a entender donde acaba cada sentencia. Es importante también contar los corchetes,e ir cerrándolos, sino nos dará error a la hora de compilar el programa.

Un apunte para aquellos que hayan trabajado con autómatas tipos Siemens,Omron, etc. El trabajo con un Arduino difiere un poco ya que el autómata reacciona al cambio de estado de sus entradas ejecutando el proceso que hayas programado. Es decir, están constantemente "monitorizadas".

En un Arduino sin embargo, has de hacer una lectura constante de éstas, y ejecutar el código cuando detectas que ha cambiado de estado.

Os dejo con un video para ver el funcionamiento de los proyectos, y observéis la realización del conexionado.