Calibració del sensor de llum

La resposta del sensor de llum depén dels valors ambientals, que en cada lloc i en cada moment poden ser diferents.
Si volem que no sigui així, cal calibrar-lo, és a dir, donar-li uns valors màxim i mínim de referència.
Evidentment, cal calibrar el sensor abans d'executar qualsevol altra cosa en el programa.
Referència: web Arduino

Per a la nostra calibració utilitzarem un Led com indicador: s'encendrà en començar la calibració, i quan s'apagui indicarà que la calibració s'ha realitzat.

Programa de calibració
Es tracta que durant els primers 5 segons de l'execució del programa es llegirà el valor mínim i el valor màxim rebuts del sensor de llum i es desarà cada un en una variable.
Un LED actuarà com indicador de la calibració.


Les variables:

const int sensorPin = A0;    // pin de connexió del sensor
const int ledPin = 13;       // pin de connexió del Led

int sensorValor = 0;         // per desar el valor del sensor
int sensorMin = 1023;        // mínim valor llegit pel sensor
int sensorMax = 0;           // màxim valor llegit pel sensor


En aquest cas no podem utilitzar la instrucció delay, perquè aquesta atura l'execució.
Per establir que l'execució de la calibració s'ha de realitzar durant els primers 5 segons de l'execució, utilitzarem la instrucció millis(); que retorna el temps des del darrer reset de la placa.

El bucle l'establim amb while (mentre) el temps d'execució (millis) sigui menor que 5 segons.
Així doncs, el void setup quedarà:

void setup() 
{
  pinMode(ledPin, OUTPUT);  // configuració del pin digital de connexió del LED
  digitalWrite(ledPin, HIGH);   // encén el LED indicador de calibració

  while (millis() < 5000) // calibra durant els primers 5 segons  
  {
    sensorValor = analogRead(sensorPin);  

    if (sensorValor > sensorMax) 
    { sensorMax = sensorValor; } // registra el valor màxim del sensor
    if (sensorValor < sensorMin) 
    { sensorMin = sensorValor; } // registra el valor mínim del sensor
  }

  digitalWrite(ledPin, LOW); // indica el final de la calibració
}

Ara, ja podem definir al void loop les instruccions que ens interessin.

Sensor de temperatura LM35

---

Aquest sensor de temperatura és un circuit integrat que retorna un valor de tensió directament proporcional a la temperatura a la que està sotmés.

El nostre és un LM35DZ. Segons el seu data sheet:
* Mesura la temperatura en graus centigraus.
* Funciona entre 0ºC i 100ºC
* Té un marge d'error de ± 1ºC (suficient precisió per als nostres projectes)

El pin central és el de senyal, es connecta a un pin analògic d'entrada.
Posant la cara plana mirant cap a nosaltres, el pin de l'esquerra és el d'alimentació (5V), i el de la dreta, GND.

Càlcul de la temperatura

El primer que cal és passar el valor llegit pel pin analògic (entre 0 per a 0V i 1023 per a 5V) al seu valor de tensió.
Com que els possibles valors llegits per un pin analògic són 1024, el valor en volts de la mesura serà: (5 / 1024) · lectura

I com que, segons el data sheet, la sortida de tensió és de 10 mV per a cada ºC (1V equival a 100ºC), la temperatura serà el valor en volts de la mesura · 100

Monitoritzem la temperatura

int sensor = A0 ;

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  int lectura = analogRead(sensor);
  float tensio = 5.0 / 1024 * lectura; // float: variable de valor un nombre decimal
  float temp = tensio * 100;
  Serial.print ("temperatura = ");
  Serial.print (temp);
  Serial.println (" ºC");
  delay (100);
}

Què podem fer amb un sensor de temperatura?

* Encendre i apagar un LED en funció d'un valor llindar de temperatura.
* Alarma d'incendi: encendre LED si la temperatura està per sobre d'un llindar.
* Activar un o altre color d'un LED RGB si la temperatura està per sobre o per sota d'un llindar >>
* Encendre més o menys segments d'una barra de LEDs en funció de la temperatura.
* Posar en marxa un ventilador quan la temperatura pugi per sobre d'un llindar >>
* Mostrar els valors de la temperatura en una pantalla LCD >>
* Mostrar els valors de temperatura amb displays de 7 segments >>
* ...

