Comunicación serial entre el Arduino y nuestra computadora.

El objetivo este ejercicio es poder imprimir valores, resultados, etc., de lo

que sucede con nuestra placa Arduino en una ventana de nuestra
computadora. Por ejemplo, si estamos trabajando con un LED podemos
imprimir en pantalla el valor de la intensidad de ese LED, o si estamos
haciendo lecturas análogas nos ayudará a saber el valor de la lectura e
imprimirlo en una ventana de nuestra computadora. Primero que nada
vamos a hablar un poco acerca de que trata la comunicación serial.

La comunicación serial es un protocolo de envio de información a traves

de computadoras, consiste en enviar y recibir una secuencia de bits, es
decir, enviar o recibir un bit a la vez a un ritmo o frecuencia acordada
entre las dos computadoras a través del puerto USB. Nuestra tarjeta
Arduino posee comunicación serial para poder hacer intercambio de
información con el PC u otros dispositivos a través de los pines digitales 0
(RX) y 1 (TX) así como con el PC mediante USB.

void setup()
{

Serial.begin(9600); //Establecemos la
velocidad de comunicacion serial
Serial.println(" Hello world! "); //Imprimimos
nuestro "Hello World!" en monitor serial
}

void loop()
{
//No hacemos nada al entrar al loop o ciclo infinito
}

Hay una parte que dice Serial.begin(9600); , en esta parte establecemos la

velocidad a la que nos vamos a estar comunicando por el puerto serial, en
este caso va a ser de 9600 bps (bits por segundo). Justo por debajo
utilizamos una función Serial.println(“Hello World!”); con este pedazo de
código imprimimos texto en el monitor serial del arduino.
Arduino Básico: Lectura Analógica Serial

Programa que lee una entrada analógica conectada a un potenciómetro

de 5 kΩ y muestra el valor leido en la computadora.

Un potenciómetro es un simple dispositivo mecánico que proporciona un

valor variable de resistencia dependiendo de la posición de giro en que se
encuentra su eje. El potenciómetro forma lo que se llama un divisor de
voltaje que son dos resistencias conectadas en serie en donde los pines
del potenciómetro corresponden a los extremos de cada resistencia y el
punto común de conexión o pin central. Al girar el potenciómetro lo que
estamos haciendo es variar la proporción entre ambas resistencias. Si el
potenciómetro es de 5KΩ, al estar girado completamente en un sentido,
una de las resistencias será casi 5KΩ y la otra casi 0Ω. Si lo giramos
completamente en el otro sentido, los valores se van a invertir. Al final lo
que interesa saber es que la suma de ambos siempre va a da 5KΩ o el
valor correspondiente del potenciómetro.

El IDE del Arduino nos proporciona una herramienta que nos permite
enviar y visualizar los datos que se manejan a través del puerto Serial.
Dicha herramienta se conoce como Monitor Serial y se puede encontrar en
el menú de herramientas, en la opción “Monitor Serial”.
 
La tarjeta Arduino tiene una circuito interno llamado convertidor análogo-
digital (también conocido como ADC, por sus siglas en ingles Analog to
Digital Converter) que lee un voltaje de 0V a 5V y devuelve un número en
una escala entre 0 a 1023. El comando analogRead() retorna el valor del
ADC que es aproximadamente proporcional al valor de voltaje aplicado al
pin de entrada analógica.

Al conectar el potenciómetro a la entrada analógica vamos a poder

observar que podemos variar el voltaje en el pin central entre 0 y 5V.
 
En la función setup se inicia la comunicación serial, a 9600 bits de
información por segundo, entre la tarjeta Arduino y la computadora con el
comando: Serial.begin(9600);

Luego, en el loop principal del código, se necesita establecer una variable

para almacenar el valor de la resistencia (el cual esta entre 0 y 1023)
proveniente del potenciómetro: int valor_sensor = analogRead(A0);

Finalmente, se necesita mostrar esta información usando el monitor serial.

Se puede hacer esto usando el comando Serial.println() en la última línea
del código: Serial.println(valor_sensor, DEC);
Cuando se abra el monitor serial, se deberá ver una cadena de números
en el rango de 0 a 1023, que cambiará cada vez que giremos el
potenciómetro mostrando el número equivalente al voltaje en la escala.
/*
  Lectura Analógica Serial
  Leer una entrada analógica del pin 0, muestra el resultado por el Serial
Monitor.
 */

void setup()
{

  Serial.begin(9600); // inicializa la comunicación serial en

9600 bits por segundo
}

void loop()
{
   int valor_sensor = analogRead(A0); // lee la entrada analógica
desde el pin 0
   Serial.println(valor_sensor); // muestra el valor que se leyó
  delay(1);         // retraso entre lectura y lectura,
para la estabilidad
}
Arduino Básico: Lectura Serial Digital

La comunicación serial mas simple usa 2 líneas. Al pin que transmite

y al que recibe se les llama TX y RX respectivamente. Cuando
conectamos dos dispositivos el TX de una se conecta al RX de la otra
y viceversa, de éste modo lo que se transmita por el pin TX de uno
será recibido en el RX del otro. En el caso de la comunicación serial
del arduino es lo mismo, sin embargo la diferencia es que en la
computadora se emula el puerto serial a través de la conexión USB.
En el arduino los pines utilizados para la comunicación son 0 y 1 y
éstos pines tienen al costado RX y TX respectivamente.

Monitorearemos el estado de un pulsador mediante el

establecimiento de una comunicación serial entre la tarjeta Arduino y
la computadora. El IDE del Arduino nos proporciona una herramienta
que nos permite enviar y visualizar los datos que se manejan a través
del puerto Serial. Dicha herramienta se conoce como Monitor Serial y
se puede encontrar en el menú de herramientas, en la opción
“Monitor Serial”.
 
Al presionar el interruptor o el pulsador se conectan los dos puntos.
Cuando el pulsador esta abierto (no presionado) no hay conexión
entre sus 2 patas. Así que el pin es conectado hacia tierra y lo lee
como LOW, o 0. Cuando el pulsador esta cerrado (presionado), esto
crea una conexión entre sus dos patas, conectando el pin a 5 voltios,
así que el pin lo lee como HIGH, o 1.

En el sketch, el primer paso que se debe realizar es establecer los

parámetros de la comunicación entre la tarjeta Arduino y la
computadora, en este caso 9600 bits de dato por segundo, este paso
se realiza dentro de la función setup: Serial.begin(9600);

Luego, se inicializa el pin digital 2 como pin de entrada, este leerá la

salida del pulsador. pinMode(2,INPUT);

Ahora que el setup esta completo, nos dirigimos al loop principal del
código. Cuando el pulsador es presionado, 5 voltios se dirigirán desde
tu circuito, y cuando el pulsador no este presionado, el pin de
entrada estará conectado hacia tierra. Esto es una entrada digital,
eso significa que el pulsador puede estar solo en estado activo (visto
desde el arduino como un '1', o como HIGH) o en un estado no activo
(visto desde el arduino como un '0', o como LOW).
El primer paso que se necesita hacer en el loop principal es
establecer una variable que contenga la información proveniente del
pulsador. Esta información proveniente del pulsador puede ser un '1'
o un '0', se puede usar un int datatype. Llamamos a esta variable
sensorValue, esto se puede lograr con una sola línea de código: int
sensorValue = digitalRead(2);

