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.
Búsqueda
Buscar
Entradas
recientes
Qué es la Internet de las Cosas
(IoT)
Librería Hardware I/O para
Processing
Instalar GNU/Linux en un SBC para
monitorización y control
electrónico
Comunicaciones Bluetooth con
Processing para Android y la
librería Ketai
Programación para Android con
Processing
Comunicaciones serie con
Processing
Processing
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 O2 en dos átomos O, muy reactivos, que forman el ozono O3 al reaccionar cada uno con
otra molécula de O2.
Í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.
Conexión Bluetooth con un módulo
HC-06
MAX30100 sensor de latido de
corazón y oxímetro de pulso con
comunicaciones I2C para wearables
de salud
Programar un módulo wifi ESP8266
desde el IDE de Arduino
Programar el SoC wifi ESP8266
Librería para el envío de correo
electrónico desde Arduino con un
módulo Wifi ESP8266
Operaciones básicas sobre un
módulo wifi ESP8266 desde Arduino
Librería de codificación Base64
con Arduino
MLX90614. Termómetro sin
contacto por infrarrojos con
comunicaciones SMBus.
MAX6675. Conversor analógicodigital para sondas de termopar K
con compensación de unión fría y
comunicaciones SPI.
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
17/11/20 9=04
Página 1 de 22
Sensor de temperatura I2C LM75
Medida electrónica de la
temperatura
Sensor de color TCS3472 con
conexión I2C
MAX7219 y MAX7221,
controladores SPI de pantallas LED
de 8 dígitos de 7 segmentos
Ajustar la hora de un RTC (reloj
en tiempo real) con Arduino
ESP8266 ¿Qué módulo elegir?
Sensor de color I2C TCS3414
MCP23S17 Expansor de 16 bits de
puertos GPIO de entrada y salida y
conexión SPI
Sensor ultravioleta I2C VEML6070
Gráficas de estado de sensores
conectados a la Internet de las
cosas IoT
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.
Definir con CSS el aspecto de la
web de gráficos de sensores en la
IoT
Dibujar con SVG los gráficos de
datos de sensores conectados a la
Internet de las cosas (IoT)
Generar y modificar con
JavaScript los gráficos SVG de
datos de sensores conectados a la
IoT
Sensor de color TCS3200
BH1750. Sensor de luz ambiental
con bus I2C.
LDR: medir la luz con una
fotorresistencia
PCF8591 Conversor AD-DA de 8
bits I2C
PCF8574. Expansor I2C de 8 bits
de puertos GPIO digitales de
entrada y salida.
Sensor de radiación ultravioleta
con Arduino
Gestionar fecha y hora con el
módulo RTC DS3231 y Arduino
Medir distancias con ultrasonidos
Formato JSON
Acceder a la base de datos desde
el lenguaje de programación PHP
Preparar la base de datos MySQL o
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
17/11/20 9=04
Página 2 de 22
MariaDB
Almacenar datos en un servidor
web IoT usando peticiones HTTP
POST
Cómo almacenar los datos
obtenidos por los dispositivos de
la Internet de las cosas (IoT)
Comparando Arduino y el módulo
WiFi ESP8266
Medida de temperaturas en
Arduino con DS18B20 1-Wire
Asignar un nombre fijo al puerto
serie USB de Arduino
Modelos 2D y 3D y montaje del
vehículo de ayuda a la
rehabilitación del DCA
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.
Software del vehículo de ayuda a
la rehabilitación del DCA
Componentes del vehículo de ayuda
a la rehabilitación del DCA
Vehículo a control remoto para
rehabilitación de personas con
daño cerebral adquirido
Librería para manejar Arduino con
un mando a distancia por
infrarrojos
Librería Arduino para controlar un
display LED de dígitos de 7
segmentos con TM1637
TM1637 driver para display LED de
6 dígitos de 7 segmentos y teclado
de 16 pulsadores
Librería Arduino para
monitorización de la frecuencia
cardíaca con oxímetro de pulso
Principio de funcionamiento del
oxímetro para monitorización del
pulso
Librería de Arduino para consultar
fecha y temperatura del integrado
DS3231 por I2C
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
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
Reloj en tiempo real DS3231 con
comunicaciones I2C
Almacenamiento de datos en una
tarjeta SD conectada a Arduino
por SPI
Conexión de una tarjeta SD por
SPI a Arduino
Monitorización desde un ordenador
de sensores conectados a una
placa Arduino
Configuración de las
17/11/20 9=04
Página 3 de 22
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.
comunicaciones serie entre
Arduino y Python
Instalación de herramientas de
desarrollo para comunicaciones
serie en Python
Adquisición de datos y
administración desde ordenador de
dispositivos microcontrolados
Sincronización horaria con un
módulo ESP8266
Librería para hacer consultas HTTP
con un módulo WiFi ESP8266 y
Arduino
Conexión WiFi con un módulo
ESP8266
Usar componentes de superficie
en montajes de inserción
Conexión Ethernet TCP con
Arduino
Conexión Ethernet con el
integrado ENC28J60 de Microchip
Gestión del reloj watchdog (perro
guardián) 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.
Programación ISP de Arduino (en
sistema)
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
1
2
3
#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
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
17/11/20 9=04
Página 4 de 22
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#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.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#define
#define
#define
#define
PIN_GUVAS12SD A0 // Pin al que se conecta el módulo con el UVM30A
ESPERA_ENTRE_LECTURAS 100 // Leer cada 100 ms
ESPERA_ENTRE_PRESENTACIONES 30000 // Mostrar el índice cada 30 s
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);
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
17/11/20 9=04
Página 5 de 22
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59 }
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.
1
2
3
4
5
6
7
8
9
10
11
12
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
PIN_VERDE 2
PIN_AMARILLO 4
PIN_NARANJA 7
PIN_ROJO 8
PIN_MORADO 12
PIN_GUVAS12SD A0 // Pin al que se conecta el módulo con el UVM30A
ESPERA_ENTRE_LECTURAS 100 // Tomar una lectura del sensor de ultravioleta cada 100 ms
ESPERA_ENTRE_PRESENTACIONES 10000 // Cambiar el color del semáforo cada 10 segundos
CANTIDAD_INDICES_UV 11
CANTIDAD_COLORES_UV 5
unsigned int lectura_sensor;
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
17/11/20 9=04
Página 6 de 22
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
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
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.
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
17/11/20 9=04
Página 7 de 22
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!
Arduino, GUVA-S12SD, Índice UV, Módulo, Ultravioleta, UV, UVM-30A, UVM30A
Sobre el Autor
Últimas entradas
Víctor Ventura
Programador multimedia y web + IoT. Mejor con software libre.
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.
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.
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
17/11/20 9=04
Página 8 de 22
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!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#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 co
#define SEPARADOR_CSV "," // El separador usado para el formato CSV
#define
#define
#define
#define
#define
PIN_GUVAS12SD A0 // Pin al que se conecta el módulo con el UVM30A
PIN_CS_SD 4 // Pin usado para activar (CS/SS) la tarjeta
PIN_CS_CONVENCIONAL 10 // Pin usado normalmente para activar dispositivos SPI
PIN_INFORME_ACTIVO 8 // LED que indica que la tarjeta SD está preparada para grabar datos
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 b
#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 promediad
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
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 p
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
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
17/11/20 9=04
Página 9 de 22
54
delay(ESPERA_REINTENTO_ERROR); // Esperar antes de reintentar
55
}
56
#ifdef MODO_PRUEBAS
57
Serial.println("Lector de tarjetas SD inicializado");
58
#endif
59
pinMode(PIN_INFORME_ACTIVO,OUTPUT); // Pin del LED de aviso de SD activada
60
digitalWrite(PIN_INFORME_ACTIVO,LOW); // Apagar el LED que informa de que se pueden estar grabando datos en la tarjeta
61
pinMode(PIN_CONMUTADOR_SD,INPUT);
62 }
63
64 void loop()
65 {
66
nuevo_estado_informe=digitalRead(PIN_CONMUTADOR_SD);
67
if(nuevo_estado_informe!=informe_activo) // Si ha cambiado el estado (ha cambiado la posición del conmutador)
68
{
69
if(nuevo_estado_informe) // Si el conmutador está en modo grabar (y antes no lo estaba)
70
{
71
do
72
{
73
itoa(numero_archivo++,buffer_numero_archivo,10);
74
strcpy(nombre_archivo,PREFIJO_ARCHIVO);
75
strcat(nombre_archivo,buffer_numero_archivo);
76
strcat(nombre_archivo,EXTENSION_ARCHIVO);
77
#ifdef MODO_PRUEBAS
78
Serial.println("Probando a usar el documento "+String(nombre_archivo));
79
#endif
80
}
81
while(SD.exists(nombre_archivo));
82
informe_uvi=SD.open(nombre_archivo,FILE_WRITE);
83
if(informe_uvi) // Si se ha conseguido preparar el documento…
84
{
85
informe_activo=true; // …cambiar el estado a activo
86
digitalWrite(PIN_INFORME_ACTIVO,HIGH); // Encender el LED para informar de que se pueden estar grabando datos en la tarjeta SD
87
contador_lecturas=0; // Empezar a contar lecturas entre grabaciones (para calcular el valor intermedio)
88
#ifdef MODO_PRUEBAS
89
Serial.println("Informe UVi activo");
90
#endif
91
cronometro=millis(); // (re)Iniciar el cronómetro para saber si ha pasado el tiempo entre grabaciones
92
}
93
else
94
{
95
#ifdef MODO_PRUEBAS
96
Serial.println("Se ha producido un error al tratar de crear el documento.");
97
Serial.print("Se reintentará dentro de ");
98
Serial.print(ESPERA_REINTENTO_ERROR);
99
Serial.println(" ms.");
100
#endif
101
delay(ESPERA_REINTENTO_ERROR); // Esperar antes de reintentar
102
}
103
}
104
else // Si el conmutador está en modo NO grabar (y antes no lo estaba)
105
{
106
informe_uvi.flush(); // Vaciar el buffer
107
informe_uvi.close(); // Cerrar el archivo
108
informe_activo=false; // Cambiar el estado a inactivo (no se graban datos en la tarjeta SD)
109
digitalWrite(PIN_INFORME_ACTIVO,LOW); // Apagar el LED que informa de grabación activa
110
#ifdef MODO_PRUEBAS
111
Serial.println("Informe UVi desactivado");
112
#endif
113
}
114
}
115
if(informe_activo) // Si la grabación está activa
116
{
117
if((unsigned long)(millis()-cronometro)>ESPERA_MUESTREO_UVI) // Si la grabación está activa y ha pasado el tiempo entre grabaciones sucesiv
118
{
119
cronometro=millis(); // (re)Iniciar el cronómetro para saber si ha pasado el tiempo entre grabaciones
120
media_lecturas*=COEFICIENTE_VOLTAJE; // Corregir los valores tomados para que trabaje con el voltaje (más o menos coincide con un UVi dec
121
#ifdef MODO_PRUEBAS
122
Serial.print("Guardado el valor ");
123
Serial.print(media_lecturas);
124
Serial.print(" en ");
125
Serial.print(cronometro);
126
Serial.print(" ms (");
127
Serial.print(contador_lecturas);
128
Serial.println(" muestras)");
129
#endif
130
registro_csv=String(cronometro,DEC); // Componer la línea CSV (registro) con el tiempo,
131
registro_csv+=String(SEPARADOR_CSV); // un separador,
132
registro_csv+=String(media_lecturas,DEC); // Valor intermedio de las lecturas hasta el momento,
133
registro_csv+=String(SEPARADOR_CSV); // otro separador
134
registro_csv+=String(contador_lecturas,DEC); // y el número de muestras tomadas para calcular el valor intermedio (más de
135
informe_uvi.println(registro_csv); // Grabar la línea CSV (el registro)
136
contador_lecturas=0; // Empezar a contar lecturas entre grabaciones (para calcular el nuevo valor intermedio)
137
}
138
else // Si no toca grabar, tomar una medida y actualizar el cálculo del valor intermedio
139
{
140
lectura_sensor=analogRead(PIN_GUVAS12SD); // leer el sensor
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
17/11/20 9=04
Página 10 de 22
141
contador_lecturas++; // incrementar el número de lecturas realizadas
142
total_lecturas+=lectura_sensor;
143
media_lecturas=total_lecturas/contador_lecturas;
144
}
145
}
146 }
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.
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
17/11/20 9=04
Página 11 de 22
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
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
17/11/20 9=04
Página 12 de 22
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/vishaysemiconductor-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.
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
17/11/20 9=04
Página 13 de 22
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!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#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"
#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
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
17/11/20 9=04
Página 14 de 22
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
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 t
cliente_web.print(F("<meta name=\"viewport\" content=\"width=device-width,height=device-height,initial-scale=1.0,user-scalable=no,minimum-s
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};
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
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
17/11/20 9=04
Página 15 de 22
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
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
2 junio, 2017 | Reply
17/11/20 9=04
Página 16 de 22
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
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
29 agosto, 2017 | Reply
17/11/20 9=04
Página 17 de 22
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.
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
17/11/20 9=04
Página 18 de 22
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
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
17/11/20 9=04
Página 19 de 22
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
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
4 diciembre, 2018 | Reply
17/11/20 9=04
Página 20 de 22
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
Deja un comentario
Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
17/11/20 9=04
Página 21 de 22
Comentario
Nombre *
Correo electrónico *
Web
Publicar comentario
Por favor confirma que eres humano antes de comentar
En 2018 Víctor Ventura
administra el blog polaridad.es
desde Granada, España.
Suscripción RSS
Seguir con Feedly
http://polaridad.es/sensor-radiacion-ultravioleta-arduino-indice-uv-uvm30a-guva-s12sd/
Contenido con licencia
Creative Commons
CC BY-SA 3.0 ES
Reconocer al autor y
compartir el contenido igual
17/11/20 9=04
Página 22 de 22