Sensors capacitius

---

Els sensors capacitius són sensors de proximitat, estan formats per una superfície conductora. En apropar-se una altra superfície conductora (p. e. el cos humà) totes dues superfícies actuen com armadures d'un condensador.

Sensor de presència. PIR

PIR = Passive InfraRed sensor 
Aquests sensors detecten canvis de temperatura dins la zona que monitoritzen, provocats per la presència de persones o d'objectes en moviment. Són molt utilitzats en sistemes d'alarma o control d'accessos.
El seu angle de visió és de 90º, i el seu abast entre 6 i 9 m. La seva sensibilitat es pot regular amb els potenciòmetres que porta incorporats.

Connexió a Arduino
Es connecta a un pin digital (que s'ha de declarar com a entrada al programa). També es pot connectar a un pin d'entrada analògic.
Es connecta directament, sense resistències.

Quan s'activa envia un senyal durant un temps, que es pot regular amb un dels potenciòmetres que te al darrera, l'altre permet regular la distància de detecció.

Aquesta va ser la meva primera proba: encesa d'un LED durant el temps que dura aquest senyal


Altra aplicació: Llum d’encesa automàtica
En apropar-se algú a la porta del bany, és detectat pel sensor i el llum s’encén. Quan el sensor torna a detectar moviment és que l’usuari surt del bany, i el llum s’apaga.
La pausa de 3 segons es per deixar temps a que el sensor deixi d'enviar senyal 1.

int llum_bany = 5; 
int sensor_pir = 4;

void setup()
{
  pinMode(llum_bany,OUTPUT);
  pinMode(sensor_pir,INPUT);
}

void loop()
{
  int presencia = digitalRead(sensor_pir);
  if (presencia == 1)
  {
    digitalWrite(llum_bany,HIGH);
    delay(3000);
    while(presencia == 0)
    {
      if (presencia == 1)
      {
        digitalWrite(llum_bany,LOW);
        delay(3000);
      }
    }
  }
}

Per assegurar que quan algú surt del bany no queda ningú a dins i es pot tancar el llum, J Santiago en el seu TR va afegir una variable al programa que suma 1 cada cop que algú entra i resta 1 cada cop que algú surt. La llum només s'apaga quan aquesta variable = 0.

Sensor d'ultrasons

---

El sensor d'ultrasons (HC-SR04) mesura distàncies entre 3 cm i 3 m, amb una precisió de ± 3 mm.
L'emissor (Trig) emet un pols d'ultrasó que rebota en els obstacles i torna al receptor del sensor (Echo), el qual emet un senyal d'entrada proporcional al temps que ha trigat en rebre el pols.

Càlcul de la distància
Segons el temps que triga el pols des que s'emet fins que retorna al sensor:
velocitat del so = 343 m/s = 34.300 cm/s. Per tant, en recòrrer 1 cm triga 29,4 µs
distància total (cm) recorreguda pel pols (anada i tornada) = temps (µs) / 29,4
distància a l'obstacle (cm) = distància total / 2 = temps / (29,4/2) = temps / 58,2

Connexió a Arduino
Per muntar-lo en robots val la pena utilitzar aquest suport i cables agrupats

Monitorització de les distàncies mesurades pel sensor

Valors amb que treballem:

int EchoPin = 2;  // pin de connexió receptor del sensor
int TrigPin = 3;  // pin de connexió emissor del sensor
int temps, distancia;  // variables per al càlcul de la distància

Configuració:

void setup()
{
  Serial.begin (9600);  // iniciem la comunicació Serial per visualitzar les dades
  pinMode (TrigPin,OUTPUT);  // el pin Trig és una sortida digital
  pinMode (EchoPin,INPUT);   // el pin Echo és una entrada digital
}

Definició de les accions:

void loop()
{
  // cal començar generant un pols pel pin Trig d'una amplada de 10 µs:
  digitalWrite (TrigPin,LOW);
  delayMicroseconds (2);
  digitalWrite (TrigPin,HIGH);
  delayMicroseconds (10);
  digitalWrite (TrigPin,LOW);

  // mesura del temps en µs des que s'executa la instrucció
  // fins que es rep un pols pel pin especificat:
  temps = pulseIn (EchoPin,HIGH);   
 
  // conversió del temps mesurat en distància (cm):
  distancia = temps / 58.2; 

  // visualització de la distància calculada (en cm) pel monitor Serial:
  Serial.println (distancia); 
  delay(50);  // petita pausa abans de tornar a començar el bucle
}

Exemple 2. Encesa d'un LED en funció de la distància

int echoPin = 2;  // pin connexió emissor del sensor
int trigPin = 3;  // pin connexió receptor del sensor
int ledpin = 13;  // pin connexió LED
int consigna = 20;  // distància a partir de la que s'ha d'encendre el LED
long temps, distancia;  // variables per al càlcul de la distància

void setup() 
{
 Serial.begin (9600);  
 pinMode(trigPin, OUTPUT);
 pinMode(echoPin, INPUT);
 pinMode(ledpin, OUTPUT);
}

void loop() 
{
 digitalWrite(trigPin, LOW); // emissió i recepció d'ultrasons
 delayMicroseconds(2); 
 digitalWrite(trigPin, HIGH);
 delayMicroseconds(10); 
 digitalWrite(trigPin, LOW);

 temps = pulseIn(echoPin, HIGH);  // càlcul de la distància
 distancia = temps/58.2; 
 
 if (distancia < consigna)  // condició d'encesa del LED
 { digitalWrite(ledpin,HIGH); }
 else 
 { digitalWrite(ledpin,LOW); }
 
 delay(50);  // petita pausa abans de tornar a començar el bucle
}

Hem utilitzat el sensor d'ultrasons:

Sensor d'infrarojos

---

Sensor òptic reflexiu TCRT5000 

Consta d'un LED emissor d'IR (de color blau) i un fototransistor (de color negre) separats per una paret.
Quan un objecte s'apropa al sensor, la llum infraroja emesa pel LED es reflexa i activa el transistor.
El seu abast és molt petit (de l'ordre de mm), la detecció d'objectes depén de la distància al sensor i de la capacitat de reflexió del material.

Com es connecta a Arduino 

Com a sensor digital el seu funcionament és com el d'un polsador. Però l'abast és molt petit. 

Connexió a un pin d'entrada digital 

(amb S4A només podem utilitzar els pins 2, 3).

Resistències a utilitzar: 220 Ω per al LED i 10 kΩ per al transistor.

Com a sensor analògic podem definir un llindar de distància a partir del qual es realitzi l'acció associada.

Infrarrojos com a sensor digital
Exemple: encesa d'un LED en funció de l'estat del sensor (0-1):

const int PinLed = 13;
const int PinSensor = 2; // pin de connexió digital
int lectura;

void setup() 
{
  pinMode (PinLed,OUTPUT);
  pinMode (PinSensor,INPUT);
  Serial.begin(9600);
}

void loop() 
{
  lectura = digitalRead (PinSensor);
  if (lectura==1) digitalWrite (PinLed,HIGH);
  else digitalWrite (PinLed,LOW);

  Serial.println (lectura);
  delay (100);
}

Infrarrojos com a sensor analògic
Exemple: encesa d'un LED quan la lectura del sensor sigui menor que la consgina establerta:

const int PinLed = 13;
const int PinSensor = A0; // pin de connexió analògic
int lectura;
int consigna = 500;

void setup() 
{
  pinMode (PinLed,OUTPUT); 
  pinMode (PinSensor,INPUT); // els pins analògics no s'han de configurar
}

void loop() 
{
  lectura = digitalRead (PinSensor);
  if (lectura < consigna) digitalWrite (PinLed,HIGH);
  else digitalWrite (PinLed,LOW);
}

Hem utilitzat el sensor d'infrarojos:

porta automàtica d'habitatge domòtic

vàter intel·ligent