Una vez que el Arduino ha leído la entrada, hacer que imprima esta
información en la computadora como un valor decimal. Se puede
hacer esto con el comando Serial.println() en la ultima linea del
código: Serial.println(sensorValue);

Ahora, cuando se abra el Serial Monitor en el entorno del Arduino, se

podrá ver una cadena de "0"'s si el pulsador esta presionado o una
cadena de "1"'s si el pulsador no esta presionado.

/*
  LecturaDigitalSerial
Lee una entrada digital del pin, muestra el resultado en el monitor
serial
Pulsador en configuración Pull Down
 */

int pulsador = 2; // declaracion de pulsador como una señal tipo

entera y asignada al valor 2

void setup() // la rutina de setup corre una vez o cuando se

presiona reset

{
   Serial.begin(9600); // inicializa la comunicación serial en
9600 bits por segundo
  pinMode(pulsador, INPUT);   // asigna al pin 2 como pin de
entrada
}

void loop() // la rutina loop corre constantemente

{  int estado_pulsador = digitalRead(pulsador);   // lee el pin
de entrada
  Serial.println(estado_pulsador);   // muestra el
estado del pulsador
  delay(1);        // retraso entre lectura
y lectura, para la estabilidad
}

Arduino Básico: Lectura Serial Digital V2

En esta versión se utiliza la función INPUT_PULLUP.

int boton = 7; // pulsador en configuración Pull up

void setup()
{
Serial.begin(9600); //Establecemos la
velocidad de comunicacion serial
Serial.println("Hello world!"); //Imprimimos
nuestro "Hello World!" en monitor serial
pinMode(boton, INPUT_PULLUP);
}

void loop()
{
if (digitalRead(boton) == LOW)
 {
Serial.println("Boton presionado");
}
delay(1000);
}

Ejecutamos y corremos nuestro monitor serial, ahora como podemos ver

cada vez que presionemos el swicht se mostrará en el monitor serial un
mensaje de que el botón fue presionado.
Programa que consiste en leer una entrada digital y mostrar en
monitor serial de Arduino el estado del pulsador cuando es oprimido.
Igual que el anterior solo que este te dice pulsado y no pulsado.

/*
   Lectura serial de una entrada digital
 
  Leer una entrada digital y mostrar por la pantalla del
  computador (consola serial) el estado del pulsador
  cuando es oprimido
*/

int boton=2; //Pin donde se

encuentra el pulsador, entrada
 
void setup()
{
pinMode(boton,INPUT); //Configurar el
boton como una entrada
Serial.begin(9600); //Inicia
comunicación serial
}
 
void loop()
{  
int estado = digitalRead(boton); //Guardar en una
variable entera el valor del boton 0 ó 1
if (estado==1) //Condicional para
saber estado del pulsador
{
Serial.println("Pulsado"); //Imprime en la
consola serial "Pulsado"
}
else // No esta pulsado
{
Serial.println("NO Pulsado"); //Imprime en la
consola serial "NO Pulsado"
}
Programa que consiste en leer una entrada digital y mostrar en
monitor serial de Arduino el estado del pulsador cuando es oprimido.
Igual que el anterior solo que este te dice pulsado y no pulsado.
  delay(100); //Retardo para la
visualización de datos en la consola
 }
 
Arduino Básico: Lectura de Voltaje Analógico V2

Similar al anterior solo que ahora veremos en el monitor serial el

valor del voltaje en vez del número en la escala del ADC.

  Pot de 5 K. Para cambiar el valor en el rango 0 a 1023 que nos

entrega el ADC al rango que corresponde de voltaje, se necesita
crear una variable que acepte números con decimales, en éste caso
de tipo float o punto flotante, y hacer una simple ecuación para
escalar los números entre 0.0 y 5.0: float voltaje = valor_sensor *
(5.0 / 1023.0);

/*
  Lectura de Voltaje Analógico
*/

void setup() // la rutina de setup corre una

vez o cuando se presiona reset
{ 
Serial.begin(9600);   // inicializa la comunicación
serial en 9600 bits por segundo
}

void loop()
{   
int valor_sensor = analogRead(A0);  // lee el pin de
entrada analogico (pin A0)
  float voltaje = valor_sensor * (5.0 / 1023.0);  // Convierto la
lectura analogica (de 0-1023)
// hacia un voltaje (0 -
5V):

Serial.println(voltaje);   // muestra el valor

}
Programa usando un potenciometro para aumentar y disminuir la
intensidad del LED, y usando el monitor serial.

void setup()
{

Serial.begin(9600); //Establecemos la
velocidad de comunicacion serial
Serial.println("Hello world!"); ); //Imprimimos
nuestro "Hello World!" en monitor serial
}

void loop()
{
int valorPotenciometro = analogRead(A0);
Serial.println("El valor del potenciometro es:");
Serial.println(valorPotenciometro);
delay(1000);
}

Este código hace lo mismo que en el anterior, solo que en el “loop()” hace
una lectura a la entrada analoga A0 y guarda el valor en
“valorPotenciometro” después imprime este valor en el monitor serial, y
hace un delay de 1000 ms. Con este código se puede monitorear el
cambio en una entrada análoga y desplegar el valor obtenido.
Arduino Básico: Lectura Serial Digital

La comunicación serial mas simple usa 2 líneas. Al pin que transmite

y al que recibe se les llama TX y RX respectivamente. Cuando
conectamos dos dispositivos el TX de una se conecta al RX de la otra
y viceversa, de éste modo lo que se transmita por el pin TX de uno
será recibido en el RX del otro. En el caso de la comunicación serial
del arduino es lo mismo, sin embargo la diferencia es que en la
computadora se emula el puerto serial a través de la conexión USB.
En el arduino los pines utilizados para la comunicación son 0 y 1 y
éstos pines tienen al costado RX y TX respectivamente.

Monitorearemos el estado de un pulsador mediante el

establecimiento de una comunicación serial entre la tarjeta Arduino y
la computadora. El IDE del Arduino nos proporciona una herramienta
que nos permite enviar y visualizar los datos que se manejan a través
del puerto Serial. Dicha herramienta se conoce como Monitor Serial y
se puede encontrar en el menú de herramientas, en la opción
“Monitor Serial”.
 
Al presionar el interruptor o el pulsador se conectan los dos puntos.
Cuando el pulsador esta abierto (no presionado) no hay conexión
entre sus 2 patas. Así que el pin es conectado hacia tierra y lo lee
como LOW, o 0. Cuando el pulsador esta cerrado (presionado), esto
crea una conexión entre sus dos patas, conectando el pin a 5 voltios,
así que el pin lo lee como HIGH, o 1.

En el sketch, el primer paso que se debe realizar es establecer los

parámetros de la comunicación entre la tarjeta Arduino y la
computadora, en este caso 9600 bits de dato por segundo, este paso
se realiza dentro de la función setup: Serial.begin(9600);

Luego, se inicializa el pin digital 2 como pin de entrada, este leerá la

salida del pulsador. pinMode(2,INPUT);

