Enciende un led parpadeante

int ledPin = 13; // LED en el pin digital 13

void setup() // configura el pin de salida
{
pinMode(ledPin, OUTPUT); // configura el pin 13 como
salida
}
void loop() // inicia el bucle del programa
{
digitalWrite(ledPin, HIGH); // activa el LED
delay(1000); // espera 1 segundo
digitalWrite(ledPin, LOW); // desactiva el LED
delay(1000); // espera 1 segundo

Usamos pulsador

int ledPin = 13; // pin 13 asignado para el LED de

// salida
int inPin = 2; // pin 2 asignado para el pulsador
void setup() // Configura entradas y salidas
{
pinMode(ledPin, OUTPUT); // declara LED como salida
pinMode(inPin, INPUT); // declara pulsador como
} // entrada
void loop()
{
if (digitalRead(inPin) == HIGH) // testea si la entrada
{ // esta activa HIGH
digitalWrite(ledPin, HIGH); // enciende el LED
delay(1000); // espera 1 segundo
digitalWrite(ledPin, LOW); // apaga el LED
}
}
Sensor infrarrojo del mouse

#define LEDCerca 9 // led que brillará más cuanto más cerca

estemos del receptor IR
#define IRRe A0 // receptor IR conectado en la entrada A0
#define IREm 2 // emisor IR conectado en la entrada 2
/* descomentar este trozo si usamos la primera parte del có
digo en el loop
int valorIRReAmbiente = 0; // guardo el valor ambiental obt
enido por IRRe
// cuanto más cerca,
mayor es el valor
*/
int valorIRReEmitido = 0; // guardo el valor obtenido por
IRRe con el emisor encendido
// cuanto más cerca, mayor es el
valor
int brillo = 0; // brillo que emitiré en la led

void setup()
{
// configuro entradas y salidas de los pines
pinMode(LEDCerca, OUTPUT);
pinMode(IRRe, INPUT);
pinMode(IREm, OUTPUT);

//inicializo el puerto serie

Serial.begin(9600);
}

void loop()
{
/*
 * Esta parte es para comprobar si hay infrarrojos en el
ambiente
*
digitalWrite(IREm, LOW); // apago el emisor
digitalWrite(LEDCerca, LOW); // apago LEDCerca
delay(1);

// Compruebo valor del receptor sin emitir nada y lo mues

tro.
// En mi caso 1024 indica que no hay señal.
// También muestro el dato por el puerto serie
valorIRReAmbiente = 1024 - analogRead(IRRe); // Leo el va
lor recogido por el receptor
Serial.print("IR Ambiente: ");
Serial.print(valorIRReAmbiente);
*
*
*/

// Compruebo valor del receptor emitiendo y lo muestro.

digitalWrite(IREm, HIGH); // Enciendo el emisor IR
delay(1);

valorIRReEmitido = 1024 - analogRead(IRRe); // Leo el

valor recogido por el receptor
// descomentar lo de la siguiente línea si usamos la 1ª
parte.
// el 100 es para quitar "ruido"
if(/*valorIRReAmbiente + */ 100 < valorIRReEmitido)
// el brillo de la LED varía de 0 a 255, el valor del
receptor va de 0 a 1023
// lo escalamos con map(valor, desde, hasta, desde,
hasta)
brillo = map(valorIRReEmitido, 0, 1024, 0, 255);
else
brillo = 0;
Serial.print("\tBrillo: ");
Serial.print(brillo);
analogWrite(LEDCerca, brillo);

Serial.print("\tIR Emision: ");

Serial.println(valorIRReEmitido);
}
Diagrama para utilizar Arduino con Fotoresistencia LDR

// Pin donde se conectan los leds

int pinLed1 = 2;
int pinLed2 = 3;
int pinLed3 = 4;
// Pin analogico 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 leido del ADC en una variable

// El valor leido por el ADC (voltaje) aumenta de manera directamente proporcional
// con respecto a la luz percibida por el LDR
valorLDR= analogRead(pinLDR);

// Devolver el valor leido a nuestro monitor serial en el IDE de Arduino

Serial.println(valorLDR);

// Encender los leds apropiados de acuerdo al valor de ADC

if(valorLDR > 256)
{
 digitalWrite(pinLed1, HIGH);
}
if(valorLDR > 512)
{
digitalWrite(pinLed2, HIGH);
}
if(valorLDR > 768)
{
digitalWrite(pinLed3, HIGH);
}
// Esperar unos milisegundos antes de actualizar
delay(200);
}

Sensor ultrasonidos HC-SR04

long distancia;
long tiempo;
void setup(){
Serial.begin(9600);
pinMode(9, OUTPUT); /*activación del pin 9 como salida: para
el pulso ultrasónico*/
pinMode(8, INPUT); /*activación del pin 8 como entrada: tiempo
del rebote del ultrasonido*/
}

