29 Mar 2016

Sensor de radiación ultravioleta con Arduino

por Víctor Ventura | publicado en: Portada | 58

Radiación ultravioleta (UV)

Además de la radiación electromagnética que los humanos somos capaces de ver, existen rangos con longitudes de onda más larga, infrarrojo, y más corta, ultravioleta. Una parte de esta radiación, la de longitud más corta, tiene efectos ionizantes, es decir, es capaz de desplazar electrones de los átomos modificando su estado.

Mientras que la zona visible se encuentra aproximadamente en el rango comprendido entre los 400 nm y los 700 nm, la ultravioleta comienza en los 10 nm (ultravioleta extremo) y termina en los 400 nm (UVA, onda larga) donde comienza la parte visible del espectro.

La radiación ultravioleta se utiliza para diversos fines prácticos, desde matar bacterias hasta revelar las placas de los circuitos impresos que fabricas en casa pero además de útil puede ser también peligrosa para la salud.

La capa de ozono que rodea la tierra nos defiende de buena parte de la radiación ultravioleta más ionizante de la que nos llega desde el sol: la de longitud de onda más corta, los «rayos UVC», que se encuentran entre los 100 nm y 280 nm. Pero aún queda la UVB, entre 280 nm y 315 nm, también en parte ionizante y la UVB, entre 315 nm y 400 nm, que es menos agresiva.

Precisamente es la radiación ultravioleta la que produce la capa de ozono en la estratosfera al disociar las moléculas de oxígeno O₂ en dos átomos O, muy reactivos, que forman el ozono O₃ al reaccionar cada uno con otra molécula de O₂.

Índice UV (ultravioleta)

El índice UV es un sistema estándar sencillo para medir la radiación ultravioleta que llega desde el sol a la tierra que sirve como orientación para determinar el riesgo potencial para la salud. La Organización Mundial de la Salud publica una guía práctica sobre el índice UV en la que explica los riesgos para la salud de la radiación ultravioleta y propone algunas medidas de protección en función de su intensidad.

Esta guía práctica sobre el Índice Solar Mundial es una recomendación conjunta de la Organización Mundial de la Salud, la Organización Meteorológica Mundial, el Programa de las Naciones Unidas para el Medio Ambiente y la Comisión Internacional de Protección contra la Radiación no Ionizante.

Para hacer su uso más sencillo establece un código de colores que asocia a los diferentes niveles: verde para el nivel bajo (índices 1 y 2), amarillo para el moderado (índices del 3 al 5), naranja para el alto (índices 6 y 7), rojo para el nivel muy alto (índices del 8 al 10) y morado para el nivel extremadamente alto (índices 11 en adelante) En función de estos índices y del fototipo de cada persona recomienda unos tiempos máximos de exposición y unas recomendaciones preventivas.

Medida de la radiación ultravioleta y cálculo del índice UV

Para medir con precisión la radiación ultravioleta, no solo la que llega del sol, también la que producen ciertos equipos, como las lámparas o LED con este tipo de luz, se utilizan espectrorradiómetros. Calibrados con los anteriores dispositivos, se pueden usar otros más sencillos (y económicos) como fotodiodos, que suelen ser de tipo Schottky. El «truco» consiste en medir la luz de cierta longitud de onda (del entorno de los UVA, normalmente) y presumir que corresponde, más o menos proporcionalmente, con la irradiancia ultravioleta; puede parecer poco preciso, pero es razonablemente funcional como para estimar el UVi.

Existen componentes que incorporan sólo la función de medida de la radiación ultravioleta o, más exactamente la del índice UV, como el GUVA-S12SD, que incorporan amplificación, como el ML8511, ambos analógicos, o digitales, como el VEML6070, que comunican por I²C el resultado de la medición. También están presentes como una función secundaria en algunos sensores de iluminación y proximidad, como el Si1145, que también utiliza el protocolo I²C.

Ninguno de los anteriores componentes es especialmente caro ni adquirido en series pequeñas y existen versiones de todos ellos en módulos que se pueden usar para prototipar o para realizar pruebas.

Para usarlo como ejemplo en este artículo he elegido el GUVA-S12SD que es muy popular (seguramente tienes uno en tu insoladora ultravioleta de circuitos) y que se puede encontrar en módulos UVM30A que pueden usarse fácilmente con Arduino. El rango de longitudes de onda que mide el GUVA-S12SD se sitúa entre los 240 nm y los (aproximadamente) 380 nm, muy adecuado para determinar la radiación ultravioleta más peligrosa.

Como la fórmula para calcular el índice UV, que puede consultarse en la guía práctica sobre el índice UV es muy compleja como para actualizar el resultado frecuentemente con un microcontrolador, el fabricante del módulo proporciona una tabla con los valores de salida con los que se alcanzan los diferentes niveles del índice UV.

Según puede verse en la gráfica anterior, especialmente para radiaciones bajas, el comportamiento no es completamente lineal aunque a efectos de establecer el índice UV, con unos márgenes relativamente grandes, no se cometería un gran error al considerarlo como lineal para ahorrar unos bytes de memoria o simplificar la programación. En cualquier caso, en los programas de ejemplo para Arduino que he desarrollado como ejemplo se usa la tabla de valores del fabricante.

Usar el fotodiodo Schottky GUVA-S12SD del módulo UVM30A con Arduino

Usar el módulo UVM30A no puede ser más sencillo, basta con alimentarlo y leer el voltaje con el que representa el nivel de radiación ultravioleta que detecta. Puede alimentarse con tensiones entre 3 V y 5 V y puede entregar a la salida entre 0 y 1200 mV (aunque de hecho no supere el voltio). Como por encima de 1100 mV de salida corresponde a un índice UV extremadamente alto (un índice mayor que 10) se puede usar la referencia interna de 1100 mV para distribuir mejor la sensibilidad aunque renunciando a la posibilidad de determinar cuánto se supera el índice 10, sólo estimando que se alcanzado el 11, pero ahorrando un divisor de tensión para usar como referencia de entrada analógica en Arduino.

Para trabajar con la referencia interna de 1100 mV en las placas Arduino basadas en el microcontrolador ATmega168 o en el ATmega328 (como Arduino Uno) se usa analogReference(INTERNAL) y se usa analogReference(INTERNAL1V1) para las placas Arduino Mega.

El tiempo de lectura del GUVA-S12SD es bastante rápido y la respuesta razonablemente estable. En los montajes de prueba, la lectura analógica que se realiza del módulo UVM30A desde Arduino, seguramente por la disposición de los cables, no es tan buena como la que da el osciloscopio, aunque resulta más que aceptable para medir el índice UV y es de esperar que en un prototipo montado en un circuito impreso incluso mejore. En cualquier caso, para tratar de eliminar las desviaciones de posibles interferencias, el programa realiza varias mediciones, tantas como sea posible en cierto periodo de tiempo, y las promedia para establecer un valor que compara con los de la tabla del fabricante para calcular el índice UV.

Puesto que la lectura analógica con analogRead() tiene una resolución de 10 bits (excepto en Arduino Due y en Arduino Zero, en los que puede configurarse a 12 bits) para obtener la tensión entregada por el módulo UVM30A hay que convertir el rango de 0 a 1023, que devuelve la función, al rango que va de 0 a 1100, que son los milivoltios que se han establecido como referencia con analogReference(). Para realizar la conversión hay que multiplicar por 1100 y dividir por 1023. En el primer programa de ejemplo se usa como una constante para hacerlo en una única operación y facilitar la lectura.

El siguiente programa de ejemplo lee el sensor de radiación ultravioleta GUVA-S12SD del módulo UVM30A cada cierto intervalo ESPERA_ENTRE_LECTURAS y va calculando la media de las lecturas que muestra cada cierto tiempo ESPERA_ENTRE_PRESENTACIONES junto con el valor correspondiente en mV

#define PIN_GUVAS12SD A0 // Pin al que se conecta el módulo con el UVM30A
#define ESPERA_ENTRE_LECTURAS 100 // Leer cada 100 ms. Necesita unos 100 µs para cada lectura analógica
#define ESPERA_ENTRE_PRESENTACIONES 60000 // Mostrar la lectura cada minuto
#define COEFICIENTE_VOLTAJE 1.07526881720430107527 // 1100/1023≃1.07526881720430107527 La lectura máxima es de 1023 que corresponde a 1100 mV 

unsigned int lectura_sensor;
unsigned int contador_lecturas=1;
float total_lecturas=0.0;
float media_lecturas;
long cronometro_lecturas;
long cronometro_presentaciones;
long tiempo_transcurrido;

void setup()
{
  analogReference(INTERNAL); // Referencia interna de 1100 mV El GUVA-S12SD mide de 0 a 1170 mV que corresponde con el índice UV 11
  //pinMode(PIN_GUVAS12SD,INPUT); // La lectura analógica no necesita inicialización
  Serial.begin(9600);
  #if defined (__AVR_ATmega32U4__)
    while(!Serial);// Esperar a Arduino Leonardo
  #endif
  lectura_sensor=analogRead(PIN_GUVAS12SD); // La primera lectura es incorrecta (normalmente cero) y necesita unos 100 µs para cada lectura analógica
  cronometro_lecturas=millis(); // Esperar un ciclo de lectura para estabilizar el sensor y la entrada analógica
  cronometro_presentaciones=millis();
}
void loop()
{
  tiempo_transcurrido=millis()-cronometro_lecturas;
  if(tiempo_transcurrido>ESPERA_ENTRE_LECTURAS)
  {
    cronometro_lecturas=millis();
    lectura_sensor=analogRead(PIN_GUVAS12SD);
    total_lecturas+=lectura_sensor;
    media_lecturas=total_lecturas/contador_lecturas++;
  }
  tiempo_transcurrido=millis()-cronometro_presentaciones;
  if(tiempo_transcurrido>ESPERA_ENTRE_PRESENTACIONES)
  {
    cronometro_presentaciones=millis();
    Serial.print("Lectura sensor: "+String(media_lecturas,DEC));
    Serial.print(" (media de "+String(contador_lecturas,DEC)+")");
    Serial.print(" Tensión (mV): "+String(media_lecturas*COEFICIENTE_VOLTAJE,DEC)+"\n\n");
    contador_lecturas=1;
    total_lecturas=0.0;
  }
}

#define PIN_GUVAS12SD A0 // Pin al que se conecta el módulo con el UVM30A