Ahora que el setup esta completo, nos dirigimos al loop principal del
código. Cuando el pulsador es presionado, 5 voltios se dirigirán desde
tu circuito, y cuando el pulsador no este presionado, el pin de
entrada estará conectado hacia tierra. Esto es una entrada digital,
eso significa que el pulsador puede estar solo en estado activo (visto
desde el arduino como un '1', o como HIGH) o en un estado no activo
(visto desde el arduino como un '0', o como LOW).
El primer paso que se necesita hacer en el loop principal es
establecer una variable que contenga la información proveniente del
pulsador. Esta información proveniente del pulsador puede ser un '1'
o un '0', se puede usar un int datatype. Llamamos a esta variable
sensorValue, esto se puede lograr con una sola línea de código: int
sensorValue = digitalRead(2);

Una vez que el Arduino ha leído la entrada, hacer que imprima esta
información en la computadora como un valor decimal. Se puede
hacer esto con el comando Serial.println() en la ultima linea del
código: Serial.println(sensorValue);

Ahora, cuando se abra el Serial Monitor en el entorno del Arduino, se

podrá ver una cadena de "0"'s si el pulsador esta presionado o una
cadena de "1"'s si el pulsador no esta presionado.

/*
  LecturaDigitalSerial
Lee una entrada digital del pin, muestra el resultado en el monitor
serial
 */

int pulsador = 2; // declaracion de pulsador como una señal tipo

entera y asignada al valor 2

void setup() // la rutina de setup corre una vez o cuando se

presiona reset

{
   Serial.begin(9600); // inicializa la comunicación serial en
9600 bits por segundo
  pinMode(pulsador, INPUT);   // asigna al pin 2 como pin de
entrada
}

void loop() // la rutina loop corre constantemente

{  int estado_pulsador = digitalRead(pulsador);   // lee el pin
de entrada
  Serial.println(estado_pulsador);   // muestra el
estado del pulsador
  delay(1);        // retraso entre lectura
y lectura, para la estabilidad
}
Arduino Comunicación: Evento Serial
/*
  Ejemplo evento Serial
 
Cuando llegan serialmente nuevos datos, el programa los agrega a
una cadena. Cuando se recibe una nueva línea, el codigo principal
(loop) imprime la cadena en el Monitor Serial y despues lo borra.
 
 */
String inputString = "";         // una cadena para contener
los datos entrantes
boolean stringComplete = false;  // si la cadena esta
completa
void setup()
{
   Serial.begin(9600); // inicializacion serial:
  inputString.reserve(200); // reserva 200 bytes para la
cadena de entrada
}
void loop()
{
   if (stringComplete) // imprime una cadena cuando
nueva linea llega:
{
    Serial.println(inputString);     // limpia la cadena
    inputString = "";
    stringComplete = false;
 }
}
/* SerialEvent ocurre cuando se recibe información en el receptor
serial (RX). Esta rutina se ejecuta entre cada loop() , por lo que el
retraso dentro del loop puede retrasar la respuesta. */
void serialEvent()
{
  while (Serial.available())
{
    char inChar = (char)Serial.read(); // obtiene un nuevo
byte:
    inputString += inChar;     // agrega esto hacia
inputString
  if (inChar == '\n') // si el caracter entrante es una nueva
linea, se configura una bandera
   // asi que el bucle principal puede hacer
algo acerca de esto:
{
      stringComplete = true;
  }
 }
}
Arduino Comunicación: Atenuador de brillo

Este ejemplo muestra cómo enviar datos desde una PC a una tarjeta
Arduino para controlar el brillo de un LED. Los datos se envían en
bytes individuales, cada uno de los cuales oscila en valor de 0 a 255.
Arduino lee estos bytes y los utiliza para ajustar el brillo del LED. El
IDE del Arduino nos proporciona una herramienta que nos permite
enviar y visualizar los datos que se manejan a través del puerto
Serial. Dicha herramienta se conoce como Monitor Serial y se puede
encontrar en el menú de herramientas, en la opción “Monitor Serial”.

/*
  Atenuador de brillo
Muestra los datos enviados desde la PC a la tarjeta Arduino. Con
estos se controla el brillo de un LED, se envían los datos en bytes
individuales, desde 0 a 255. Arduino lee los bytes y los utiliza para
ajustar el brillo del LED.
 */
const int ledPin = 9;       // Se declara una variable entera
con valor de 9

void setup()
{
   Serial.begin(9600); // inicializa la comunicacion
serial:
  pinMode(ledPin, OUTPUT);   // inicializa el ledPin como pin de
salida:
}
void loop()
{
  byte brightness; // revisa si el dato a sido enviado
desde la computadora:

  if (Serial.available())
{
  brightness = Serial.read(); // lee el byte más reciente (el cual
podría ser desde 0 hasta 255):   analogWrite(ledPin, brightness);
// determina el brillo del LED:
}
}
Arduino Analógico: Entrada analógica y salida serial
Si leemos una entrada analógica, el resultado esta en un rango de 0 a 255,
y usamos ese resultado para configurar una señal PWM que va hacia el
LED. El IDE del Arduino nos proporciona una herramienta que nos permite
enviar y visualizar los datos que se manejan a través del puerto Serial,
diicha herramienta se conoce como Monitor Serial.
 /*
Después de declarar los pines de salida,
entrada (pin analógico 0 para el
potenciómetro y pin digital 9 para el
LED) y dos variables, SensorValue y
OutputValue, en la función setup se
declara la velocidad de la comunicación
serial.
En void loop el valor de sensorValue se
asigna al pin analógico . Como el
comando analogRead tiene una
resolucion de 0-1023, y analogWrite una
resolución de 0 a 255, este dato debe
ser convertido antes de usarlo. Con el
fin de ampliar este valor, se utiliza una
función llamada  map (). OutputValue =
map(sensorValue, 0, 1023, 0, 255); El
nuevo valor asignado a outputValue es
la salida al LED, la cual varía segun el
giro del potenciometro.  Este resultado
esta dentro del rango 0 a 255 y se
envía como una señal PWM al pin de
salida y se muestra en el Serial Monitor
*/
const int analogInPin = A0;
const int analogOutPin = 9;
int sensorValue = 0;        // valor leido
desde el potenciómetro
int outputValue = 0;        // valor de la salida PWM (salida analógica)

void setup()
{
   Serial.begin(9600); // inicializa la comunicacion serial con 9600 bits
por segundo
}
void loop()
{
   sensorValue = analogRead(analogInPin);         // lectura de la entrada
analógica
   outputValue = map(sensorValue, 0, 1023, 0, 255);   // ubica el valor de
la entrada en el rango
//de la salida analógica
  analogWrite(analogOutPin, outputValue);       // cambia el valor de
salida analógica
  Serial.print("sensor = " );                        // muestra el resultado en
el Serial Monitor:
  Serial.print(sensorValue);      
  Serial.print("\t output = ");      
  Serial.println(outputValue);  
  delay(2);                    // espera 2 milisegundos antes
del siguiente ciclo
} 
Arduino Analógico: Calibración

En este ejemplo se demuestra una técnica para calibrar un sensor de