void loop(){
 digitalWrite(9,LOW); /* Por cuestión de estabilización del
sensor*/
delayMicroseconds(5);
digitalWrite(9, HIGH); /* envío del pulso ultrasónico*/
delayMicroseconds(10);
tiempo=pulseIn(8, HIGH); /* Función para medir la longitud del
pulso entrante. Mide el tiempo que transcurrido entre el envío
del pulso ultrasónico y cuando el sensor recibe el rebote, es
decir: desde que el pin 12 empieza a recibir el rebote, HIGH, ha
sta que
deja de hacerlo, LOW, la longitud del pulso entrante*/
distancia= int(0.017*tiempo); /*fórmula para calcular la
distancia obteniendo un valor entero*/
/*Monitorización en centímetros por el monitor serial*/
Serial.println("Distancia ");
Serial.println(distancia);
Serial.println(" cm");
delay(1000);
}

/*Pines a utilizar por Arduino. Puedes modificarlos por los pines digitales que desees*/
4
5 int Trig=4;
6 int Echo=3;
7
8 //Variable en la que se va a almacenar el valor correspondiente a la distancia
9 int Dist;
10
11 void setup() {
12
13 pinMode (Trig, OUTPUT);
14 pinMode (Echo, INPUT);
15
16 }
17
18 //Este módulo calcula y devuelve la distancia en cm.
19 /*
20 Puedes poner el código del módulo directamente en el loop o utilizar el módulo
21 para reducir el número de líneas de código del loop o reutilizar el código
22 */
23 void ultrasonido (int &Distancia){
24
25 //Para estabilizar el valor del pin Trig se establece a LOW
26 digitalWrite (Trig, LOW);
27 delay(10);
28
29 //Se lanzan los 8 pulsos
30 digitalWrite (Trig, HIGH);
31 delay(10);
32 digitalWrite (Trig, LOW);
33
34 /*
35 Se mide el tiempo que tarda la señal en regresar y se calcula la distancia.
36
37 Observa que al realizar pulseIn el valor que se obtiene es tiempo, no distancia
38
39 Se está reutilizando la variable Distancia.
40 */
41
42 Distancia= pulseIn (Echo, HIGH);
43 Distancia=Distancia/58;
44
45 delay(100);
46
47 }
48
49 void loop() {
50
51 ultrasonido (Dist);
52
delay (250);
}

Con el sensor de ultrasonidos TS601P01

unsigned long pulso; // necesitamos una variable para medir el pulso
float distancia; // otra para calcular la distancia
int pin = 8; // y otra para el pin

void setup()
{
Serial.begin(9600); // inicializamos el puerto serie
}
void loop()
{
pinMode(pin, OUTPUT); // ponemos el pin como salida
digitalWrite(pin, HIGH); // lo activamos
delayMicroseconds(10); // esperamos 10 microsegundos
digitalWrite(pin, LOW); // lo desactivamos
pinMode(pin, INPUT); // cambiamos el pin como entrada
pulso = pulseIn(pin, HIGH); // medimos el pulso de salida del sensor
Serial.print("tiempo = "); // lo pasamos a milisegundos y lo sacamos
por
// el puerto serie
Serial.print(float(pulso/1000.0));
Serial.print("ms, distancia = "); // ahora calculamos la distancia en
cm
// y al puerto serie
distancia = ((float(pulso/1000.0))*34.32)/2;
Serial.print(distancia);
Serial.println("cm");
delay(1000); // esperamos un segundo antes de hacer una nueva medida
}
Sensor de infrarrojos CNY70 como entrada digital

This example code is in the public domain*/

int ledPin1 = 8; // pin de un LED

int ledPin2 = 9; // pin de otro LED
int infraPin = 4; // pin del infrarrojos utilizado como entrada
digital
int valorInfra = 0; // Valor inicial de la lectura digital del
infrarrojos.

void setup() {
pinMode(ledPin1, OUTPUT); // Inicializa el pin del LED1 como
salida digital
pinMode(ledPin2, OUTPUT); // Inicializa el pin del LED2 como
salida digital
pinMode(infraPin, INPUT); // Inicializa el pin 4 como entrada
digital
}

void loop() {
valorInfra = digitalRead(infraPin); // Lee el valor de la entrada
4, esto es, el valor que lee el infrarrojo
digitalWrite(ledPin1, valorInfra); /* Escribe en el pin 8 el
valor que lee la entrada 4, esto es, el mismo valor que lee el
infrarrojo
Si el infrarrojo lee 0,
entonces, el LED estará apagado
Si el infrarrojo lee 1,
entonces, el LED estará encendido */
valorInfra = !valorInfra; // Se asigna a valorInfra el
valorInfra negado. Si valorInfra es 1, el nuevo valorInfra será 0; y
viceversa
digitalWrite(ledPin2, valorInfra); /* Escribe en el pin 9 el
valor negado que lee la entrada 4, esto es, el negado del valor que
lee el infrarrojo
Si el infrarrojo lee 0,
entonces, el LED conectado al pin 9 estará encendido
Si el infrarrojo lee 1,
entonces, el LED conectado al pin 9 estará apagado */
}