#define ESPERA_ENTRE_LECTURAS 100 // Leer cada 100 ms. Necesita unos 100 µs para cada lectura analógica

#define ESPERA_ENTRE_PRESENTACIONES 60000 // Mostrar la lectura cada minuto

#define COEFICIENTE_VOLTAJE 1.07526881720430107527 // 1100/1023≃1.07526881720430107527 La lectura máxima es de 1023 que corresponde a 1100 mV

unsigned int lectura_sensor;

unsigned int contador_lecturas=1;

float total_lecturas=0.0;

float media_lecturas;

long cronometro_lecturas;

long cronometro_presentaciones;

long tiempo_transcurrido;

void setup()

{

analogReference(INTERNAL); // Referencia interna de 1100 mV El GUVA-S12SD mide de 0 a 1170 mV que corresponde con el índice UV 11

//pinMode(PIN_GUVAS12SD,INPUT); // La lectura analógica no necesita inicialización

Serial.begin(9600);

#if defined (__AVR_ATmega32U4__)

while(!Serial);// Esperar a Arduino Leonardo

#endif

lectura_sensor=analogRead(PIN_GUVAS12SD); // La primera lectura es incorrecta (normalmente cero) y necesita unos 100 µs para cada lectura analógica

cronometro_lecturas=millis(); // Esperar un ciclo de lectura para estabilizar el sensor y la entrada analógica

cronometro_presentaciones=millis();

}

void loop()