entrada. El Arduino toma la lectura del sensor durante los cinco
segundos durante la puesta en marcha y un seguimiento de los
valores más altos y más bajos que recibe. Estas lecturas, durante los
primeros cinco segundos de la ejecucion definen el mínimo y máximo
de los valores esperados para las lecturas tomadas durante el ciclo.
 

  /*
  Calibración
Antes de comenzar con la función setup(), se definen los valores máximos
y mínimos como:
int sensorMin = 1023;        // valor mínimo del sensor
int sensorMax = 0;           // valor máximo del sensor
 
Estas pueden parecer al revés. Inicialmente, se establece el alto mínimo y
leer cualquier cosa menor que eso, guardándolo como el nuevo mínimo.
Asimismo, se establece la máxima baja y leer cualquier cosa más alto que
el nuevo máximo, de este modo:
  while (millis() < 5000) // calibración durante los primeros cinco segundos

{
   sensorValue = analogRead(sensorPin);
      if (sensorValue > sensorMax) // asigna el nuevo máximo valor
{
     sensorMax = sensorValue;
   }
      if (sensorValue < sensorMin) // asigna el nuevo mínimo valor
{
     sensorMin = sensorValue;
   }
 }
De esta manera, cualquier lectura que se toma puede asignarse a un
rango entre el mínimo y el máximo de este modo:
 sensorValue = map(sensorValue, sensorMin, sensorMax, 0, 255); // aplica
la calibración a la lectura del sensor
 */
const int sensorPin = A0;    // el número del pin al cual se
conectará el sensor
const int ledPin = 9;           // el número del pin al cual se
conectará el LED
int sensorValue = 0;         // se inicializa el valor del sensor
int sensorMin = 1023;      // se inicializa el valor mínimo del
sensor
int sensorMax = 0;           // se inicializa el valor máximo del
sensor
void setup() {
 
  pinMode(13, OUTPUT); // prende el LED para señalar que
comienza el periodo de calibración
  digitalWrite(13, HIGH);

   while (millis() < 5000) // calibra durante los primeros cinco

segundos
{
    sensorValue = analogRead(sensorPin);

       if (sensorValue > sensorMax) // asigna el nuevo máximo valor

{
      sensorMax = sensorValue;
  }
    if (sensorValue < sensorMin)     // asigna el nuevo mínimo valor
{
      sensorMin = sensorValue;
  }
 }
  digitalWrite(13, LOW); // señala el fin del periodo de la
calibración
}

void loop()
{ 
sensorValue = analogRead(sensorPin);   // lee el sensor
  sensorValue = map(sensorValue, sensorMin, sensorMax, 0, 255);   //
aplica la calibracion a la lectura del sensor
   sensorValue = constrain(sensorValue, 0, 255); // en caso el
valor del sensor este fuera del rango
// visto durante la
calibración
  analogWrite(ledPin, sensorValue);   // se atenua el
LED usando el valor de calibración
}
Arduino Analógico: Cambio de brillo en un LED

Demuestra el uso de una salida analógica (PWM) para atenuar el

brillo de un LED. PWM es una técnica para conseguir un
comportamiento similar a la analógica en una salida digital
apagándolo y prendiéndolo muy rápido.
 
 

/*
  Atenuación
  Este ejemplo muestra como atenuar el brillo un LED usando la
función analogWrite().
*/
int ledPin = 9;     // el LED conectado al pin digital 9

void setup()  
{
 }
void loop()
 {
   for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) //
cambia el brillo desde el mínimo al máximo,
// incrementando de
5 en 5:
{
    analogWrite(ledPin, fadeValue);        
    delay(30);                                // espera por 30 milisegundos
para distingir el efecto de cambio  
  } 
for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5)   //
cambia el brillo desde el máximo al mínimo,
// disminuyendo de 5
en 5:
{
    analogWrite(ledPin, fadeValue);          delay(30);          // espera
por 30 milisegundos para
//distingir el efecto
de cambio
 }
}
Sentencia: Switch Case
Una sentencia if le permite elegir entre dos opciones diferenciadas,
verdadero o falso. Cuando hay más de dos opciones, puede utilizar
múltiples sentencias if, o puede utilizar la sentencia switch. la sentencia
switch permite elegir entre varias opciones discretas. En este ejemplo
usaremos la sentencia switch para cambiar entre cuatro estados deseados
de una fotoresistencia: muy oscuro, oscuro, medio y brillante. Este
programa lee primero la fotorresistencia. A continuación, utiliza el mapa ()
para mapear su salida a uno de cuatro valores: 0, 1, 2, o 3. Por último, se
utiliza la sentencia switch() para imprimir uno de los cuatro mensajes de
vuelta al ordenador, dependiendo de cuál de los cuatro valores se
devuelve.
/*
Sentencia Switch
Demuestra el uso de la sentencia Switch. La sentencia Switch
permite elegir entre un numero de valores discretos. Esto es como
una serie de sentencias if.
*/
const int sensorMin = 0;     // la máxima y mínima lectura
const int sensorMax = 600; //que se obtiene del sensor:

void setup()
{
   Serial.begin(9600);   // inicializa la comunicación serial:
}
void loop()
{
   int sensorReading = analogRead(A0); // Lectura del sensor
  int range = map(sensorReading, sensorMin, sensorMax, 0, 3);
  switch (range)   // dependiendo del valor de range realiza una
determinada acción
{
  case 0:    
    Serial.println("dark"); // una mano esta sobre el sensor
    break;
  case 1    Serial.println("dim");    // una mano esta cerca del sensor
    break;
  case 2    Serial.println("medium");   // una mano esta un poco alejada
del sensor
    break;
  case 3:        Serial.println("bright"); // una mano no esta cersa del
sensor
    break;
 }
  delay(1);        // retraso entre lecturas para la
estabilidad
}
Sentencia While Loop
 
A veces quieres que todo el programa se detenga mientras una condición
dada es verdadera. Usted puede hacer esto utilizando un while loop. En
este ejemplo se muestra cómo utilizar un while loop para calibrar el valor
de un sensor analógico.
En el loop principal, el siguiente esquema se lee el valor de una
fotorresistencia el pin 0 analógico y lo utiliza para desaparecer un LED en
el pin 9. Pero mientras se presiona un botón conectado al pin digital 2, el
programa se ejecuta un método llamado calibrar () que busca los valores
más altos y más bajos del sensor analógico. Al soltar el botón, continúa
con el bucle principal. Esta técnica le permite actualizar los valores
máximos y mínimos de la fotorresistencia cuando las condiciones de
ilumina.
  /*
  Condicional - Sentencia While
Mientras el pulsador es presionado, la rutina de calibración es corrida.
La lectura del sensor durante el while loop define el los valores máximo y
mínimos esperados de la fotoresistencia.  
Esta es una variación del ejemplo de calibración
 */
const int sensorPin = A2;       // el sensor se declara en el pin A2
const int ledPin = 9;           // ledpin se declara en el pin 9
const int indicatorLedPin = 13; // indicatorLedPin se declara en el pin
13
const int buttonPin = 2;         //el botón se declara en elpin 2
int sensorMin = 1023;  // mínimo valor del sensor
int sensorMax = 0;     // máximo valor del sensor
int sensorValue = 0;         // el valor del sensor

