UltraV : Mesureur d'Indice UV Portable pour une Exposition Solaire Sécurisée

Composants et Fournitures

Composant	Description	Quantité
Arduino Nano R3	Microcontrôleur compact	1
Capteur UV Texas Instruments ML-8511	Capteur UV avec amplificateur intégré	1
Écran OLED 128x64	Affichage SSD1306	1
Convertisseur DC-DC MT3608 (Step-up)	Éleve la tension de la pile 3V	1
Pile CR2 (3V)	Pile lithium 800 mAh	1
Support de pile CR2		1

À Propos de ce Projet

Ne pouvant m'exposer au soleil à cause d'un problème dermatologique, j'ai mis à profit le temps que j'aurais passé à la plage pour construire un mesureur d'ultraviolets : l'UltraV.

Il est basé sur un Arduino Nano rev3, avec un capteur UV, un convertisseur DC/DC pour élever la tension de la pile 3V, et un petit écran OLED. Mon objectif principal était la portabilité, pour connaître l'indice UV à tout moment et en tout lieu.

Étape 1 : Pièces et Composants

• Microcontrôleur Arduino Nano rev.3
• Capteur UV ML8511
• Écran OLED 128×64 (SSD1306)
• Convertisseur DC-DC step-up MT3608
• Pile CR2
• Support de pile CR2
• Interrupteur
• Boîtier de protection

Étape 2 : Le Capteur

Le ML8511 (Lapis Semiconductors) est un capteur UV adapté pour mesurer l'intensité UV en intérieur comme en extérieur. Il intègre un amplificateur opérationnel qui convertit le photocourant en tension selon l'intensité UV. Cette caractéristique offre une interface facile vers des circuits externes comme un ADC. En mode veille, le courant de veille typique est de 0,1 µA, prolongeant la durée de vie de la pile.

Caractéristiques :

• Photodiode sensible aux UV-A et UV-B
• Amplificateur opérationnel embarqué
• Sortie tension analogique
• Faible consommation (300 µA typ.) et très faible en veille (0,1 µA typ.)
• Boîtier QFN céramique 12 broches compact (4,0 mm × 3,7 mm × 0,73 mm)

Malheureusement, je n'ai pas trouvé de matériau transparent aux UV pour protéger le capteur. Toute couverture transparente testée (plastique, verre, etc.) atténuait la mesure UV. Le meilleur choix serait du verre de silice fondue (quartz), mais je n'en ai pas trouvé à prix raisonnable. J'ai donc laissé le capteur à l'air libre, hors du boîtier.

Étape 3 : Fonctionnement

Pour effectuer une mesure, allumez l'appareil et pointez-le vers le soleil pendant plusieurs secondes, en le maintenant aligné avec la direction des rayons solaires. Regardez l'affichage : l'indice à gauche affiche la mesure instantanée (une toutes les 200 ms), tandis que la lecture à droite est le maximum atteint durant la session – c'est celle qu'il faut retenir.

En bas à gauche, l'affichage indique aussi la nomenclature OMS équivalente (FAIBLE, MODÉRÉ, FORT, TRÈS FORT, EXTRÊME) pour l'indice UV mesuré.

Étape 4 : Tension de la Pile et Lecture

J'ai choisi une pile CR2 pour sa taille et sa capacité (800 mAh). J'ai utilisé l'UltraV tout l'été et la pile affiche encore 2,8 V, ce qui me satisfait. En fonctionnement, le circuit consomme environ 100 mA, mais une mesure ne dure que quelques secondes. La tension nominale de la pile étant de 3 V, j'ai ajouté un convertisseur DC-DC step-up pour porter la tension à 9 V et la connecter à la broche Vin.