{

tiempo_transcurrido=millis()-cronometro_lecturas;

if(tiempo_transcurrido>ESPERA_ENTRE_LECTURAS)

{

cronometro_lecturas=millis();

lectura_sensor=analogRead(PIN_GUVAS12SD);

total_lecturas+=lectura_sensor;

media_lecturas=total_lecturas/contador_lecturas++;

}

tiempo_transcurrido=millis()-cronometro_presentaciones;

if(tiempo_transcurrido>ESPERA_ENTRE_PRESENTACIONES)

{

cronometro_presentaciones=millis();

Serial.print("Lectura sensor: "+String(media_lecturas,DEC));

Serial.print(" (media de "+String(contador_lecturas,DEC)+")");

Serial.print(" Tensión (mV): "+String(media_lecturas*COEFICIENTE_VOLTAJE,DEC)+"\n\n");

contador_lecturas=1;

total_lecturas=0.0;

}

Del mismo modo, para ahorrar un poco de proceso se pueden calcular los valores compensados para la tabla de índices. En lugar de comparar la lectura analógica con el valor de la hoja de datos del UVM30A se puede crear un vector que contenga los datos convertidos al rango de 0 a 1023 realizando la operación inversa a la descrita antes. Ya no será necesario calcular la tensión a cada lectura puesto que la tabla de índices está modificada.

#define PIN_GUVAS12SD A0 // Pin al que se conecta el módulo con el UVM30A
#define ESPERA_ENTRE_LECTURAS 100 // Leer cada 100 ms
#define ESPERA_ENTRE_PRESENTACIONES 30000 // Mostrar el índice cada 30 s
#define CANTIDAD_INDICES_UV 11

unsigned int lectura_sensor;
unsigned int contador_lecturas=1;
float total_lecturas=0.0;
float media_lecturas;
int valor_indice_uv[CANTIDAD_INDICES_UV]={210,295,378,467,563,646,738,818,907,1003,1022}; // De 1 a 11
byte indice;
boolean buscando_indice_uv;
long cronometro_lecturas;
long cronometro_presentaciones;
long tiempo_transcurrido;

void setup()
{
  analogReference(INTERNAL); // Referencia interna de 1100 mV El GUVA-S12SD mide de 0 a 1170 mV que corresponde con el índice UV 11
  //pinMode(PIN_GUVAS12SD,INPUT); // La lectura analógica no necesita inicialización
  Serial.begin(9600);
  #if defined (__AVR_ATmega32U4__)
    while(!Serial);// Esperar a Arduino Leonardo
  #endif
  lectura_sensor=analogRead(PIN_GUVAS12SD); // La primera lectura es incorrecta (normalmente cero)
  cronometro_lecturas=millis(); // Esperar un ciclo de lectura para estabilizar el sensor y la entrada analógica
  cronometro_presentaciones=millis();
}
void loop()
{
  tiempo_transcurrido=millis()-cronometro_lecturas;
  if(tiempo_transcurrido>ESPERA_ENTRE_LECTURAS)
  {
    cronometro_lecturas=millis();
    lectura_sensor=analogRead(PIN_GUVAS12SD);
    total_lecturas+=lectura_sensor;
    media_lecturas=total_lecturas/contador_lecturas++;
  }
  tiempo_transcurrido=millis()-cronometro_presentaciones;
  if(tiempo_transcurrido>ESPERA_ENTRE_PRESENTACIONES)
  {
    cronometro_presentaciones=millis();
    buscando_indice_uv=true;
    indice=CANTIDAD_INDICES_UV;
    while(buscando_indice_uv&&indice>0)
    {
      indice--;
      if(media_lecturas>valor_indice_uv[indice])
      {
        buscando_indice_uv=false;
      }
    }
    Serial.print("Lectura sensor: "+String(media_lecturas,DEC));
    Serial.print(" (media de "+String(contador_lecturas,DEC)+")");
    Serial.print(" Índice UV: "+String(indice,DEC));
    contador_lecturas=1;
    total_lecturas=0.0;
  }
}

#define PIN_GUVAS12SD A0 // Pin al que se conecta el módulo con el UVM30A

#define ESPERA_ENTRE_LECTURAS 100 // Leer cada 100 ms

#define ESPERA_ENTRE_PRESENTACIONES 30000 // Mostrar el índice cada 30 s

#define CANTIDAD_INDICES_UV 11

unsigned int lectura_sensor;

unsigned int contador_lecturas=1;

float total_lecturas=0.0;

float media_lecturas;

int valor_indice_uv[CANTIDAD_INDICES_UV]={210,295,378,467,563,646,738,818,907,1003,1022}; // De 1 a 11

byte indice;

boolean buscando_indice_uv;

long cronometro_lecturas;

long cronometro_presentaciones;

long tiempo_transcurrido;

void setup()

{

analogReference(INTERNAL); // Referencia interna de 1100 mV El GUVA-S12SD mide de 0 a 1170 mV que corresponde con el índice UV 11

//pinMode(PIN_GUVAS12SD,INPUT); // La lectura analógica no necesita inicialización

Serial.begin(9600);

#if defined (__AVR_ATmega32U4__)

while(!Serial);// Esperar a Arduino Leonardo

#endif

lectura_sensor=analogRead(PIN_GUVAS12SD); // La primera lectura es incorrecta (normalmente cero)

cronometro_lecturas=millis(); // Esperar un ciclo de lectura para estabilizar el sensor y la entrada analógica

cronometro_presentaciones=millis();

}

void loop()

{

tiempo_transcurrido=millis()-cronometro_lecturas;

if(tiempo_transcurrido>ESPERA_ENTRE_LECTURAS)

{

cronometro_lecturas=millis();

lectura_sensor=analogRead(PIN_GUVAS12SD);

total_lecturas+=lectura_sensor;

media_lecturas=total_lecturas/contador_lecturas++;

}

tiempo_transcurrido=millis()-cronometro_presentaciones;

if(tiempo_transcurrido>ESPERA_ENTRE_PRESENTACIONES)

{

cronometro_presentaciones=millis();

buscando_indice_uv=true;

indice=CANTIDAD_INDICES_UV;

while(buscando_indice_uv&&indice>0)

{

indice--;

if(media_lecturas>valor_indice_uv[indice])

{

buscando_indice_uv=false;

}

Serial.print("Lectura sensor: "+String(media_lecturas,DEC));

Serial.print(" (media de "+String(contador_lecturas,DEC)+")");

Serial.print(" Índice UV: "+String(indice,DEC));

contador_lecturas=1;

total_lecturas=0.0;

}

Implementar el método en un semáforo de índice UV

Utilizando el código de colores que publica la Organización Mundial de la Salud en la guía práctica sobre el índice UV se puede construir un sencillo montaje basado en Arduino (que puede ser muy portátil si se usa una placa Arduino Mini, Arduino Micro, Arduino Nano…) que encienda el LED del color correspondiente al índice UV detectado por el GUVA-S12SD de un módulo UVM30A.

En el diagrama se muestra la conexión usada para el código del ejemplo del «solmáforo». El valor de las resistencias, rotulado como 220 Ω en el esquema, se sustituirá por el que corresponda a la tensión a la que deban trabajar los LED (dependiendo del propio LED y de la relación entre luminosidad y vida útil deseada, seguramente entre 100 Ω y 330 Ω). No es especialmente importante utilizar ni la misma entrada analógica A0 ni las mismas salidas digitales, pero hay que recordar sustituirlas en el programa.

#define PIN_VERDE 2
#define PIN_AMARILLO 4
#define PIN_NARANJA 7
#define PIN_ROJO 8
#define PIN_MORADO 12
#define PIN_GUVAS12SD A0 // Pin al que se conecta el módulo con el UVM30A
#define ESPERA_ENTRE_LECTURAS 100 // Tomar una lectura del sensor de ultravioleta cada 100 ms
#define ESPERA_ENTRE_PRESENTACIONES 10000 // Cambiar el color del semáforo cada 10 segundos
#define CANTIDAD_INDICES_UV 11
#define CANTIDAD_COLORES_UV 5

unsigned int lectura_sensor;
unsigned int contador_lecturas=1;
float total_lecturas=0.0;
float media_lecturas;
int valor_indice_uv[CANTIDAD_INDICES_UV]={210,295,378,467,563,646,738,818,907,1003,1022}; // De 1 a 11
byte color[CANTIDAD_INDICES_UV+1]={PIN_VERDE,PIN_VERDE,PIN_VERDE,PIN_AMARILLO,PIN_AMARILLO,PIN_AMARILLO,PIN_NARANJA,PIN_NARANJA,PIN_ROJO,PIN_ROJO,PIN_ROJO,PIN_MORADO}; // De 0 a 11
byte pin_color[CANTIDAD_COLORES_UV]={PIN_VERDE,PIN_AMARILLO,PIN_NARANJA,PIN_ROJO,PIN_MORADO};
byte indice;
byte indice_anterior=0;
boolean buscando_indice_uv;
long cronometro_lecturas;
long cronometro_presentaciones;
long tiempo_transcurrido;

void setup()
{
  analogReference(INTERNAL); // Referencia interna de 1100 mV El GUVA-S12SD mide de 0 a 1170 mV que corresponde con el índice UV 11
  //pinMode(PIN_GUVAS12SD,INPUT); // La lectura analógica no necesita inicialización
  for(indice=0;indice<CANTIDAD_COLORES_UV;indice++)
  {
    pinMode(pin_color[indice],OUTPUT);
    digitalWrite(pin_color[indice],LOW);
  }
  digitalWrite(pin_color[0],HIGH);
  lectura_sensor=analogRead(PIN_GUVAS12SD); // La primera lectura es incorrecta (normalmente cero)
  cronometro_lecturas=millis(); // Esperar un ciclo de lectura para estabilizar el sensor y la entrada analógica
  cronometro_presentaciones=millis();
}
void loop()
{
  tiempo_transcurrido=millis()-cronometro_lecturas;
  if(tiempo_transcurrido>ESPERA_ENTRE_LECTURAS)
  {
    cronometro_lecturas=millis();
    lectura_sensor=analogRead(PIN_GUVAS12SD);
    total_lecturas+=lectura_sensor;
    media_lecturas=total_lecturas/contador_lecturas++;
  }
  tiempo_transcurrido=millis()-cronometro_presentaciones;
  if(tiempo_transcurrido>ESPERA_ENTRE_PRESENTACIONES)
  {
    cronometro_presentaciones=millis();
    buscando_indice_uv=true;
    indice=CANTIDAD_INDICES_UV;
    while(buscando_indice_uv&&indice>0)
    {
      indice--;
      if(media_lecturas>valor_indice_uv[indice])
      {
        buscando_indice_uv=false;
      }
    }
    if(indice_anterior!=indice)
    {
      digitalWrite(color[indice_anterior],LOW);
      digitalWrite(color[indice],HIGH);
      indice_anterior=indice;
    }
    contador_lecturas=1;
    total_lecturas=0.0;
  }
}

#define PIN_VERDE 2

#define PIN_AMARILLO 4

#define PIN_NARANJA 7

#define PIN_ROJO 8

#define PIN_MORADO 12

#define PIN_GUVAS12SD A0 // Pin al que se conecta el módulo con el UVM30A

#define ESPERA_ENTRE_LECTURAS 100 // Tomar una lectura del sensor de ultravioleta cada 100 ms

#define ESPERA_ENTRE_PRESENTACIONES 10000 // Cambiar el color del semáforo cada 10 segundos

#define CANTIDAD_INDICES_UV 11

#define CANTIDAD_COLORES_UV 5

unsigned int lectura_sensor;

unsigned int contador_lecturas=1;

float total_lecturas=0.0;

float media_lecturas;

int valor_indice_uv[CANTIDAD_INDICES_UV]={210,295,378,467,563,646,738,818,907,1003,1022}; // De 1 a 11

byte color[CANTIDAD_INDICES_UV+1]={PIN_VERDE,PIN_VERDE,PIN_VERDE,PIN_AMARILLO,PIN_AMARILLO,PIN_AMARILLO,PIN_NARANJA,PIN_NARANJA,PIN_ROJO,PIN_ROJO,PIN_ROJO,PIN_MORADO}; // De 0 a 11

byte pin_color[CANTIDAD_COLORES_UV]={PIN_VERDE,PIN_AMARILLO,PIN_NARANJA,PIN_ROJO,PIN_MORADO};

byte indice;

byte indice_anterior=0;

boolean buscando_indice_uv;

long cronometro_lecturas;

long cronometro_presentaciones;

long tiempo_transcurrido;

void setup()

{

analogReference(INTERNAL); // Referencia interna de 1100 mV El GUVA-S12SD mide de 0 a 1170 mV que corresponde con el índice UV 11

//pinMode(PIN_GUVAS12SD,INPUT); // La lectura analógica no necesita inicialización

for(indice=0;indice<CANTIDAD_COLORES_UV;indice++)

{

pinMode(pin_color[indice],OUTPUT);

digitalWrite(pin_color[indice],LOW);

}

digitalWrite(pin_color[0],HIGH);

lectura_sensor=analogRead(PIN_GUVAS12SD); // La primera lectura es incorrecta (normalmente cero)

cronometro_lecturas=millis(); // Esperar un ciclo de lectura para estabilizar el sensor y la entrada analógica

cronometro_presentaciones=millis();

}

void loop()

{

tiempo_transcurrido=millis()-cronometro_lecturas;

if(tiempo_transcurrido>ESPERA_ENTRE_LECTURAS)

{

cronometro_lecturas=millis();

lectura_sensor=analogRead(PIN_GUVAS12SD);

total_lecturas+=lectura_sensor;

media_lecturas=total_lecturas/contador_lecturas++;

}

tiempo_transcurrido=millis()-cronometro_presentaciones;

if(tiempo_transcurrido>ESPERA_ENTRE_PRESENTACIONES)

{

cronometro_presentaciones=millis();

buscando_indice_uv=true;

indice=CANTIDAD_INDICES_UV;

while(buscando_indice_uv&&indice>0)

{

indice--;

if(media_lecturas>valor_indice_uv[indice])

{

buscando_indice_uv=false;

}

if(indice_anterior!=indice)

{

digitalWrite(color[indice_anterior],LOW);

digitalWrite(color[indice],HIGH);

indice_anterior=indice;

}

contador_lecturas=1;

total_lecturas=0.0;

}

Para la versión portátil se puede usar una batería LiPo y un cargador para USB (el módulo más a la derecha de la imagen). Yo he utilizado dos interruptores, uno para cargar la batería y otro para encender el dispositivo, pero es posible hacerlo solamente con uno y hacer una u otra operación en función de la posición en la que conmute; será necesario usar conmutadores, no interruptores, claro.

Además de poner el sensor a 90° o mejor en el lado contrario a los LED (el semáforo sirve para el exterior y se puede usar en condiciones de mucha luz) puede ser útil añadir a la caja un resalte que haga de visera para distinguir mejor el color.

Si usas una placa Arduino Uno se puede alimentar con una pila de 9 V (recuerda que la tensión de salida de Arduino determinará el cálculo de las resistencias de los LED). Otra alternativa es usar un único LED RGB que establezca el color en función del índice UV. Seguro que habrá ocasión de tratar estas alternativas en próximos artículos ¡no te los pierdas!

Víctor Ventura

Desarrollando aplicaciones para la web conocí el potencial de internet de las cosas, encontré la excusa perfecta para satisfacer la inquietud de aprender electrónica que había tenido desde siempre. Ahora puedo darme el gusto de programar las cosas que yo mismo diseño y fabrico.

Más entradas - Página web

Sígueme:

Sobre el Autor
Últimas entradas

Seguir Víctor Ventura:

Víctor Ventura

Programador multimedia y web + IoT. Mejor con software libre.

Últimas publicaciones de Víctor Ventura

Qué es la Internet de las Cosas (IoT) - 2 julio, 2017
Librería Hardware I/O para Processing - 14 febrero, 2017
Instalar GNU/Linux en un SBC para monitorización y control electrónico - 26 enero, 2017

58 Respuestas

Jose Luis Viamonte Alonso

6 mayo, 2016 | Reply

Gracias por la información, llevaba tiempo intentando encontrar información de como fabricar un medidor de UV.
- Víctor Ventura
  
  6 mayo, 2016 | Reply
  
  Hola, Jose Luis.
  
  Gracias a ti por visitar polaridades. Me alegro de que el artículo te haya resultado útil. Si el tema te interesa, sigue el blog, que en unos días voy a publicar algo más sobre sensores UV y el índice UVi.
  
  ¡Hasta pronto!

juan

8 julio, 2016 | Reply

muy pero muy buena la informacion un favor no se si se le puede agregar una adquisicion de datos cada 4 minutos para bajarlos a un usb o algo asi todo lo que se esta midiendo.. gracias

Víctor Ventura

8 julio, 2016 | Reply

Hola, Juan.

Parece fácil, por ejemplo, grabarlo en una tarjeta SD. En cuanto tenga un rato lo añado al artículo (y te aviso por correo).

Gracias a ti por participar en polaridad.es

Víctor Ventura

9 julio, 2016 | Reply

Hola otra vez, Juan.

He preparado un sencillo programa que graba cada 4 minutos los valores que se han ido promediando al leer el sensor de ultravioleta.

Además del lector SD utiliza un conmutador que cambia entre GND y nivel alto (3 V o 5 V, según qué placa uses) para activar y desactivar la grabación (y así no tener errores al crear-cerrar el documento) y un LED para indicar que se están grabando datos. Lógicamente, debes usar los números de pin de los #define para las conexiones o cambiarlos según tu hardware.

Una posible mejora incluiría un reloj en tiempo real, como el RTC DS3231. Puedes encontrar algún artículo en el blog sobre cómo gestionar el DS3231 desde Arduino usando las comunicaciones I2C, así como una librería para manejar la fecha y la hora usando un RTC DS3231 con Arduino.

Como el código está muy comentado, no te aburro con más charla. Espero que te sirva. ¡Vuelve pronto por polaridad.es!

#define MODO_PRUEBAS // Borrar esta definición para que no se envíen a la consola datos de informe en modo prueba

#define PREFIJO_ARCHIVO "UVI" // Los nombres de los documentos tienen el formato UVIn.CSV siendo n el número (correlativo) de archivo
#define EXTENSION_ARCHIVO ".CSV" // Se usa el formato CSV, valores expresados como texto y separados por comas (también puede usarse punto y coma, espacio, tabulador…)
#define SEPARADOR_CSV "," // El separador usado para el formato CSV

#define PIN_GUVAS12SD A0 // Pin al que se conecta el módulo con el UVM30A
#define PIN_CS_SD 4 // Pin usado para activar (CS/SS) la tarjeta
#define PIN_CS_CONVENCIONAL 10 // Pin usado normalmente para activar dispositivos SPI
#define PIN_INFORME_ACTIVO 8 // LED que indica que la tarjeta SD está preparada para grabar datos
#define PIN_CONMUTADOR_SD 9 // Pin que le indica al programa que debe preparar la tarjeta SD y grabar datos (nivel alto) o que debe vaciar el buffer y dejar de usar la tarjeta SD (nivel bajo)

#define ESPERA_REINTENTO_ERROR 3000 // Esperar unos segundos antes de reintentar después de detectar un error
#define ESPERA_MUESTREO_UVI 240000 // Intervalo entre grabaciones del valor del UVi (4 minutos a petición de Juan 4*60*1000 ms)

#define COEFICIENTE_VOLTAJE 1.07526881720430107527 // 1100/1023≃1.07526881720430107527 La lectura máxima es de 1023 que corresponde a 1100 mV 

#include <SD.h> // La librería SD estándar de Arduino

File informe_uvi;
char nombre_archivo[13]; // buffer para el nombre del documento con el informe UVi
char buffer_numero_archivo[4]; // buffer con el número (sufijo) del documento
unsigned int numero_archivo=0; // Número de archivo que se busca para, si no existe, usarlo como sufijo del nombre
boolean informe_activo=false; // No se están grabando datos en la tarjeta SD
boolean nuevo_estado_informe; // Lectura actual del conmutador de la tarjeta SD
unsigned long cronometro; // Tiempo entre grabaciones del índice UVi en la tarjeta SD
unsigned long contador_lecturas; // Número de lecturas tomadas entre grabaciones (para calcular el valor intermedio)
unsigned int lectura_sensor; // Valor entregado por el sensor GUVAS12SD
float total_lecturas=0.0; // Suma de los valores muestreados en una sesión
float media_lecturas; // Valor intermedio de los valores muestreados entre grabaciones
String registro_csv; // Datos que se graban en una línea del documento CSV (milisegundos (desde encendido) ,valor calculado, lecturas promediadas)

void setup()
{
  #ifdef MODO_PRUEBAS
    Serial.begin(9600); // Preparar el puerto serie
    #ifdef __AVR_ATmega32U4__
      while(!Serial);// Esperar a Arduino Leonardo
    #endif
  #endif
  analogReference(INTERNAL); // Referencia interna de 1100 mV El GUVA-S12SD mide de 0 a 1170 mV que corresponde con el índice UV 11
  lectura_sensor=analogRead(PIN_GUVAS12SD); // La primera lectura es incorrecta (normalmente cero)
  pinMode(PIN_CS_SD,OUTPUT); // El pin al que realmente se conecta la tarjeta SD debe ser de salida para activarla (nivel bajo) o desactivarla (nivel alto)
  digitalWrite(PIN_CS_SD,HIGH); // Desactivar la tarjeta SD
  pinMode(PIN_CS_CONVENCIONAL,OUTPUT); // Puede que sea necesario usar como salida (o simplemente reservar) el pin que normalmente se utiliza para SPI por seguridad (si el verdadero no es el 10)
  digitalWrite(PIN_CS_SD,HIGH); // Desactivar el dispositivo en el bus SPI habitual
  while(!SD.begin(PIN_CS_SD)) // Reintentar hasta activar el lector de tarjetas SD (si no se consigue, no hay razón para seguir el programa)
  {
    #ifdef MODO_PRUEBAS
      Serial.print("Error al inicializar el lector de tarjetas SD. Se reintenta en ");
      Serial.print(ESPERA_REINTENTO_ERROR);
      Serial.println(" ms.");
    #endif
    delay(ESPERA_REINTENTO_ERROR); // Esperar antes de reintentar
  }
  #ifdef MODO_PRUEBAS
    Serial.println("Lector de tarjetas SD inicializado");
  #endif
  pinMode(PIN_INFORME_ACTIVO,OUTPUT); // Pin del LED de aviso de SD activada
  digitalWrite(PIN_INFORME_ACTIVO,LOW); // Apagar el LED que informa de que se pueden estar grabando datos en la tarjeta
  pinMode(PIN_CONMUTADOR_SD,INPUT);
}

void loop()
{
  nuevo_estado_informe=digitalRead(PIN_CONMUTADOR_SD);
  if(nuevo_estado_informe!=informe_activo) // Si ha cambiado el estado (ha cambiado la posición del conmutador)
  {
    if(nuevo_estado_informe) // Si el conmutador está en modo grabar (y antes no lo estaba)
    {
      do
      {
        itoa(numero_archivo++,buffer_numero_archivo,10);
        strcpy(nombre_archivo,PREFIJO_ARCHIVO);
        strcat(nombre_archivo,buffer_numero_archivo);
        strcat(nombre_archivo,EXTENSION_ARCHIVO);
        #ifdef MODO_PRUEBAS
          Serial.println("Probando a usar el documento "+String(nombre_archivo));
        #endif
      }
      while(SD.exists(nombre_archivo));
      informe_uvi=SD.open(nombre_archivo,FILE_WRITE);
      if(informe_uvi) // Si se ha conseguido preparar el documento…
      {
        informe_activo=true; // …cambiar el estado a activo
        digitalWrite(PIN_INFORME_ACTIVO,HIGH); // Encender el LED para informar de que se pueden estar grabando datos en la tarjeta SD
        contador_lecturas=0; // Empezar a contar lecturas entre grabaciones (para calcular el valor intermedio)
        #ifdef MODO_PRUEBAS
          Serial.println("Informe UVi activo");
        #endif
        cronometro=millis(); // (re)Iniciar el cronómetro para saber si ha pasado el tiempo entre grabaciones
      }
      else
      {
        #ifdef MODO_PRUEBAS
          Serial.println("Se ha producido un error al tratar de crear el documento.");
          Serial.print("Se reintentará dentro de ");
          Serial.print(ESPERA_REINTENTO_ERROR);
          Serial.println(" ms.");
        #endif
        delay(ESPERA_REINTENTO_ERROR); // Esperar antes de reintentar
      }
    }
    else // Si el conmutador está en modo NO grabar (y antes no lo estaba)
    {
      informe_uvi.flush(); // Vaciar el buffer
      informe_uvi.close(); // Cerrar el archivo
      informe_activo=false; // Cambiar el estado a inactivo (no se graban datos en la tarjeta SD)
      digitalWrite(PIN_INFORME_ACTIVO,LOW); // Apagar el LED que informa de grabación activa
      #ifdef MODO_PRUEBAS
        Serial.println("Informe UVi desactivado");
      #endif
    }
  }
  if(informe_activo) // Si la grabación está activa
  {
    if((unsigned long)(millis()-cronometro)>ESPERA_MUESTREO_UVI) // Si la grabación está activa y ha pasado el tiempo entre grabaciones sucesivas…
    {
      cronometro=millis(); // (re)Iniciar el cronómetro para saber si ha pasado el tiempo entre grabaciones
      media_lecturas*=COEFICIENTE_VOLTAJE; // Corregir los valores tomados para que trabaje con el voltaje (más o menos coincide con un UVi decimal)
      #ifdef MODO_PRUEBAS
        Serial.print("Guardado el valor ");
        Serial.print(media_lecturas);
        Serial.print(" en ");
        Serial.print(cronometro);
        Serial.print(" ms (");
        Serial.print(contador_lecturas);
        Serial.println(" muestras)");
      #endif
      registro_csv=String(cronometro,DEC); // Componer la línea CSV (registro) con el tiempo,
      registro_csv+=String(SEPARADOR_CSV); // un separador,
      registro_csv+=String(media_lecturas,DEC); // Valor intermedio de las lecturas hasta el momento,
      registro_csv+=String(SEPARADOR_CSV); // otro separador
      registro_csv+=String(contador_lecturas,DEC); // y el número de muestras tomadas para calcular el valor intermedio (más de 1100000 en un Arduino Uno con intervalos de 4 minutos)
      informe_uvi.println(registro_csv); // Grabar la línea CSV (el registro)
      contador_lecturas=0; // Empezar a contar lecturas entre grabaciones (para calcular el nuevo valor intermedio)
    }
    else // Si no toca grabar, tomar una medida y actualizar el cálculo del valor intermedio
    {
      lectura_sensor=analogRead(PIN_GUVAS12SD); // leer el sensor
      contador_lecturas++; // incrementar el número de lecturas realizadas
      total_lecturas+=lectura_sensor;
      media_lecturas=total_lecturas/contador_lecturas;
    }
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

#define MODO_PRUEBAS // Borrar esta definición para que no se envíen a la consola datos de informe en modo prueba

#define PREFIJO_ARCHIVO "UVI" // Los nombres de los documentos tienen el formato UVIn.CSV siendo n el número (correlativo) de archivo

#define EXTENSION_ARCHIVO ".CSV" // Se usa el formato CSV, valores expresados como texto y separados por comas (también puede usarse punto y coma, espacio, tabulador…)

#define SEPARADOR_CSV "," // El separador usado para el formato CSV

#define PIN_GUVAS12SD A0 // Pin al que se conecta el módulo con el UVM30A

#define PIN_CS_SD 4 // Pin usado para activar (CS/SS) la tarjeta

#define PIN_CS_CONVENCIONAL 10 // Pin usado normalmente para activar dispositivos SPI

#define PIN_INFORME_ACTIVO 8 // LED que indica que la tarjeta SD está preparada para grabar datos

#define PIN_CONMUTADOR_SD 9 // Pin que le indica al programa que debe preparar la tarjeta SD y grabar datos (nivel alto) o que debe vaciar el buffer y dejar de usar la tarjeta SD (nivel bajo)

#define ESPERA_REINTENTO_ERROR 3000 // Esperar unos segundos antes de reintentar después de detectar un error

#define ESPERA_MUESTREO_UVI 240000 // Intervalo entre grabaciones del valor del UVi (4 minutos a petición de Juan 4*60*1000 ms)

#define COEFICIENTE_VOLTAJE 1.07526881720430107527 // 1100/1023≃1.07526881720430107527 La lectura máxima es de 1023 que corresponde a 1100 mV

#include <SD.h> // La librería SD estándar de Arduino

File informe_uvi;

char nombre_archivo[13]; // buffer para el nombre del documento con el informe UVi

char buffer_numero_archivo[4]; // buffer con el número (sufijo) del documento

unsigned int numero_archivo=0; // Número de archivo que se busca para, si no existe, usarlo como sufijo del nombre

boolean informe_activo=false; // No se están grabando datos en la tarjeta SD

boolean nuevo_estado_informe; // Lectura actual del conmutador de la tarjeta SD

unsigned long cronometro; // Tiempo entre grabaciones del índice UVi en la tarjeta SD

unsigned long contador_lecturas; // Número de lecturas tomadas entre grabaciones (para calcular el valor intermedio)

unsigned int lectura_sensor; // Valor entregado por el sensor GUVAS12SD

float total_lecturas=0.0; // Suma de los valores muestreados en una sesión

float media_lecturas; // Valor intermedio de los valores muestreados entre grabaciones

String registro_csv; // Datos que se graban en una línea del documento CSV (milisegundos (desde encendido) ,valor calculado, lecturas promediadas)

void setup()

{

#ifdef MODO_PRUEBAS

Serial.begin(9600); // Preparar el puerto serie

#ifdef __AVR_ATmega32U4__

while(!Serial);// Esperar a Arduino Leonardo

#endif

analogReference(INTERNAL); // Referencia interna de 1100 mV El GUVA-S12SD mide de 0 a 1170 mV que corresponde con el índice UV 11

lectura_sensor=analogRead(PIN_GUVAS12SD); // La primera lectura es incorrecta (normalmente cero)

pinMode(PIN_CS_SD,OUTPUT); // El pin al que realmente se conecta la tarjeta SD debe ser de salida para activarla (nivel bajo) o desactivarla (nivel alto)

digitalWrite(PIN_CS_SD,HIGH); // Desactivar la tarjeta SD

pinMode(PIN_CS_CONVENCIONAL,OUTPUT); // Puede que sea necesario usar como salida (o simplemente reservar) el pin que normalmente se utiliza para SPI por seguridad (si el verdadero no es el 10)

digitalWrite(PIN_CS_SD,HIGH); // Desactivar el dispositivo en el bus SPI habitual

while(!SD.begin(PIN_CS_SD)) // Reintentar hasta activar el lector de tarjetas SD (si no se consigue, no hay razón para seguir el programa)

{

#ifdef MODO_PRUEBAS

Serial.print("Error al inicializar el lector de tarjetas SD. Se reintenta en ");

Serial.print(ESPERA_REINTENTO_ERROR);

Serial.println(" ms.");

#endif

delay(ESPERA_REINTENTO_ERROR); // Esperar antes de reintentar

}

#ifdef MODO_PRUEBAS

Serial.println("Lector de tarjetas SD inicializado");

#endif

pinMode(PIN_INFORME_ACTIVO,OUTPUT); // Pin del LED de aviso de SD activada

digitalWrite(PIN_INFORME_ACTIVO,LOW); // Apagar el LED que informa de que se pueden estar grabando datos en la tarjeta

pinMode(PIN_CONMUTADOR_SD,INPUT);

}

void loop()

{

nuevo_estado_informe=digitalRead(PIN_CONMUTADOR_SD);

if(nuevo_estado_informe!=informe_activo) // Si ha cambiado el estado (ha cambiado la posición del conmutador)

{

if(nuevo_estado_informe) // Si el conmutador está en modo grabar (y antes no lo estaba)

{

itoa(numero_archivo++,buffer_numero_archivo,10);

strcpy(nombre_archivo,PREFIJO_ARCHIVO);

strcat(nombre_archivo,buffer_numero_archivo);

strcat(nombre_archivo,EXTENSION_ARCHIVO);

#ifdef MODO_PRUEBAS

Serial.println("Probando a usar el documento "+String(nombre_archivo));

#endif

}

while(SD.exists(nombre_archivo));

informe_uvi=SD.open(nombre_archivo,FILE_WRITE);

if(informe_uvi) // Si se ha conseguido preparar el documento…

{

informe_activo=true; // …cambiar el estado a activo

digitalWrite(PIN_INFORME_ACTIVO,HIGH); // Encender el LED para informar de que se pueden estar grabando datos en la tarjeta SD

contador_lecturas=0; // Empezar a contar lecturas entre grabaciones (para calcular el valor intermedio)

#ifdef MODO_PRUEBAS

Serial.println("Informe UVi activo");

#endif

cronometro=millis(); // (re)Iniciar el cronómetro para saber si ha pasado el tiempo entre grabaciones

}

else

{

#ifdef MODO_PRUEBAS

Serial.println("Se ha producido un error al tratar de crear el documento.");

Serial.print("Se reintentará dentro de ");

Serial.print(ESPERA_REINTENTO_ERROR);

Serial.println(" ms.");

#endif

delay(ESPERA_REINTENTO_ERROR); // Esperar antes de reintentar

}

else // Si el conmutador está en modo NO grabar (y antes no lo estaba)

{

informe_uvi.flush(); // Vaciar el buffer

informe_uvi.close(); // Cerrar el archivo

informe_activo=false; // Cambiar el estado a inactivo (no se graban datos en la tarjeta SD)

digitalWrite(PIN_INFORME_ACTIVO,LOW); // Apagar el LED que informa de grabación activa

#ifdef MODO_PRUEBAS

Serial.println("Informe UVi desactivado");

#endif

}

if(informe_activo) // Si la grabación está activa

{

if((unsigned long)(millis()-cronometro)>ESPERA_MUESTREO_UVI) // Si la grabación está activa y ha pasado el tiempo entre grabaciones sucesivas…

{

cronometro=millis(); // (re)Iniciar el cronómetro para saber si ha pasado el tiempo entre grabaciones

media_lecturas*=COEFICIENTE_VOLTAJE; // Corregir los valores tomados para que trabaje con el voltaje (más o menos coincide con un UVi decimal)

#ifdef MODO_PRUEBAS

Serial.print("Guardado el valor ");

Serial.print(media_lecturas);

Serial.print(" en ");

Serial.print(cronometro);

Serial.print(" ms (");

Serial.print(contador_lecturas);

Serial.println(" muestras)");

#endif

registro_csv=String(cronometro,DEC); // Componer la línea CSV (registro) con el tiempo,

registro_csv+=String(SEPARADOR_CSV); // un separador,

registro_csv+=String(media_lecturas,DEC); // Valor intermedio de las lecturas hasta el momento,

registro_csv+=String(SEPARADOR_CSV); // otro separador

registro_csv+=String(contador_lecturas,DEC); // y el número de muestras tomadas para calcular el valor intermedio (más de 1100000 en un Arduino Uno con intervalos de 4 minutos)

informe_uvi.println(registro_csv); // Grabar la línea CSV (el registro)

contador_lecturas=0; // Empezar a contar lecturas entre grabaciones (para calcular el nuevo valor intermedio)

}

else // Si no toca grabar, tomar una medida y actualizar el cálculo del valor intermedio

{

lectura_sensor=analogRead(PIN_GUVAS12SD); // leer el sensor

contador_lecturas++; // incrementar el número de lecturas realizadas

total_lecturas+=lectura_sensor;

media_lecturas=total_lecturas/contador_lecturas;

}

juan

3 agosto, 2016 | Reply

hola soy juan de nuevo me encanta pero me gustaría saber cuales son los materiales que voy a necesitar para la implementacion de este proyecto aparte del sensor,el arduino uno,un led,el reloj de tiempo real hay algo mas que tengo que comprar ??
- Víctor Ventura
  
  4 agosto, 2016 | Reply
  
  Hola, Juan.
  
  Si quieres hacer el montaje del artículo, básicamente necesitas los componentes de la foto, un lector de tarjetas SD para el programa del ejemplo y un reloj en tiempo real para la «mejora» (almacenar la fecha y la hora de la medida)
  
  El sensor de ultravioleta. Mejor un módulo, que incluye junto al sensor otros compoentes pasivos que puedas necesitar.
  
  Una placa (compatible) Arduino. Mejor pequeña.
  
  5 LED de los colores correspondientes (mejor todos teñidos o todos transparentes, pero con luz de color)
  
  5 resistencias que correspondan a la tensión y corriente de salida de la placa Arduino elegida y de la intensidad de luz deseada (alta, que es para exteriores)
  
  Entre 100 Ω y 330 Ω y un cuarto de vatio. Menor tensión menor resistencia, mayor iluminación menor resistencia
  
  Una batería. Te recomiendo una de las de teléfono móvil que entregan 3,7 V (seguro que tienes alguna muerta de risa en un cajón)
  
  Un cargador de batería. Dependiendo de la alimentación de la placa Arduino, puedes necesitar también aumentar la tensión entregada por la batería, en tal caso te recomiendo que uses un módulo de los que incluyen ambas cosas (y además protegen la batería) que cuesta igual (más o menos) y minimiza el montaje.
  
  Te recomiendo un par de interruptores o conmutadores para el encendido y la carga, aunque puedes hacerlo con un conmutador de dos posiciones (tres terminales, uno común que el conmutador conecta con uno u otro de los restantes según cambie su posición)
  
  Si quieres hacer el montaje del ejemplo del comentario necesitas añadir un módulo lector de tarjetas SD para Arduino (mejor MicroSD) y la correspondiente tarjeta. Si optas por un módulo (es mi consejo para ti) incluirá los componentes que necesite para conectar directamente a la placa Arduino (debes buscar que la alimentación de uno y otro sean compatibles). Por si necesitas más información que la del ejemplo, en el blog hay un artículo que explica cómo almacenar datos desde Arduino hasta una tarjeta SD
  
  Si quieres añadir un RTC, necesitarás el módulo correspondiente. Te recomiendo el reloj en tiempo real DS3231, que suele incluir espacio para su propia batería que durará más que la del montaje. En el blog hay varios artículos sobre cómo controlar desde Arduino el RTC DS3231
  
  Si no te ves muy suelto con esto, te aconsejo que pidas ayuda en una tienda de electrónica cercana. No sé en tu país, mi experiencia en España es que están muy preparados y encantados de ayudar; suele ser una ocasión para aprender un montón. Son pocos componentes, pedirlos fuera te va a ahorrar poco y un pedido al extranjero en agosto (siempre refiriéndome a España) puede significar que llegue a final de septiembre.
CAMEN

20 agosto, 2016 | Reply

ESTIMADO VICTOR:
MUCHAS GRACIAS POR LA INFORMACIÓN TAN CLARA QUE PRESENTAS A TRAVÉS DE TU PAGINA, ME HA SIDO DE GRAN AYUDA PARA EL TRABAJO QUE TENIA QUE PRESENTAR MI HIJO EN EL COLEGIO EN UNA FERIA DE CIENCIAS SOBRE LOS SEMÁFOROS DE RADIACIÓN UV Y PREVIO A ELLO TENIA QUE INVESTIGAR SOBE LOS RAYOS ULTRAVIOLETA Y COMO SE ELABORAN ESTOS EQUIPOS , LA VERDAD YO NO COMPRENDO MUCHO SOBRE ESTOS TEMAS PERO ME PARECIÓ MUY INTERESANTE.
ESTEREMOS AL PENDIENTE DE TUS SIGUIENTES PUBLICACIONES. BENDICIONES!!!
- Víctor Ventura
  
  20 agosto, 2016 | Reply
  
  Pues muchas gracias, me alegra ser de utilidad; espero que lo próximo que publique también te guste 🙂 ¡Hasta pronto!
Jorge

1 septiembre, 2016 | Reply

Muchas gracias por tu respuesta, está muy bien explicado el uso de este sensor. Yo estoy trabajando en una monografía donde en una de sus partes tengo que construir un solmáforo y la información que brindas es justo lo que andaba buscando para este sensor. Un saludo desde Nicaragua
- Víctor Ventura
  
  1 septiembre, 2016 | Reply
  
  Hola, Jorge.
  
  Me alegro mucho de que te sirva el artículo.
  
  ¡Otro saludo de vuelta para Nicaragua! ¡Te espero pronto en polaridad.es!
Paul

24 septiembre, 2016 | Reply

Hola Victor, deseo usar el sensor uvm30a permanentemente a la intemperie, utilize varios vidrios o lentes o cristales transparentes para poder protegerlo del polvo y lluvia pero veo que el indice uv medido baja en comparación sin lente.
Asi que opte por ponerlo sobre la base y cubrirlo con silicona transparente para protegelo dejando el sensor(guva-s12d color blanco) solo al aire ya que necesito entregarlo.
Por favor como podría proteger al sensor uvm30a para usarlo permanente a la intemperie o hay un cristal vidrio o lente? O esta bien mi solución?
- Víctor Ventura
  
  24 septiembre, 2016 | Reply
  
  Hola, Paul.
  
  Los sensores de luz se fabrican pensando en que es muy probable que queden detrás de un cristal que los proteja (puedes leer en muchas hojas de datos cosas como que se «comportan bien» detrás de un cristal)
  
  El problema no es tanto que el índice se reduzca (¿Es que se te reduce muchísimo? Danos datos, por favor), el problema serio es que el índice no se reduzca de manera proporcional detrás del cristal. Si se reduce de manera predecible es cuestión de corregir el programa, para reflejarlo, haciendo pruebas con y sin cristal (si nos das datos concretos a lo mejor puedo ayudarte con eso). Por desgracia, los valores menores se recortarán pero en el caso de la radiación ultravioleta no es un problema muy importante ya que esos valores son los que se miden con menor precisión y suelen ser los que menos importan en las aplicaciones finales.
  
  Mi principal problema con todos los sensores a la intemperie, especialmente si les da el sol directamente (los que necesitan los de luz), es que se terminan por destruir. Es decir, hay que contar que el propio sensor es un componente fungible y preparar el montaje para sustituirlo cada cierto tiempo (al segundo año es razonable).
  
  Considerado el sensor como un consumible, yo optaría por dejarlo al aire sin protección. Lógicamente el resto de los componentes sí necesitarán protección. Lo de la silicona (que también se destruirá) me parece una solución aceptable, la mejor si es una producción muy pequeña, un dispositivo único ad hoc o un prototipo.
  
  Gracias por participar en polaridad.es, contar tu experiencia nos ayuda a aprender 🙂
- Matias
  
  5 enero, 2019 | Reply
  
  Paul, Victor, han podido determinar cual es la mejor forma de trabjar con estos sensores a la intemperie? he probado con algunos cristales y acrilicos pero sucede lo que ya han comentado. He visto estos sensores que ya vienen protegidos (https://www.digikey.com/es/datasheets/vishay-semiconductor-opto-division/vishay-semiconductor-opto-division-veml6075).
  He notado que tambien varia mucho la medicion segun la inclinacion del sol respecto al sensor, han experimentado alguna solucion para esto?
aldair

14 octubre, 2016 | Reply

hola victor.
deseo utilizar un LCD para la salida reemplazando a los leds y asi que me de la medicion uv como puedo reemplazar la programacion para implementar al arduino. Por favor es mi proyecto de mediciones Gracias.
- Víctor Ventura
  
  14 octubre, 2016 | Reply
  
  Hola, Aldair.
  
  No es difícil encontrar información sobre cómo utilizar una LCD desde Arduino pero yo todavía no he publicado nada al respecto 🙁 Todo llegará.
  
  Por si te sirve para tu proyecto, sí que he publicado información sobre cómo usar pantallas con números de LED de 7 segmentos desde Arduino, por ejemplo, el MAX7219 y el MAX7221 (controladores SPI de pantallas LED de 8 dígitos de 7 segmentos) o el TM1637 (controlador de un display LED de hasta 6 dígitos de 7 segmentos).
  
  ¡Suerte con tu proyecto y gracias por participar en polaridad.es!
Patrick

25 noviembre, 2016 | Reply

Hola Victor.
Muchas gracias por la informacion, por favor si podria implementar al programa para la comunicacion via ethernet y asi tener los valores en una pagina web.
- Víctor Ventura
  
  25 noviembre, 2016 | Reply
  
  Hola, Patrick.
  
  Los tres componentes que planteas (① lectura del sensor ultravioleta VEML6070 o del sensor ultravioleta GUVA-S12SD (el del módulo UVM30A), ② la conexión Ethernet TCP con Arduino (incluyendo la conexión del ENC28J60) y ③ la construcción de un servidor web para la IoT o incluso cómo hacer gráficos web de los sensores conectados a la IoT) están explicados en los artículos que te enlazo, así que, si quieres ponerte manos a la obra ahí tienes algunas pistas para empezar. De todas formas, parece que es un tema que tiene su público, por lo que no descarto hacer algún ejemplo cuando tenga un rato así que ¡vuelve pronto por polaridad.es!
  
  ¡Hasta pronto!
Ibrahin

25 noviembre, 2016 | Reply

Estimado Victor:
exelente informacion si podria realizar el programa para enlazarlo via ethernet seria de mucha ayuda gracias por su respuesta

Víctor Ventura

25 noviembre, 2016 | Reply

Como parece que hay muchos lectores interesados, os he preparado un ejemplo de cómo se podría mostrar el índice UV usando un servidor web basado en Arduino con una conexión Ethernet.

Después conectar todo y alimentarlo (mostrar también la consola serie es de ayuda para monitorizar el funcionamiento), hay que usar un navegador web en un PC que esté en la misma red que la conexión Ethernet de Arduino y escribir en la barra de direcciones 192.168.1.252

Si la red no es la del ejemplo (192.168.1.X) habrá que cambiar el valor de la variable ip.

Espero que os dé una idea para hacer vuestro proyecto ¡Suerte!

#define PIN_GUVAS12SD A0 // Pin al que se conecta el módulo con el UVM30A
#define CANTIDAD_INDICES_UV 11
String color[CANTIDAD_INDICES_UV+1]={"1C0","1C0","1C0","FE0","FE0","FE0","FA0","FA0","F11","F11","F11","E1B"}; // Colores de los índices para el fondo de la página web

#include <SPI.h>
#include <Ethernet.h>

byte mac[]={0x12,0x34,0x56,0x78,0x9A,0xBC}; // Dirección MAC inventada
IPAddress ip(192,168,1,252); // Dirección IP arbitraria en el rango 192.168.1.
EthernetServer servidor_web(80); // El puerto por defecto del HTTP es el 80
EthernetClient cliente_web;
char lectura_ethernet;
char lectura_anterior;
byte indice;

void setup()
{
  Serial.begin(115200);
  while(!Serial);
  Ethernet.begin(mac,ip);
  servidor_web.begin();
  Serial.println(F("Servidor web iniciado"));
  analogReference(INTERNAL); // Referencia interna de 1100 mV El GUVA-S12SD mide de 0 a 1170 mV que corresponde con el índice UV 11
  analogRead(PIN_GUVAS12SD); // La primera lectura es incorrecta (normalmente cero)
}

void loop()
{
  cliente_web=servidor_web.available();
  if(cliente_web)
  {
    lectura_anterior=0; // Cualquier carácter que no sea \n para evitar malinterpretar el final del texto
    Serial.println(F("Se ha conectado un cliente")); // Monitorizar que el cuando se conecta el cliente (el navegador web)
    Serial.println(F("Datos enviados por el cliente:\n")); // Monitorizar la información que envía el cliente (el navegador web)
    while(cliente_web.connected()) // Cuando el cliente (el navegador web) se conecte
    {
      indice=indice_uv(); // Leer el sensor
      if(cliente_web.available()) // Si llegan datos desde el cliente (el navegador web)
      {
        lectura_ethernet=cliente_web.read(); // Leer una letra del texto enviado por el cliente
        Serial.print(lectura_ethernet); // Mostrar la letra recibida del cliente para monitorizar el funcionamiento
        if(lectura_ethernet=='\r'&&lectura_anterior=='\n') // Si llega CR y antes había llegado LF se interpreta como una línea en blanco
        {
          cliente_web.flush(); // Como la línea en blanco marca el final de la petición HTTP ignorar el resto del texto que mande el cliente
          cliente_web.println(F("HTTP/1.1 200 OK")); // Cabecera de petición aceptada correctamente
          cliente_web.println(F("Content-Type: text/html")); // Cabecera de tipo de respuesta enviada (texto en formato HTML)
          cliente_web.println(F("Connection: close")); // Al terminar, cerrar la conexión para liberar al servidor lo antes posible
          cliente_web.println(); // Una línea en blanco para indicar el final de las cabeceras y el comienzo del código HMTML
          cliente_web.print(F("<DOCTYPE html>")); // Es un documento HTML
          cliente_web.print(F("<html lang=\"es\">")); // El texto del HTML está en español
          cliente_web.print(F("<head>"));
          cliente_web.print(F("<meta charset=\"utf-8\">")); // La codificación del texto es UTF-8 (importante para los caracteres no-ASCII como las tildes)
          cliente_web.print(F("<meta name=\"viewport\" content=\"width=device-width,height=device-height,initial-scale=1.0,user-scalable=no,minimum-scale=1.0,maximum-scale=1.0\">")); // ventana para que se muestre al tamaño correspondiente en un dispositivo móvil y la escala sea fija
          cliente_web.print(F("<title>Índice UV</title>")); // Título de la página (para la ventana del navegador)
          cliente_web.print(F("</head>"));
          cliente_web.print(F("<body style=\""));
          cliente_web.print(F("background-color:#")); // Color de fondo de la página (el que corresponde con el índice UV)
          cliente_web.print(color[indice]);
          cliente_web.print(F(";\">"));
          cliente_web.print(F("<div style=\""));
          cliente_web.print(F("display:table;"));
          cliente_web.print(F("width:100%;"));
          cliente_web.print(F("height:100%;"));
          cliente_web.print(F("\">"));
          cliente_web.print(F("<div style=\""));
          cliente_web.print(F("display:table-cell;"));
          cliente_web.print(F("vertical-align:middle;"));
          cliente_web.print(F("text-align:center;")); // Centrar el texto
          cliente_web.print(F("font-size:24px;"));
          cliente_web.print(F("\">"));
          cliente_web.print(F("El índice UV es "));
          cliente_web.print(indice); // Valor numérico del índice UV
          cliente_web.print(F("</div>"));
          cliente_web.print(F("</div>"));
          cliente_web.print(F("</body>"));
          cliente_web.print(F("</html>"));
          cliente_web.stop(); // Cerrar la conexión para liberar al servidor
        }
        lectura_anterior=lectura_ethernet; // Recordar la lectura anterior para detectar una línea en blanco y saber cuándo termina la petición HTTP
      }
    }
    Serial.println(F("\nEl cliente se ha desconectado")); // Avisar de que se ha cerrado la conexión para monitorizarla
  }
}

byte indice_uv()
{
  static const int valor_indice_uv[CANTIDAD_INDICES_UV]={210,295,378,467,563,646,738,818,907,1003,1022}; // De 1 a 11
  unsigned int lectura_sensor=analogRead(PIN_GUVAS12SD);
  boolean buscando_indice_uv=true;
  byte indice=CANTIDAD_INDICES_UV;
  while(buscando_indice_uv&&indice>0)
  {
    indice--;
    if(lectura_sensor>valor_indice_uv[indice])
    {
      buscando_indice_uv=false;
    }
  }
  return indice;
}

100

101

#define PIN_GUVAS12SD A0 // Pin al que se conecta el módulo con el UVM30A

#define CANTIDAD_INDICES_UV 11

String color[CANTIDAD_INDICES_UV+1]={"1C0","1C0","1C0","FE0","FE0","FE0","FA0","FA0","F11","F11","F11","E1B"}; // Colores de los índices para el fondo de la página web

#include <SPI.h>

#include <Ethernet.h>

byte mac[]={0x12,0x34,0x56,0x78,0x9A,0xBC}; // Dirección MAC inventada

IPAddress ip(192,168,1,252); // Dirección IP arbitraria en el rango 192.168.1.

EthernetServer servidor_web(80); // El puerto por defecto del HTTP es el 80

EthernetClient cliente_web;

char lectura_ethernet;

char lectura_anterior;

byte indice;

void setup()

{

Serial.begin(115200);

while(!Serial);

Ethernet.begin(mac,ip);

servidor_web.begin();

Serial.println(F("Servidor web iniciado"));

analogReference(INTERNAL); // Referencia interna de 1100 mV El GUVA-S12SD mide de 0 a 1170 mV que corresponde con el índice UV 11

analogRead(PIN_GUVAS12SD); // La primera lectura es incorrecta (normalmente cero)

}

void loop()

{

cliente_web=servidor_web.available();

if(cliente_web)

{

lectura_anterior=0; // Cualquier carácter que no sea \n para evitar malinterpretar el final del texto

Serial.println(F("Se ha conectado un cliente")); // Monitorizar que el cuando se conecta el cliente (el navegador web)

Serial.println(F("Datos enviados por el cliente:\n")); // Monitorizar la información que envía el cliente (el navegador web)

while(cliente_web.connected()) // Cuando el cliente (el navegador web) se conecte

{

indice=indice_uv(); // Leer el sensor

if(cliente_web.available()) // Si llegan datos desde el cliente (el navegador web)

{

lectura_ethernet=cliente_web.read(); // Leer una letra del texto enviado por el cliente

Serial.print(lectura_ethernet); // Mostrar la letra recibida del cliente para monitorizar el funcionamiento

if(lectura_ethernet=='\r'&&lectura_anterior=='\n') // Si llega CR y antes había llegado LF se interpreta como una línea en blanco

{

cliente_web.flush(); // Como la línea en blanco marca el final de la petición HTTP ignorar el resto del texto que mande el cliente

cliente_web.println(F("HTTP/1.1 200 OK")); // Cabecera de petición aceptada correctamente

cliente_web.println(F("Content-Type: text/html")); // Cabecera de tipo de respuesta enviada (texto en formato HTML)

cliente_web.println(F("Connection: close")); // Al terminar, cerrar la conexión para liberar al servidor lo antes posible

cliente_web.println(); // Una línea en blanco para indicar el final de las cabeceras y el comienzo del código HMTML

cliente_web.print(F("<DOCTYPE html>")); // Es un documento HTML

cliente_web.print(F("<html lang=\"es\">")); // El texto del HTML está en español

cliente_web.print(F("<head>"));

cliente_web.print(F("<meta charset=\"utf-8\">")); // La codificación del texto es UTF-8 (importante para los caracteres no-ASCII como las tildes)

cliente_web.print(F("<meta name=\"viewport\" content=\"width=device-width,height=device-height,initial-scale=1.0,user-scalable=no,minimum-scale=1.0,maximum-scale=1.0\">")); // ventana para que se muestre al tamaño correspondiente en un dispositivo móvil y la escala sea fija

cliente_web.print(F("<title>Índice UV</title>")); // Título de la página (para la ventana del navegador)

cliente_web.print(F("</head>"));

cliente_web.print(F("<body style=\""));

cliente_web.print(F("background-color:#")); // Color de fondo de la página (el que corresponde con el índice UV)

cliente_web.print(color[indice]);

cliente_web.print(F(";\">"));

cliente_web.print(F("<div style=\""));

cliente_web.print(F("display:table;"));

cliente_web.print(F("width:100%;"));

cliente_web.print(F("height:100%;"));

cliente_web.print(F("\">"));

cliente_web.print(F("<div style=\""));

cliente_web.print(F("display:table-cell;"));

cliente_web.print(F("vertical-align:middle;"));

cliente_web.print(F("text-align:center;")); // Centrar el texto

cliente_web.print(F("font-size:24px;"));

cliente_web.print(F("\">"));

cliente_web.print(F("El índice UV es "));

cliente_web.print(indice); // Valor numérico del índice UV

cliente_web.print(F("</div>"));

cliente_web.print(F("</body>"));

cliente_web.print(F("</html>"));

cliente_web.stop(); // Cerrar la conexión para liberar al servidor

}

lectura_anterior=lectura_ethernet; // Recordar la lectura anterior para detectar una línea en blanco y saber cuándo termina la petición HTTP

}

Serial.println(F("\nEl cliente se ha desconectado")); // Avisar de que se ha cerrado la conexión para monitorizarla

}

byte indice_uv()

{

static const int valor_indice_uv[CANTIDAD_INDICES_UV]={210,295,378,467,563,646,738,818,907,1003,1022}; // De 1 a 11

unsigned int lectura_sensor=analogRead(PIN_GUVAS12SD);

boolean buscando_indice_uv=true;

byte indice=CANTIDAD_INDICES_UV;

while(buscando_indice_uv&&indice>0)

{

indice--;

if(lectura_sensor>valor_indice_uv[indice])

{

buscando_indice_uv=false;

}

return indice;

}

Arist

26 noviembre, 2016 | Reply

¿Por qué puede ser que en mi smartphone se ve muy chico y en mi laptop se ve normal?

Gracias por el programa.
- Víctor Ventura
  
  26 noviembre, 2016 | Reply
  
  Porque tu teléfono tiene mucha resolución 😀
  
  Es por el viewport. He cambiado el código (línea 53) para que se vea en un dispositivo móvil a un tamaño equiparable al de un PC (para que considere que la resolución de la pantalla de un teléfono es mucho mayor, los píxeles son mucho más pequeños) y para que se centre en vertical (en lugar de dejar cierto margen) De todas formas, puedes modificar la línea 69 y sustituir «24px» por un tamaño mayor, si lo necesitas.
  
  Gracias por participar en polaridad.es

Cesar Augusto Tapia

7 marzo, 2017 | Reply

Muy buena explicacion
excelente pagina
- Víctor Ventura
  
  7 marzo, 2017 | Reply
  
  ¡Gracias! 🙂
EDISON

24 marzo, 2017 | Reply

Buena pagina e informacion
Tengo varias consultas que enviare
Gracias por compartir tu conocimiento
Edison
Jeftd

24 mayo, 2017 | Reply

Habrá una diferencia si solo uso el guva-s12sd, esque se me dificulta obtener el UVM 30a
- Víctor Ventura
  
  24 mayo, 2017 | Reply
  
  Poca cosa. El UVM30A es uno de los módulos que incorporan el sensor GUVA-S12SD y un mínimo de electrónica pero para el software con que podrías manejarlo te sirve lo que se dice en el artículo.
  
  Un saludo y gracias por visitar polaridad.es
  - Jeftd
    
    24 mayo, 2017 | Reply
    
    Entonces el solmaforo podría funcionar solamente con el guva-s12sd?
Raul

25 mayo, 2017 | Reply

Estimados me pueden indicar como puedo sensar y mostrar un arreglo de lamparas cuando falla una de ellas, si cada una de ellas tiene un interruptor que cuando esta encendida esta cerrado.
Clemente

1 junio, 2017 | Reply

Hola,
Primero de todo, gracias por el manual, me ha ayudado mucho a hacer lo que quería, pero usando una pantalla LCD conectada por i2c.
Yo también había pensado en ponerle una batería, ¿Podrías indicar que batería y regulador has elegido tú?
Muchas gracias
- Víctor Ventura
  
  2 junio, 2017 | Reply
  
  Hola, Clemente.
  
  He hecho varios montajes de este tipo con diferentes baterías. El que hice para las pruebas del artículo utilizaba una batería de litio de 3V7 reciclada de otro equipo, creo recordar que perteneció a un receptor de GPS pero puedes encontrarla en infinidad de dispositivos, es el tipo más habitual. En este casó no utilicé regulador y jugué con la tolerancia del MCU.
  
  Para hacer algo pequeño, con el mínimo de LED, puedes usar un AMS1117-5 o un AMS1117-3.3 (dependiendo del MCU, el resto es más flexible) o los correspondientes LM1117.
  
  Gracias por participar en polaridad.es
indira

9 junio, 2017 | Reply

Hola, si deseo ocupar un sensor ML8511, ¿como seria su programación? ¿cambia mucho?
- Víctor Ventura
  
  9 junio, 2017 | Reply
  
  Hola, Indira.
  
  La idea general según la cual se usa el ML8511 es la misma que la que explico en este artículo.
  
  La diferencia entre el uso de uno y otro es que el sensor GUVA-S12SD tiene una respuesta entre 0 y algo más un voltio mientras que el ML8511 tiene una respuesta entre cero y algo más dos voltios y medio, así que tendrás que cambiar la tabla de valores consultando las especificaciones (en la datasheet) del ML8511.
  
  El ML8511 se está empezando a ser tan popular como lo fue en su momento el GUVA-S12SD (o más) así que estoy pensando publicar algún código adaptado a este sensor de radiación UV, pero no será pronto, que ando regular de tiempo 🙁
  
  ¡Suerte con tu proyecto y gracias por participar en polaridad.es!
Antonio

20 julio, 2017 | Reply

Hola Victor:
Excelente artículo.
Serías tan amable de decirme si conoces algún sensor que mida por encima de los 380 mn.
Muchas gracias por todo.
- Víctor Ventura
  
  20 julio, 2017 | Reply
  
  Hola, Antonio.
  
  Los sensores de luz ultravioleta que conozco empiezan a filtrar desde los 350 nm y se supone que son insensibles entorno a los 400 nm.
  
  Se me ocurre que podrías complementar la toma de datos con algún sensor de luz ambiental aunque, al contrario, lo habitual es que empiecen a ser sensibles entorno a los 400 nm, por lo que te quedará una pequeña ventana fuera de rango.
  
  Espero que eso te ayude un poco.
  
  Gracias por visitar polaridad.es
Carlos Alejandro

29 agosto, 2017 | Reply

Buenas noches, me gusto mucho la idea, pero me ha resultado un poco difícil el conectar los sensores. ¿Como seria el diagrama completo usando el lector de tarjetas?
José María

21 octubre, 2017 | Reply

Hola Víctor;
En primer lugar quiero agradecerte tu proyecto ya que hay muy poco en Español! Todo está muy claro y tus respuestas son muy precisas.
He realizado el montaje y ya he hecho las mediciones y se me presentan algunas dudas.
Utilicé el mismo sensor en un arduino uno pero el código que utilicé es uno básico y leo del serial plotter la salida de los mv.
El tema es que he medido ya unas cinco veces a mediodía y sin nubes y el valor en mv no supera los 250 mv, el tema es que el servicio meteorológico da un valor de índice 7. Entonces según lo que interpreté yo estoy midiendo 250 que asumo será un valor entre 1 y 2 pero el servicio meteorológico les da 7 a 8.
No se si estoy midiendo mal (el sensor siempre lo pongo perpendicular al sol) o si los 250 mv que devuelve el sensor hay que interpretarlos diferente. Te dejo el código sencillo que utilizo ya que podría estar mal el código también.
Un abrazo y nuevamente profundamente agradecido
José María desde Argentina

/*
# This Sample code is for testing the UV Sensor .
#Connection:
VCC-5V
GND-GND
OUT-Analog pin 0
*/

void setup()
{
Serial.begin(9600);// open serial port, set the baud rate to 9600 bps
}
void loop()
{
int sensorValue;
sensorValue = analogRead(0);//connect UV sensors to Analog 0
Serial.println(sensorValue);//print the value to serial
delay(200);
}
Marcos P Sosa

24 noviembre, 2017 | Reply

hola gracias por tu aporte esta super, una pregunta para el sistema del solmaforo la salida es un cero o 5 volt. tengo mis dudas, me gustaria que solo me bote 5 volt para hacerfuncionar en paralelo otros relay y hacer funciones … porfa si pudieras ayudarme
Rodrigo

27 noviembre, 2017 | Reply

Hola, muy buena informacion, yo estoy trabajando con otro modulo uv-sens pero no se si podrias ayudarme con la formula, lo que deseo es hacer la medicion pero en nanometros (nm), es para medir la radiacion de un fluorescente uv, ando algo perdido con esto… agradeceria tu apoyo.
Jordan

23 enero, 2018 | Reply

Amigo Buenos Días

Es un excelente proyecto el que hiciste para el solmaforo
pero tengo una complicación hay alguna manera de implementar un led rbg
para hacer mas llamativo el proyecto.
Gracias de antemano.

Saludos desde Ecuador
Daniel

3 mayo, 2018 | Reply

Me pueden ayudar con el costo de un sensor de irradiacion por favor. El proyecto en el cual quiero implementar dicho sensor de de baja potencia.

De ante mano muchas gracias.
Saludos
Alejandro

11 mayo, 2018 | Reply

Quisiera comprender este mismo proyecto con un sensor UV ML1185
Arturo

28 mayo, 2018 | Reply

Buenos días Victor,
podrías orientarme sobre alguna empresa o entidad que realice mediciones de UV.
Necesitamos saber el grado de protección que proporcionan ciertos tejidos y que además una empresa lo certifique.
Muchas gracias,
un cordial saludo
- Víctor Ventura
  
  28 mayo, 2018 | Reply
  
  Hola, Arturo.
  
  Lo siento, no puedo recomendarte ninguna empresa para lo que necesitas.
  
  Gracias por visitar el blog.
sergio muñoz

10 junio, 2018 | Reply

Hola, vengo siguiendo tu página ya que me ayuda en un proyecto de investigación, estoy siguiendo los pasos y esto pero quisiera saber cómo es que se convierte esta intensidad UV al índice UV, o sea que fórmula o que instrumentos son los que miden o convierten, agradecería la respuesta y muy buena tu información.
Freddy

20 junio, 2018 | Reply

Buenos tardes,

estoy realizando un proyecto de WSN para medir radiación solar.
como podria conectarlo a travez de WIFI a una RASPBERRY PI?

Gracias
cristina

22 junio, 2018 | Reply

Hola, muy bueno tu articulo, estoy implemententado este proyecto pero a la salida que active 5 reles para que enciendan luces a 110v, a parte tengo una pantalla y un sensor de temperatura, intente poner los reles para cada salida de medidor UV y no hace nada, pdrias ayudame por favor
felipe

10 julio, 2018 | Reply

la intensidad UV como se convierte a indice UV ?
CLAUDIA

7 septiembre, 2018 | Reply

BUENAS NOCHES ESQUE QUIERO HACER UN BRAZALETE MEDIDOR ULTRAVIOLETA QUIERO SABER COMO SERIA LA PROGRAMACION SI NECESITO UN DISPLAY OLED 128X32
Adriana

11 septiembre, 2018 | Reply

Hola Victor!! Muy buenos tus articulos. Me gustaria saber si publicarás alguno referente al Sensor UV UV ML1185.
- Víctor Ventura
  
  11 septiembre, 2018 | Reply
  
  Gracias, Adriana.
  
  Desde luego que entra en mis planes, incluso compré algunos kit para probarlo en distintas plataformas. Pero, si te refieres a si lo publicaré próximamente, me temo que no porque no creo que tenga ni un rato libre hasta casi fin de año 🙁
  
  En cualquier caso, la idea del blog es que cualquiera pudiera solicitar o aportar información; no solo yo. Imagínate el tiempo que llevaría contestar (como merece) cada comentario o correo que me llega. Te propongo que preguntes lo que necesites o escribas lo que conoces de este sensor (o de lo que quieras), a ver si otros lectores también se animan y te ayudan o aprovechan lo que tú sepas 🙂
  
  ¡Hasta pronto!
hector galindo

6 octubre, 2018 | Reply

guau que buena informacion gracias me interesa controlar una medicion de luz ultravioleta por medio de aplicar unaperaje de un lado y ver cuanta cantidad de luz uv llega de el otro lado como un amperimetro y medir si el polarizado reduced la cantidad de rayos uv
Héctor

26 noviembre, 2018 | Reply

Me gustaría saber cómo sería el programa si se usa el ml8511
Cesar Torres

4 diciembre, 2018 | Reply

Hola primero que nada muchas gracias por compartir y hacer público todo esto :), quería preguntarle, ¿cree que se presente algún problema si sólo se utiliza el sensor Guva-s12sd pero un módulo diferente al uvm30a?
Rodrigo Ojeda

17 enero, 2019 | Reply

Hola, muy buesn post…
Me gustaría saber si el módulo UvM30A necesita ser orientado al sol dependiendo de la hora….
Gracias.
- Víctor Ventura
  
  18 enero, 2019 | Reply
  
  Hola, Rodrigo.
  
  Normalmente se utiliza para saber la cantidad de radiación que incide en un sitio en cada momento del día. En tal caso, como es lógico, no es necesario moverlo.
  
  Sería necesario (re) orientarlo si la medida que quieres tomar es más global (para estimar la de una zona amplia, por ejemplo)
  
  En cualquier caso, considera que la medida dependerá siempre del lugar y del momento. No podrás, por ejemplo, evitar la variación que producirá una nube que puede no «hacer sombra» en otro sitio relativamente cercano.
  
  Un saludo y gracias por visitar el blog 🙂
eder valencia

12 abril, 2019 | Reply

que tal victor, antes que nada deseo felicitarte por tu proyecto y la manera en la que lo explicas ya que esta de 10,tengo una duda haber si me pudieras ayudar, si no quisiera usar leds como semaforo y en su lugar quisiera usar una pantalla tipo nextion para desplegar los datos, seria muy complicado?? un fuerte abrazo desde mexico y saludos!!
gustavo

15 mayo, 2020 | Reply

Hola . he encontrado tu proyecto y me es muy pero muy util . estoy haciendo con el ULm30A un detector obvio de UV pero mi interes es que pueda disernir segun los milivolt que da como resultado que frecuencia en nanometros estoy midiendo, es posible esto . podrias ayudarme ? desde ya muchas gracias ejemplo 50mv son 390nm y 1000 mv supongo que 240nm y puedo disernir entre UVa UVB y UVC

Radiación ultravioleta (UV)

Índice UV (ultravioleta)

Medida de la radiación ultravioleta y cálculo del índice UV

Usar el fotodiodo Schottky GUVA-S12SD del módulo UVM30A con Arduino

Implementar el método en un semáforo de índice UV

Últimas publicaciones de Víctor Ventura

58 Respuestas

Deja un comentario Cancelar respuesta