void setup()
{
  pinMode(indicatorLedPin, OUTPUT);
  pinMode (ledPin, OUTPUT);
  pinMode (buttonPin, INPUT);
}
void loop()
{
  while (digitalRead(buttonPin) == HIGH) // cuando el boton
es presionado hacemos la calibracion
{
    calibrate();
 }
   digitalWrite(indicatorLedPin, LOW);  // señal de
termino del periodo de calibración
  sensorValue = analogRead(sensorPin);   // lectura
del sensor:
  sensorValue = map(sensorValue, sensorMin, sensorMax, 0, 255); //
aplica la calibración a la lectura del sensor
  sensorValue = constrain(sensorValue, 0, 255);
  analogWrite(ledPin, sensorValue); // Atenua el brillo
del LED usando el valor de calibración:
}

void calibrate()
{
   digitalWrite(indicatorLedPin, HIGH); // prende el LED para
indicar que la calibración esta sucediendo: 
sensorValue = analogRead(sensorPin);   // lectura del sensor:
   if (sensorValue > sensorMax) // almacena el máximo
valor del sensor
{
    sensorMax = sensorValue;
 }
  if (sensorValue < sensorMin)   // almacena el mínimo valor
del sensor
{
    sensorMin = sensorValue;
 }
}
Sentencia for loop

A menudo se desea iterar sobre una serie de pines y hacer algo para cada
uno. Por ejemplo, este ejemplo hace parpadear 5 LEDs conectados al
Arduino utilizando la sentencia: for () loop para modificar la salida desde el
pin 2 al pin 6. Los LED se enciende y se apaga, en secuencia, utilizando
tanto las funciones de delay() y digitalWrite().
 
/*
  Bucle de iteración
  Muestra el uso de: for() loop.
  Prende multiples LEDs en secuencia de una direccion a otra y viceversa

 El siguiente código  utiliza un for () loop para asignar los pines 2-6 como
salidsa, las cuales iran conectadas a los 5 LEDs utilizados. Una vez que se
encendió
el ultimo LED, este se apaga y se prende el LED anterior esto continua de
forma
continua hasta llegar primer LED, donde se inicia el ciclo
 */

int tiempo = 100; // define el tiempo entre el cambio de nivel de voltaje

(ms)

void setup()
{
  for (int pin = 2; pin <= 6; pin++)    // usa la sentencia loop para declarar
los pines como pines de salida
 {
     pinMode(pin, OUTPUT);      
 }
}

void loop()
{  for (int pin = 2; pin <= 6; pin++)   // bucle
 {
       digitalWrite(pin, HIGH);  // prende el LED:
    delay(tiempo);                  
       digitalWrite(pin, LOW);    // apaga el LED:
 }

  for (int pin = 6;  pin >= 2; pin--)   // bucle

  {    digitalWrite(pin, HIGH);     // prende LED

    delay(tiempo);
       digitalWrite(pin, LOW); // apaga el LED
 }
}
Sentencia if

La sentencia if() es la sentencia más básica de entre todas las sentencias

en la estructura de control. Esta permite que pase algo o no, dependiendo
si la condición dada es verdadera o falsa.

if (condición) Realiza una accion si la condicion es verdadera

 
Existe una variación, llamada if-else:
if (condición) 
Realiza una accion si la condicion es verdadera
else
Realiza una accion si la condicion es falsa
 
También existe la sentencía else-if, donde se puede verificar una segunda
condicióń.
if (condición)
Realiza una accion si la condicion es verdadera
else if (otra condición) 
Realiza una accion si la primera condicion es falsa

Vamos a usar lasentencia if todo el tiempo. En el ejemplo se enciende un

LED en el pin 13 (el LED incorporado en muchas tarjetas Arduinos) si el
valor leído en una entrada analógica* pasa por encima de un determinado
umbral.
 
/*
  Condicional- sentencia if
  Este ejemplo demuestra el uso de la sentencia if().
  Se lee el valor del potenciómetro(una entrada analógica) y prende el LED
  solo si el valor sobrepasa el nivel de umbral.
 */

const int analogPin = A0;    // pin al cual se conectará el potenciómetro

const int ledPin = 9;       // pin al cual se conectará el LED
const int threshold = 400;   // un valor de umbral

void setup() {
  // inicializa el pin del LED como pin de salida
  pinMode(ledPin, OUTPUT);
  // inicialización de la comunicación serial
  Serial.begin(9600);
}
void loop() {
  // lectura del valor del potenciómetro
  int analogValue = analogRead(analogPin);

  // si el valor analógico es suficientemente alto se prende el LED:

  if (analogValue > threshold) {
    digitalWrite(ledPin, HIGH);
  }
  else {
    digitalWrite(ledPin,LOW);
  }

  // imprime el valor analógico

  Serial.println(analogValue);
  delay(1);        // retraso entre lecturas para estabilizar
}
Movimiento de Luces con control de Velocidad

Ejerecicip para aprender a mover la luz entre varios leds al estilo del
auto fantástico. La velocidad la podemos controlar con el
potenciómetro. Si giramos el potenciómetro en sentido horario la
velocidad de esplazamiento aumentará y si lo giramos en sentido
antihorario disminuirá.Para lograrlo utilizamos la estructura switch -
case que circula por los diferentes estados en que cada led está
encendido. Luego hacemos una pausa por un tiempo que depende de
la lectura del potenciómetro. En éste caso estamos usando la fórmula
tiempo=(valorPot/2)+25 con la que obtenemos un rango de tiempo
entre medio segundo y 25 milisengundos de espera antes de pasar al
siguiente estado.
 

/*
  Movimiento de Luces con Control de Velocidad
 
  Con este programa la luz se va moviendo por los leds al estilo del
auto
  fantastico. La velocidad del movimiento la podemos controlar
girando el
  potenciometro.
 */

// Le damos nombre a los pines del arduino para poder entender

mejor
// su funcion en el programa:
int led1 = 3;
int led2 = 5;
int led3 = 6;
int led4 = 9;
int led5 = 10;
int pinPot = A0; // pin donde leemos el valor del potenciometro

// Variables
int valorPot = 0; // aca almacenamos el valor del potenciometro
int tiempo = 0;
int estado = 1;

void setup() {                
  // inicializamos los pines de los leds como salidas
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
  pinMode(led5, OUTPUT);
  // asignamos los valores iniciales a los leds (apagados)
  digitalWrite(led1, LOW);
  digitalWrite(led2, LOW);
  digitalWrite(led3, LOW);
  digitalWrite(led4, LOW);
  digitalWrite(led5, LOW);
}

void loop() {
  // Leemos el valor del potenciometro y lo alamacenamos
  valorPot = analogRead(pinPot); // va de 0 a 1023
  // Calculamos el tiempo en milisegundos en base al valor del
  // potenciometro de modo que el tiempo entre estados sea como
  // maximo alrededor de medio segundo y como minimo 25
milisegundos.
  tiempo = ( valorPot / 2 ) + 25;
  // Evaluamos el estado en el que nos encontramos (que led debe
estar
  // encendido)
  switch(estado) {
    case 1:
      digitalWrite(led4, LOW);
      digitalWrite(led5, HIGH);
      break;
    case 2:
      digitalWrite(led4, HIGH);
      digitalWrite(led5, LOW);
      break;
    case 3:
      digitalWrite(led3, HIGH);
      digitalWrite(led4, LOW);
      break;
    case 4:
      digitalWrite(led2, HIGH);
      digitalWrite(led3, LOW);
      break;
    case 5:
      digitalWrite(led1, HIGH);
      digitalWrite(led2, LOW);
      break;
    case 6:
      digitalWrite(led1, LOW);
      digitalWrite(led2, HIGH);
      break;
    case 7:
      digitalWrite(led2, LOW);
      digitalWrite(led3, HIGH);
      break;
    case 8:
      digitalWrite(led3, LOW);
      digitalWrite(led4, HIGH);
      break;
  }
  // evaluamos si llegamos al estado final
  if ( estado == 8 ) {
    // pasamos al estado 1
    estado = 1;
  } else {
    // pasamos al siguiente estado
    estado = estado + 1;
  }
  // esperamos el tiempo que va a estar encendido un led
  delay(tiempo);
}
Mover Posición de LED Encendido con Potenciómetro