Pour afficher la tension de la pile sur l'écran, j'ai utilisé une entrée analogique (A2). Les entrées analogiques Arduino mesurent une tension DC entre 0 et 5 V, mais cela nécessite un étalonnage. Pour l'étalonner, il vous faut un multimètre. Alimentez le circuit avec votre pile CR2 finale (pas l'USB de l'ordinateur) ; mesurez le 5 V sur l'Arduino depuis le régulateur (broche 5V de l'Arduino) : cette tension sert de référence pour l'ADC de l'Arduino par défaut. Insérez la valeur mesurée dans le sketch comme suit (supposons 5,023 V) :

voltage = ((long)sum / (long)NUM_SAMPLES * 5023) / 1024.0;

Dans le sketch, je prends la mesure de tension comme une moyenne sur 10 échantillons.

Étape 5 : Schéma et Connexions

Étape 6 : Logiciel

Pour l'affichage, j'ai utilisé la bibliothèque U8g2lib, très flexible et puissante pour ce type d'écrans OLED, offrant un large choix de polices et de bonnes fonctions de positionnement.

Concernant la lecture de tension du ML8511, j'ai utilisé la broche de référence 3,3 V de l'Arduino (précise à 1 %) comme base pour le convertisseur ADC. En faisant une conversion analogique-numérique sur la broche 3,3 V (en la connectant à A1) et en comparant cette lecture à celle du capteur, on peut extrapoler une lecture fidèle, quelle que soit la tension Vin (tant qu'elle est supérieure à 3,4 V).

int uvLevel = averageAnalogRead(UVOUT);
int refLevel = averageAnalogRead(REF_3V3);
float outputVoltage = 3.3 / refLevel * uvLevel;

Téléchargez le code complet depuis le lien suivant.

UltraV_OLED.ino.zip

Étape 7 : Boîtier de Protection

Après plusieurs essais (infructueux) de découpe manuelle de la fenêtre rectangulaire de l'écran sur une boîte plastique commerciale, j'ai décidé de concevoir le mien. Avec un logiciel de CAO, j'ai dessiné une boîte la plus compacte possible, en montant la pile CR2 à l'extérieur sur la face arrière (support de pile collé sur la boîte).

Téléchargez le fichier STL pour le boîtier depuis le lien suivant.

UltraV.stl.zip

Étape 8 : Améliorations Futures Possibles

• Utiliser un spectromètre UV pour mesurer les valeurs réelles d'indice UV en temps réel sous diverses conditions (les spectromètres UV sont très chers) ;
• Enregistrer simultanément la sortie du ML8511 avec le microcontrôleur Arduino ;
• Écrire un algorithme pour relier la sortie du ML8511 à la valeur UVI réelle en temps réel sous une large gamme de conditions atmosphériques.

Étape 9 : Galerie d'Images

Étape 10 : Crédits

• Carlos Orts : Projet Arduino
• Forum Arduino : Discussion
• Starting Electronics : Articles
• U8g2lib : Documentation
• Organisation Mondiale de la Santé, Indice UV : OMS

Code

UltraV (C/C++)

/* Fabio Marzocca @ 2018
Analog to digital conversions rely completely on VCC. We assume this is 5V but if the board is powered from USB this may be as high as 5.25V or as low as 4.75V: https://en.wikipedia.org/wiki/USB#Power
Because of this unknown window it makes the ADC fairly inaccurate in most cases.
To fix this, we use the very accurate onboard 3.3V reference (accurate within 1%).
So by doing an ADC on the 3.3V pin (A1) and then comparing this against the reading from the sensor we can extrapolate a true-to-life reading no matter what VIN is (as long as it's above 3.4V).
v. 2.0.0 - July 2018 - moved from 16x2 LCD to OLED
v. 2.0.1 - Sept 2018 - changed read battery function */
#include <Arduino.h>
#include <U8g2lib.h>
#include <Wire.h>

U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE); // All Boards without Reset of the Display

#define FIRST_ROW_Y 16
#define FIRST_ROW_X 16
#define BOX_H 38

//Hardware pin definitions
const int UVOUT = A0; //Output from the sensor
const int REF_3V3 = A1; //3.3V power on the Arduino board
const int VBATT = A2; //Battery voltage

float maxUV = 0; //Max UV index read

void setup() {
  pinMode(UVOUT, INPUT);
  pinMode(REF_3V3, INPUT);
  pinMode(VBATT, INPUT);
  u8g2.begin();
}

void loop() {
  u8g2.firstPage();
  do {
    int uvLevel = averageAnalogRead(UVOUT);
    int refLevel = averageAnalogRead(REF_3V3);
    //Use the 3.3V power pin as a reference to get a very accurate output value from sensor
    float outputVoltage = 3.3 / refLevel * uvLevel;
    float uvIntensity = mapfloat(outputVoltage, 0.99, 2.6, 0.0, 15.0); //Convert the voltage to a UV intensity level
    readBattery();
    if (maxUV < uvIntensity) {
      maxUV = uvIntensity;
    }
    u8g2.drawFrame(0,FIRST_ROW_Y+1,128,BOX_H);
    u8g2.setFont(u8g2_font_logisoso18_tf); //Instant UV
    u8g2.setCursor(10,40);
    u8g2.print(uvIntensity);
    //UV Max
    u8g2.setCursor(70,40);
    u8g2.print(maxUV);
    u8g2.setFont(u8g2_font_u8glib_4_tf);
    u8g2.setCursor(10,52);
    u8g2.print(F("INSTANT"));
    u8g2.setCursor(75,52);
    u8g2.print(F("MAXIMUM"));
    showUVCategory();
    u8g2.setCursor(88,64);
    u8g2.print(F("F.Marzocca"));
  } while ( u8g2.nextPage() );
  delay(200);
}

// Reads maxUV and prints the UV category
void showUVCategory() {
  char strCat[12];
  byte categ = (byte)(maxUV+0.5); //round up
  if ((categ >= 0) && (categ < 3)) {
    strcpy(strCat, "LOW");
  } else if ((categ >= 3) && (categ < 6)) {
    strcpy(strCat, "MODERATE");
  } else if ((categ >= 6) && (categ < 8)) {
    strcpy(strCat, "HIGH !");
  } else if ((categ >= 8) && (categ < 10)) {
    strcpy(strCat, "VERY HIGH!");
  } else if (categ >= 11) {
    strcpy(strCat, "EXTREME!");
  }
  u8g2.setCursor(0,64);
  u8g2.print(strCat);
}

//Takes an average of readings on a given pin
//Returns the average
int averageAnalogRead(int pinToRead) {
  byte numberOfReadings = 16;
  unsigned int runningValue = 0;
  for(int x = 0 ; x < numberOfReadings ; x++)
    runningValue += analogRead(pinToRead);
  runningValue /= numberOfReadings;
  return(runningValue);
}

//The Arduino Map function but for floats
//From: https://forum.arduino.cc/index.php?topic=3922.0
float mapfloat(float x, float in_min, float in_max, float out_min, float out_max) {
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

void readBattery() {
  long battery = readBattVcc();
  long VccMin = 2300; //Battery minimum voltage read on Vcc
  byte batteryBar; //Battery progress bar
  int barStep = 140; //step for battery progress bar (235)
  batteryBar = (battery - VccMin)/barStep;
  // battery icon
  u8g2.setFont(u8g2_font_open_iconic_embedded_2x_t);
  u8g2.drawGlyph(1, FIRST_ROW_Y, 73 ); // battery status cursor
  u8g2.setFont(u8g2_font_open_iconic_play_1x_t);
  for (byte i=1; i<=batteryBar; i++) {
    u8g2.drawGlyph( 128-9*i,FIRST_ROW_Y-4,75);
  }
  // battery voltage
  u8g2.setFont(u8g2_font_freedoomr10_tu);
  u8g2.setCursor(25, FIRST_ROW_Y);
  u8g2.print(float(battery)/1000, 3);
}

long readBattVcc() {
  int sum=0;
  int sample_count=0;
  long voltage= 0;
  #define NUM_SAMPLES 10 // take a number of analog samples and add them up
  while (sample_count < NUM_SAMPLES) {
    sum += analogRead(VBATT);
    sample_count++;
    delay(2);
  }
  // calculate the voltage
  // use 5000 for a 5.0V ADC reference voltage
  // 5020V is the calibrated reference voltage (in millivolts) for my project
  voltage = ((long)sum / (long)NUM_SAMPLES * 5020) / 1024.0;
  return voltage; //Vbattery in millivolts
}