Calibración Sensores Subsistema Plazas

 

  

A continuación, se expone el esquema de conexiones que se utilizará en cada plaza del garaje para detectar la presencia o no de un vehículo en la misma, además en el caso de que la plaza esté ocupada, el sistema debe devolver el tipo de vehículo que la ocupa (bicicleta, coche o camión), para ello utiliza el sensor LDR para medir la luminosidad colocado en el suelo  y el sensor HC-SR04 que mide la distancia colocado en el techo aproximadamente.

Calibración sensor LDR.

El objetivo es estudiar el comportamiento de la medida del sensor LDR con el fin de mejorar la toma de valores, realizando un calibrado y reducciendo el ruido.
Se dispone de un sensor de luz LDR para obtener la luminosidad. Como referencia se utiliza el sensor de luz presente en un Smartphone a través de la aplicación Lux Meter.

Para calcular el rango real de valores, la curva de transferencia y su linealidad hemos utilizado el siguiente código:

#define ldr A0
 

void setup() {
    pinMode(ldr,INPUT);
    Serial.begin(9600);

}
void loop() {
    int lx = analogRead(ldr);
    Serial.println(lx); 

   delay(1000);
}

Medida	Real
X	Y
130	3
507	4
805	23
970	650
1024	1200

Mientras se obtienen las medidas del sensor es necesario obtener la luminosidad a traves de la

aplicacion LuxMeter (real). Representando los valores en un gráfico obtenemos lo siguiente:

A partir de la regresion lineal se obtiene que la sensibilidad es 225,1 y el offset es 11,9 .

A la hora de calcular la media, mediana y moda de los valores de la luminosidad, lo hemos hecho teniendo en cuenta los distintos niveles de luminosidad que hemos utilizado en el sistema de lógica difusa, ya que el camión deja pasar poca luz, el coche deja pasar algo más de luz, la bicicleta deja pasar casi toda la luz y si la plaza está libre está iluminada con el total de la luz ambiental disponible.

 Para calcular la media móvil hemos usado el siguiente algoritmo:

Con el siguiente código:

#define ldr A0
int in;
int arr_med[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int leng_med = 10;
int med_min = 130;
int med_max = 1024;
int old_index = 0;
int out = 0;
int out_temp = 0;
int tol = 0;

void setup() {
      // put your setup code here, to run once:
      pinMode(ldr, INPUT);
      for(int i=0; i<leng_med;i++){
        arr_med[i]=0;
      }
      leng_med = 10;
      med_min = 100;
      med_max = 1100;
      old_index = 0;
      out = 0;
      out_temp = 0;
      tol = 2; //la desviación típica es 1 aproximadamente, usamos una tolerancia de 2
     Serial.begin(9600);
}
int mean_med() {
      float sum = 0;
      for (int i = 0; i < leng_med; i++) {
        sum = sum + arr_med[i];
      }
     return round(sum / leng_med);
}
void loop() {
    in = analogRead(ldr);
    while (in < med_min && in > med_max) {
        in = analogRead(ldr);
     }
   arr_med[old_index] = in;
   old_index = (old_index + 1) % leng_med;
   int mean = mean_med();
   if (in > (mean - tol) && in < (mean + tol)) {
      out = mean;
   }
  Serial.println(out);
  delay(500);
} 

Por último hemos construido la tabla de LookUp para realizar una regresión lineal utilizando la interpolación.
La tabla lockup utilizada está construida por los mismos valores obtenidos anteriormente:

Medida	Real
X	Y
130	3
507	4
805	23
970	650
1024	1200

 El valor linealizado se obtiene a partir de la siguiente formula:



El código que hemos usado es el siguiente:

#define ldr A0
int real[5] = {3, 4, 23, 650, 1200}; 
int medida[5] = {130, 507, 805, 970, 1024};

int n = 5;
void setup() {
     pinMode(ldr, INPUT);
     Serial.begin(9600);
     Serial.println("Tabla Lockup");
     Serial.println("Medida, Real");
     for (int i = 0; i < 5; i++) {
       Serial.print(medida[i]);
       Serial.print(",");
       Serial.println(real[i]);
    }
    Serial.println("");
    Serial.println("-------------");
    Serial.println("");
    Serial.println("Ejecucion de pruebas");
    Serial.println("Medida, Real");
}
void loop() {
    int data_out = 0;
    int data_in = analogRead(ldr);
    if (data_in < medida[10]) {
        data_out = real[0];
    } else if (data_in > medida[n - 1]) {
       data_out = real[n - 1];
    } else {
       int i = 1;
       while (i < (n - 1) && medida[i] < data_in) {
          i++;
       }
    data_out = map(data_in, medida[i - 1], medida[i], real[i - 1], real[i]);
  }
  Serial.print(data_in);
  Serial.print(",");
  Serial.println(data_out);
  delay(1000);
}

Calibración sensor HC-SR04.

Este sensor no nos ha hecho falta calibrarlo ya que es muy preciso, solo hemos tenido que definir los umbrales de distancia, para saber cuando la plaza está libre o ocupada por un vehículo. 

El sensor lo hemos ubicado en la plaza de garaje arriba (cerca del techo), de tal manera que si la plaza está libre mide la distancia hasta el suelo (distancia máxima), y si está ocupada por un camión mide hasta la parte de arriba del camión (distancia mínima), y los valores de distancia para coche y bicicleta serían valores intermedios de los anteriores (para hacer las pruebas hemos colocado el sensor de ultrasonidos en el suelo también para no tenerlo que mantenerlo levantado mientras tomamos los valores).