Con este tutorial podrás cambiar el led encendido al girar un

potenciometro que leemos por una entrada analógica.  Cuando el
potenciómetro esté completamente girado en sentido horario, el led1
(que está al extremo derecho) estará encendido. Cuando el
potenciómetro esté completamente girado en sentido antihorario, el
led5 (que está al extremo izquierdo) estatá encendido. Del mismo
modo en las posiciones intermedias del potenciómetro los leds
intermedios se encenderán según corresponda.
El rango de lectura de la entrada analógica es de 0 a 1023 por los
que dividimos ese rango en cinco rangos que concidan con los leds
según su posición. Entonces tendremos los siguientes rangos:
Valor Valor
LED
Inicial Final
0 205 led1
206 409 led2
410 614 led3
615 818 led4
819 1023 led5
En el programa utilizaremos una estructura if - else para encender el
led correspondiente en donde iremos comparando en base al valor
final para diferenciar los rangos. cada valor final define el rango
inmediato superior. La comparación se iniciará a partir del valor final
del led4 y bajará hasta el del led1.
 

 
/*
  Cambiar Posicion de Led Encendido con Potenciometro
 
  Con este programa podras cambiar el led encendido segun el valor
del
  potenciometro que leemos por una entrada analogica. El rango de
lectura
  es de 0 a 1023 por los que dividimos ese rango en cinco rangos que
concidan
  con los leds segun su posicion.
 */

// Le damos nombre a los pines del arduino para poder entender

mejor
// su funcion en el programa:
int led1 = 3;
int led2 = 5;
int led3 = 6;
int led4 = 9;
int led5 = 10;
int pinPot = A0; // pin donde leemos el valor del potenciometro

// Variables
int valorPot = 0; // aca almacenamos el valor del potenciometro

void setup() {                
  // inicializamos los pines de los leds como salidas
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
  pinMode(led5, OUTPUT);
}

void loop() {
  // Leemos el valor del potenciometro y lo alamacenamos para
comparar
  // el valor mas adelante
  valorPot = analogRead(pinPot);
  // comparamos con los valores de los rangos para cada led.
  if( valorPot > 818 ){ // rango led5 : 819 - 1023
    digitalWrite(led1, LOW);
    digitalWrite(led2, LOW);
    digitalWrite(led3, LOW);
    digitalWrite(led4, LOW);
    digitalWrite(led5, HIGH);
  } else if( valorPot > 614 ){ // rango led4 : 615 - 818
    digitalWrite(led1, LOW);
    digitalWrite(led2, LOW);
    digitalWrite(led3, LOW);
    digitalWrite(led4, HIGH);
    digitalWrite(led5, LOW);
  } else if( valorPot > 409 ){ // rango led3 : 410 - 614
    digitalWrite(led1, LOW);
    digitalWrite(led2, LOW);
    digitalWrite(led3, HIGH);
    digitalWrite(led4, LOW);
    digitalWrite(led5, LOW);
  } else if( valorPot > 205 ){ // rango led2 : 206 - 409
    digitalWrite(led1, LOW);
    digitalWrite(led2, HIGH);
    digitalWrite(led3, LOW);
    digitalWrite(led4, LOW);
    digitalWrite(led5, LOW);
  } else { // rango led1 : 0 - 205
    digitalWrite(led1, HIGH);
    digitalWrite(led2, LOW);
    digitalWrite(led3, LOW);
    digitalWrite(led4, LOW);
    digitalWrite(led5, LOW);
 }
 
}
SENSOR LDR

Programa para utilizar un sensor LDR para encender y apagar un LED.

Uniremos el LED al pin 9 que tiene salida PWM y el sensor LDR al pin 0
analógico. Esto se hace así porque los valores que nos va a dar el sensor
LDR variarán de 0 (0V) a 1024 (5V) y por el pin 9 con salida PWM
podemos manejar, como se verá en el programa, a través de la función
analogWrite(), dichos valores.

int pinLED  = 9; 

int pinLDR  = 0, valorLDR = 0;
 
void setup()
{
 pinMode (pinLED, OUTPUT);                // defino el pin del LED como salida.
 
pinMode (pinLDR, INPUT);                 // defino el pin del sensor LDR
como entrada
}
 
void loop ()
 valorLDR = analogRead(pinLDR);                // leo el valor que tiene el pin
del sensor LDR en este instante y lo
// guardo en la variable 'valorLDR'.
 analogWrite (pinLED, valorLDR);                // 'escribo' en el pin del LED el
valor de 'valorLDR'.
  // Si 'pinLED' fuese un pin digital el
programa no funcionaría correctamente
 }
Circuito Antirebote
Con este circuito conseguiremos eliminar el efecto rebote en nuestras
entradas arduino, se utilizan los tiempos de carga de un condensador
para compensar los rebotes de un pulsador. 

En el estado lógico de reposo de nuestra entrada tendrá un nivel alto, dado

que el condensador se cargara a la tensión de alimentación 5v, en el
momento de activar el pulsador el condensador se descargara a través de
R2, llevando la tensión de la entrada a 0v, esta descarga sera lenta con lo
que desaparecerán los diferentes pulsos en nuestra entrada de arduino,
una vez el pulsador se libere el condensador comenzara a cargarse
lentamente a través de R1 Y R2, esta carga sera lenta llevando la entrada
digital a un nivel logico alto. Otra ventaja de este circuito es que elimina
el problema de inducciones en nuestra entrada digital de arduino,
un problema debido a la poca corriente necesaria para activar la entrada
de nuestra placa. Para comprobar el funcionamiento puedes utilizar el
siguiente código,  el cual es un contador de pulsos,  el cual envía el
resultado del contador por el puerto serie para monitorizar el resultado.
 
const int buttonPin = 2; //Pin donde se conecta el pulsador, adaptar
a tu circuito
int buttonState = 0; //Variable que contiene el valor del
pulsador
int EstadoAnteriorPulsador=0; //Estado del pulsador en el ultimo ciclo
int ContPulso=0; //Variable para conteo de numero de pulsos
void setup()
{
Serial.begin(9600);
pinMode(buttonPin, INPUT);
}

void loop()
{
buttonState = digitalRead(buttonPin); // cargamos estado de
entrada
// comprobamos si esta presionado el
pulsador
if (buttonState == LOW ) // y si esta pulsado
incrementamos variable conteo de pulsos
{ //y enviamos el valor por puerto serie
if(EstadoAnteriorPulsador!=buttonState)
{
EstadoAnteriorPulsador=buttonState;
ContPulso++;
Serial.println(ContPulso);
}
}
else
{
EstadoAnteriorPulsador = HIGH;
}
}
// Código para evitar el indeseado efecto rebote. La lectura de la pulsación
de un botón no se procesa hasta que está pulsación este estable durante
al menos 200 ms. Controla el encendido y apagado de led.
 
const int  buttonPin = 11;    // pin del pulsador
const int ledPin = 13;       // pin del led
.int ledStatus = false;   // almacena el estado del led. Por defecto
está apagado
int buttonState = 0;     // estado actual del botón
int lastButtonState = 0; // estado del botón tras el filtrado del
debounce
int lastButtonState2 = LOW;  // estado anterior para el filtrado del
debounce
int reading;  // para la lectura del pin del pulsador
long lastDebounceTime = 0; // contador para el debounce
long debounceDelay = 200;   // tiempo que tiene que mantenerse
estable la señal de la pulsación
 void setup()
{
 pinMode(buttonPin, INPUT);
 pinMode(ledPin, OUTPUT);
}
void loop()
{
 reading = digitalRead(buttonPin); // lectura del pin
 if (reading != lastButtonState2) // si ha cambiado con respecto al
estado anterior
{
lastDebounceTime = millis(); // resetear el contador para el
debounce
}
if ((millis() - lastDebounceTime) > debounceDelay)
{ //si la señal se ha mantenido estable más del tiempo establecido
por lo tando se puede cambiar el valor
buttonState = reading;
 }
 lastButtonState2 = reading; // almacenar la lectura para la
siguiente comprobación
 if (buttonState != lastButtonState)  // comparar el estado del pulsador
con el estado anterior
{
 if (buttonState == LOW)   // si el estado ha cambiado
comprobar si ha sido porque ha sido pulsado
{  // y no porque ha sido soltado
 ledStatus = !ledStatus; // el botón ha sido presionado,
cambiamos el valor del led
 }
lastButtonState = buttonState; // almacenar el nuevo valor del botón
}
if (ledStatus)  // actualizar el estado del led de acuerdo a
la variable
{
digitalWrite(ledPin, HIGH);
}
else
{
 digitalWrite(ledPin, LOW);
 }}
int led = 22; //asociamos el numero de pin 22 a la
variable led
int pulsador = 24; // asociamos el numero de pin 24 al
pulsador
int estado = 0; //hacemos una variable para almacenar
el estado del led
 
void setup() //iniciamos el void setup , que se ejecuta
una vez al iniciarse la placa arduino
{
  pinMode(led,OUTPUT); //aqui configuramos el led como
salida digital
  pinMode(pulsador,INPUT); //Aqui configuramos el pulsador como
entrada digital
  digitalWrite(led,LOW); //iniciamos con el led apagado
}
 
 void loop() //ahora pasamos al loop, que se ejecuta
una y otra vez infinitamente
{
    if(digitalRead(pulsador)==1) //si se presiona el pulsador
{
     if(estado == 0) //si el estado es 0, es decir, el led esta
apagado
{
       digitalWrite(led,HIGH); //prendemos el led
       estado = 1; //y establecemos la variable estado a
1
 }
else //de lo contrario, significa que estado es igual a uno,
y el led esta encendido, por lo tanto
{
       digitalWrite(led,LOW); //lo apagamos
       estado = 0;  //y establecemos estado a 0
     }
     delay(500); //un retardo de 500 ms para evitar que se lea
varias veces el pulsador al mismo tiempo
  }
}

Adquisición de datos en la entrada analógica A0 para variar la frecuencia

de parpadeo de un diodo LED conectado a una salida digital cualquiera.

/*
  Funcionamiento de las entradas analógicas configurando  el pin
analógico A0 para tomar datos de una señal. Esta toma de datos
 es utilizada para variar la velocidad de parpadeo de un diodo LED
conectado a la salida digital 9.
 */
 
int pinSensor = A0;     // Entrada para el
potenciómetro.
int pinLed = 9;         // Seleccionamos pin para el Led.
int valorSensor = 0;   // variable para el valor del
sensor.
 
void setup()
{
  pinMode(pinLed, OUTPUT);    // Declaramos el pin del
Led como salida:
}
 
void loop()
{
   valorSensor = analogRead(pinSensor); // Leemos el
valor del sensor y lo almacenamos:
    digitalWrite(pinLed, HIGH); // encendemo el
diodo LED:
  delay(valorSensor);   // Detenemos el programa
durante <valorSensor> milisegundos:
  digitalWrite(pinLed, LOW); // Apagamos el diodo Led:
  delay(valorSensor); // Detenemos el programa
durante <valorSensor> milisegundos:
}

analogRead(pinSensor).- Esta instrucción nos permite leer cualquier sensor

que conectemos al pin analógico establecido en “pinSensor”, por defecto,
nuestra placa Arduino nos realizará una conversión analógico-digital para
toda señal (40mA máximo) de 0v a 5v con una resolución de 10 bit, lo que
nos da 210 (1024) valores de referencia para nuestro programa, siendo 0
en 0v y 1023 en +5v, en posteriores ejemplos veremos como ese rango de
tensión en el que se realizan las mediciones se puede variar para que, por
ejemplo, empiece a lanzarnos valores a partir de 2,2v. Con esto, y
observando un poco el programa, podemor ver que el intervalo entre
encendido y apagado de nuestro diodo LED podrá variar entre 0 y 1023
milisegundos, si quisiéramos aumentar más el tiempo de los intervalos
podríamos aplicar alguna operación matemática al valor de nuestro
sensor, por ejemplo, si añadiéramos la línea de código que se puede
observar debajo de la toma de datos del sensor obtendríamos un
incremento del tiempo cuatro veces mayor:
// Leemos el valor del sensor y lo almacenamos:
valorSensor = analogRead(pinSensor);
valorSensor = valorSensor*4;
Sin variar el circuito, vamos a introducir un nuevo código para realizar un
ejemplo diferente, en este proyecto, nuestro diodo LED variará su
intensidad lumínica en función del valor que esté aportando el
potenciómetro a nuestra entrada analógica, esto es el llamado efecto
fading (desvanecimiento), puede observarse que se ha elegido la salida
número 9, ya que esta sí que es compatible con la opción PWM como se
explica algo más arriba.
/*
  En este tutorial, mostramos como se desvanece un LED
 en función del valor recogido en un entrada analógica.
 */
 int pinSensor = A0;    // Entrada para el potenciómetro.
int pinLed = 9;        // Seleccionamos pin para el Led.
int valorSensor = 0;   // variable para el valor del sensor.
 
void setup()
{
  pinMode(pinLed, OUTPUT); // Establecemos el pin como
salida.
}
 
void loop()
{
  valorSensor = analogRead(pinSensor); // Leemos el
valor del sensor y lo almacenamos:
  analogWrite(pinLed, valorSensor / 4); // Establecemos el
valor analógico para la salida PWM
  delay(30); // Detenemos el
programa durante 30 milisegundos:
}

Podemos observar una nueva instrucción: analogWrite(pinLed, valorSensor

/ 4);
Esta será la instrucción que nos permitirá emular una señal analógica a
partir de una digital en nuestros circuitos, como explicaba algo más arriba.
El rango de salida de esta instrucción varia de 0 a 255, siendo 0 = 0v y
255 = 5v, por lo que es tan sencillo como introducir un valor determinado
para la tensión de salida que nosotros queramos conseguir, si quisiéramos
conseguir 2,5v el valor a asignar sería 127. Así que lo único que debemos
hacer es transformar mediante una simple operación matemática la señal
tomada en nuestro potenciómetro para adaptarla a nuestra salida PWM.
Montaje y programa del pulsador con Arduino. El código que a
continuación se muestra es de un pulsador entre prender un led y apagar
el otro.

/*
Pulsador para 2 LED´s
*/

int ledPin = 13; // este es el PIN de salida del primer LED

int ledPin2 = 12; // este es el PIN de salida del segundo LED
int inputPin = 2; // este es el PIN de entrada para el boton
int val = 0; // esta variable se usa para leer el in de entrada
del pulsador

void setup()
{
pinMode(ledPin, OUTPUT); // Se inicializan los pines que son salida
pinMode(ledPin2,OUTPUT);
pinMode(inputPin, INPUT); // y se declara el Pin del pulsador como
entrada
Serial.begin(9600);
}

void loop()
{
val = digitalRead(inputPin); // lee el valor del pulsador
if (val == HIGH) // condicion de lectura del pulsador
{
digitalWrite(ledPin, LOW);
digitalWrite(ledPin2, HIGH);
Serial.println("EL led 2 encendido");
}
else
{
digitalWrite(ledPin, HIGH);
Serial.println("EL led 1 encendido");
digitalWrite(ledPin2, LOW);
}
}
Tengo el botón conectado en mi conector 12, es decir que voy a usar
digitalRead(12) para saber cuál es su valor, asignándolo a la variable
sensorValue. Después, le indico que el sensorValue lo muestre en la
ventana Serial monitor, que debo abrir usando el menú Tools. Una vez
compilado el código (botón “verify”, el primero) y subido a la placa (botón
“upload”. el que tiene una flecha hacia la derecha) , pulso el botón y veo en el
Serial monitor una secuencia de ceros, que cuando pulso el botón se
transforman en unos.

/*
Aqui usamos el boton para encender el LED.
*/
void setup()
{
Serial.begin(9600);
pinMode(12, OUTPUT);
}
void loop()
{
int sensorValue = digitalRead(A2);
Serial.println(sensorValue);
if (sensorValue == 1)
{
digitalWrite(12, HIGH); // si el valor del sensor es 1, enciende el
LED
delay(100);                      // espera un ratito
digitalWrite(12, LOW); // apaga el LED
}
}

Este código enciende el led de acuerdo al valor del potenciómetro:

/*
Aqui usamos el potenciometro para encender el LED.
*/

void setup()
{
Serial.begin(9600);
pinMode(A3, OUTPUT);
}
void loop()
{
int sensorValue = analogRead(A2);
analogWrite(A3, sensorValue/4);    // escribimos en el conector A3 el
valor del sensor (del potenciómetro)
// dividido cuatro.
Serial.println(sensorValue);
}
Control de intensidad de un LED", donde es usado una Mini fotocelda, el
cual es usado para detectar luz.

/*
  Control de intensidad de un LED
*/

void setup
{
  Serial.begin(9600);  //Inicia comunicacion
  pinMode(9,OUTPUT);   //Configurar el pin 9 como salida
}
 
void loop()
{      
  int foto = analogRead(A0); //Variable del valor de la lectura
analoga de la mini fotocelda
   int conversion = 780 - foto; // Verifica el valor máximo y se realiza
una conversion
   if ( conversion < 0)   //Condicion para establecer un valor
absoluto
  conversion = conversion * -1; //Multiplicar por -1
  Serial.print("Foto : ");    //Se Imprimen los datos de la mini
fotocelda
  Serial.print(foto);
  Serial.println("");
   Serial.print("Conv : "); //Se Imprimen los datos del valor de la
conversion
  Serial.print(conversion);
  Serial.println("");
   analogWrite(9, conversion);   //Escritura análoga de PWM en el LED de
acuerdo a la conversion
  delay(100);
 }
Interruptor crepuscular

Un interruptor crepuscular es un circuito que cambia su comportamiento

cuando se alcanza una cierta intensidad de luz. Por ejemplo cuando
anochece o por la razón que sea hay poca luz, el alumbrado público se se
enciende, cuando el sol vuelve a brillar, se apaga.

El circuito propuesto esta compuesto por una resistencia LDR y un led. Una
resistencia LDR es un componente cuya resistencia al paso de la corriente
eléctrica varia en función de la luz que recibe.
La resistencia se conecta de tal modo que sea proporcional a la cantidad
de luz que recibe, es decir, cuanta más luz, mayor será la resistencia que
oponga al paso de la corriente eléctrica, para ello colocaremos una
resistencia de 1KOhm para estabilizar su salida. Cuando haya poca luz se
encendera un led y se apagará cuando se supere cierto umbral.

int ldr = A0;
//La resistencia LDR estará en la entrada 0 de analogico  
int led = 1; //El led estará conectado a la salida digital 1  
int luz = 0;  // Variable para el valor de la intensidad de la luz  
int umbral = 10; 
//umbral en el que encenderemos/apagaremos el led  
int t = 5000;  

void setup() 
{  
    pinMode(ldr,INPUT) ;
//configuramos el pin de la resistencia como entrada  
    pinMode(led,OUTPUT); //configuramos el pin del led cómo salida  
}  
   
void loop()
{  
    luz = analogRead(ldr);       //leemos el valor de la resitencia LDR    
    if (luz >= umbral)
{  
        digitalWrite(led,HIGH);             //si no supera el umbral, encendemos e
l led  
}
else
{  
      digitalWrite(led,LOW);   //si lo supera, lo apagamos.  
 }  
   delay(t);      //esperamos antes de volver a leer y comprobar  
}  

Cada 5 segundos leemos la intensidad de luz, si supera el umbral, el led

estará apagado, en caso contrario lo encenderemos. El umbral se puede
ajustar cambiando el valor de la variable umbral, y el tiempo de espera
con la variable t (en milisegundos.)
Control Serial

/*Declaramos una variables de tipo caracter en la que se almacenará  lo q
ue nos llegue por consola*/  
char orden;   //Definimos el led estará en la patilla 9;  
int led = 9;  
void setup() 
{  
    pinMode(led,OUTPUT);   //definimos la patilla del led cómo salida  
    Serial.begin(9600);   // Abrimos la conexión serial a 9600 baudios  
}  
  
void loop() 

{    /*leemos las ordenes que nos llegan por consola y  la almacenamos en 
la variable orden*/  
  orden = Serial.read();        
  switch (orden)
{  
   case 'e': digitalWrite(led,HIGH);  
             break;  
   case 'E': digitalWrite(led,HIGH);  
             break;  
   case 'o': digitalWrite(led,LOW);  
             break;  
   case 'O': digitalWrite(led,LOW);  
             break;  
   default:  digitalWrite(led,HIGH);  
             delay(300);  
             digitalWrite(led,LOW);  
             delay(300);  
             digitalWrite(led,HIGH);  
             delay(300);  
             digitalWrite(led,LOW);  
             break;  
}  
}