Radio signal monitor / RXperiment - mon nouveau projet ESP32 (3)

 Attention : RXperiment / Radio signal monitor est désormais accessible via la plateforme IOT Adafruit. Les données sont transmises en MQTT à cette plateforme, les données ne sont plus transmises via APRS-IS.

Voici les nouveaux liens :

Le graphique du monitoring en cours : https://io.adafruit.com/guyvano/dashboards/rxperiment
   ( ou https://bit.ly/radiosignalmonitor )

copie d'écran de la page web :

La relève de la pression atmosphérique (QNH) est aussi transmise à la plateforme Adafruit :
https://io.adafruit.com/guyvano/dashboards/qnh
  ( ou https://bit.ly/barofareins )

copie d'écran de la page web :

Ce changement de plateforme a pour objectifs l'amélioration de la fiabilité dans le transfert des données et une meilleure sécurité.

**** 73 de Guy F8ABX - 20/05/2021 ****

Baromètre connecté : schéma et code

La toute première version du 22 mars dernier ne gérait pas correctement les problèmes de communication, mais après une modification du code le lendemain, le baromètre fonctionne depuis en permanence et il transmet correctement ses mesures à Weather Underground. La mesure de la pression atmosphérique ramenée au niveau de la mer (QNH) est transmise toutes les 5 minutes au site. En cas de problème de connexion, un nouvel essai est fait 2 minutes plus tard. Au delà de 5 échecs de connexion, le micro contrôleur redémarrera.

Les mesures sont consultables ici https://bit.ly/barogrelonges 

Faites défiler la page car le graphique est situé presque tout en bas. Par défaut, le site affiche en la pression en pouces de mercure mais l'on peut l'avoir en hPa (bouton réglages en haut à droite, puis °C pour avoir la pression en hecto-Pascal...).

Pour publier ses mesures sur Weather Underground, il faut d'abord s'être créé un compte et au moins un "device".
L'identifiant du device et son mot de passe associé sont indispensables pour la publication des mesures.
En ce qui concerne la connexion à Internet, il faudra rentrer le SSID et le mot de passe de votre connexion Wifi dans le programme.
Il faut de même renseigner correctement l'altitude du capteur (en mètres).
Donc en tout, il y a 5 constantes à personnaliser dans le programme.

Depuis le 23 mars 2021, cette version me donne satisfaction.


Le schéma de câblage des composants :

Le code de la v.2.0.0 du 23 mars 2021 :

/* Program name: esp32-baro-wu-2-0-0.ino
   Author: Guy Vanoverbeke @GuyVano
   Program last update (dd/mm/yyyy) : 23/03/2021 - V.2 R.0 C.0
   Arduino IDE V1.8.13
   Board: ESP-WROOM-32
   Function: Publish the barometric pressure from a BME280 sensor on the Weather Underground web site.
   Disclaimer:
   This program (in other words: this code, this software or this application) is a personal creation
   made as part of a hobby and it is given without guarantee of any kind and no support is provided.
   It is free of rights and can be reused freely as you wish.
*/
#include <Wire.h>
#include <WiFi.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
Adafruit_BME280 bme; // I2C
#include <HTTPClient.h>
//
// Wifi SSID and password
//
const char* ssid       = "my Wifi SSID";
const char* password   = "my Wifi password";
//
// Weather Underground device ID and password
//
const char* wudevid    = "my WU device ID";
const char* wudevpw    = "my WU device password";
//

const float myaltitude = 186; // my sensor altitude in meters
//
const boolean autcnx = true; // autorize the connection in http flag
const boolean spr = false;   // true for serial prints or false for no prints
const unsigned long ndly = 300000; // 300000 for 5 minutes. Normal delay between each data upload
const unsigned long edly = 120000; // 120000 for 2 minutes. Retry delay after error
//
float temp = 0;
float hr = 0;
float qfe = 0;
float myqnh = 0;
float myqnhinches = 0;
String wumsg; // http connection url + data to transmit
boolean error = false; // error flag
boolean rderr = false; // sensor read error flag
boolean cnxok = false; // http connection ok flag
int serr = 0; // sensor error counter
int herr = 0; // internet error counter
int hcode = 0; // returned http code
int i = 0; // loop control
String htxt; // returned http text
unsigned snsrsts; // sensor status
//
void setup() {
  //
  pinMode(19, OUTPUT); // red LED for error
  pinMode(23, OUTPUT); // green LED ok
  //
  do {
    digitalWrite(19, LOW);
    digitalWrite(23, HIGH);
    delay(500);
    digitalWrite(19, HIGH);
    digitalWrite(23, LOW);
    delay(500);
    i++;
  } while (i < 6);
  // start the serial connection
  if (spr) {
    Serial.begin(115200);
    // wait for serial monitor to open
    while (! Serial);
  }
  //
  // Connect to WiFi
  //
  if (spr) {
    Serial.println("Connecting to Wifi...");
  }
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    if (spr) {
      Serial.print(">");
    }
  }
  if (spr) {
    Serial.println();
    Serial.println(" Wifi connected.");
    //
    Serial.println();
    Serial.println("BME280 linking...");
  }
  // default settings
  snsrsts = bme.begin(0x76);
  if (!snsrsts) {
    rderr = true;
    error = true;
    if (spr) {
      Serial.println("BME280 sensor not found.");
    }
  }
}
void loop() {
  //
  HTTPClient http;
  rdSensor();
  if (spr) {
    prtValues();
  }
  bldwuMsg();
  if ((!rderr) & (autcnx)) {
    http.begin(wumsg);
    hcode = http.GET();
    htxt = http.getString();
  }
  if (spr) {
    Serial.println();
    Serial.print("Returned code: ");
    Serial.print(hcode);
    Serial.print(" / ");
    Serial.println(htxt);
  }
  if (hcode == 200) {
    // a return code 200 means success
    herr = 0;
    error = false;
    cnxok = true;
  } else {
    herr = herr + 1;
    cnxok = false;
    error = true;
    if (spr) {
      Serial.println();
      Serial.print("HTTP error #");
      Serial.print(herr);
      Serial.println(".");
    }
  }
  //
  //
  //
  if (error) {
    digitalWrite(19, HIGH);
  } else {
    digitalWrite(19, LOW);
  }
  if (cnxok) {
    digitalWrite(23, HIGH);
  } else {
    digitalWrite(23, LOW);
  }
  if (herr > 5) {
    // too much errors, restart the MCU
    ESP.restart();
  }
  //
  //
  //
  if (error) {
    delay((edly - 2000));
  } else {
    delay((ndly - 2000));
  }
  digitalWrite(19, LOW);
  digitalWrite(23, LOW);
  delay(2000);
  hcode = 0;
  htxt = ' ';
}
void prtValues() {
  //
  // Print Temperature, Humidity and barometric pressure
  //
  Serial.print("Temperature = ");
  Serial.print(temp);
  Serial.println(" °C");
  Serial.print("Humidity = ");
  Serial.print(hr);
  Serial.println(" % ");
  Serial.print("Pressure = ");
  Serial.print(myqnh);
  Serial.println(" hPa");
}
void rdSensor() {
  //
  temp = bme.readTemperature();
  hr = bme.readHumidity();
  qfe = bme.readPressure() / 100.0F;
  // myqnh = qfe + (myaltitude * 0.1205F); // previous used formulae
  myqnh = qfe / pow((1 - (myaltitude * (0.0065 / 288.15))), 5.255); // OACI standard atmosphear formulae
  myqnhinches = myqnh * 0.02953F;
  if ((myqnh < 860) | (myqnh > 1090)) {
    //
    // myqnh is out of range, probably error sensor or wiring
    //
    serr = serr + 1;
    rderr = true;
    error = true;
    if (spr) {
      Serial.println();
      Serial.print("Error reading sensor #");
      Serial.print(serr);
      Serial.println(".");
    }
  } else {
    serr = 0;
    rderr = false;
    error = false;
  }
  //
}
void bldwuMsg() {
  //
  // build the internet message for Weather Underground publishing
  //
  wumsg = "https://weatherstation.wunderground.com/weatherstation/updateweatherstation.php?ID=";
  wumsg = wumsg + wudevid + "&PASSWORD=" + wudevpw + "&dateutc=now&baromin=";
  wumsg = wumsg + myqnhinches + "&action=updateraw";
  //
  if (spr) {
    Serial.println();
    Serial.println(wumsg);
  }
}
// End of program esp32-baro-wu-2-0-0.ino - Thanks for watching !

Cordiales 73 !

**** Guy F8ABX - 27/03/2021 ***

Baromètre connecté avec ESP32

 Je viens de mettre à niveau mon circuit baromètre avec une nouvelle version 2.0 connectée. Cette fois-ci, je n'utilise plus d'Arduino Uno mais un ESP32 car ce dernier a l'avantage d'intégrer nativement le Wifi.
Le logiciel est pour l'instant une version de développement un peu frustre mais une version un peu plus présentable devrait voir le jour et je la publierai dans un autre article prochainement.

Le circuit :

Les composants sont réduits au minimum vital : la carte micro contrôleur ESP-WROOM-32, le module de mesure BME280 qui communique avec le micro contrôleur en I2C, deux LED et deux résistances de 220 ohms. Et bien sûr la plaque de prototypage, quelques fils de câblage et une alimentation secteur 5V.

Comme le montage est autonome, c'est-à-dire qu'il fonctionne seul sans le recours d'un pc, j'ai donc souhaité avoir un affichage minimal pour m'assurer de son bon fonctionnement :
La LED verte indique que la dernière connexion au serveur Internet de Weather Underground a réussi. La LED rouge indique qu'il y a eu un problème de connexion Internet ou bien un problème de mesure.

Actuellement, le baromètre publie ses mesures de pression atmosphérique (QNH) toutes les 5 minutes sur Weather Underground et l'on peut les voir ici :

 https://www.wunderground.com/dashboard/pws/IFAREI3/ 

ou via le raccourci https://bit.ly/barogrelonges

Par défaut sur Weather Underground, les pressions barométriques sont indiquées en pouces de mercure, mais on peut les avoir en hecto-Pascal en cliquant tout en haut à droite sur l'engrenage puis °C afin de passer en système métrique.

A bientôt !

**** Guy F8ABX - 22, 25/03/2021 ****

Mise à jour du programme BARO1-5 - new release for the simple but smart barometer

 Une nouvelle et dernière mise à jour avec des changements dans le découpage des pressions et l'affectation aux couleurs. Je pense que c'est mieux comme ceci.

Voici le code de cette ultime release de la version 1, nom de code "Epic Ernest" :

/* Program name: BARO1-5-guyvano.ino
   Author: Guy Vanoverbeke @GuyVano
   Program last update (dd/mm/yyyy) : 16/02/2021 - V.1 R.5 C.0 - Release "Epic Ernest"
   Arduino IDE V1.8.13
   Board: Arduino UNO R3
   Function: Using a BME280 sensor, display the range of barometric pressure and trend on a single RGB LED.
     Fixed red:     QNH <= 995 (Barometric pressure at sea level is lower or equal to 995 hPa)
     Fixed purple:  996 <= QNH <= 1005 hPa
     Fixed indigo: 1006 <= QNH <= 1010 hPa
     Fixed yellow: 1011 <= QNH <= 1015 hPa
     Fixed green:  1016 <= QNH <= 1020 hPa
     Fixed blue:   1021 <= QNH <= 1030 hPa
     Fixed ice white: 1031 <= QNH
     Short green flashes each 30 seconds: barometric pressure has increased recently (at least +0.2 hPa in the last 15 minutes).
     Short blue flashes each 30 seconds: barometric pressure has decreased recently (at least -0.2 in the last 15 minutes).
     Short red flashes each 30 seconds : barometric pressure fast falling warning (at least -0.5 hPa in the last 15 mn).
   Disclaimer:
   This program (in other words: this code, this software or this application) is a personal creation made as part of a hobby
   and it is given without guarantee of any kind and no support is provided. It is free of rights
   and can be reused freely as you wish.
*/
#include <Wire.h>
//
// I2C Temperature, humidity and barometric pressure sensor
//
#include <Adafruit_BME280.h>
Adafruit_BME280 bme;
//
//  Define the 3 pins of the RGB LED
//
const byte pblueled = 9;
const byte pgreenled = 10;
const byte predled = 11;
//
const int myaltitude = 186;  // altitude above sea level en meter
const boolean acnt = false; // true for serial monitor/debug
//
// variables
//
int qfe = 0; // locale barometric pressure qfe in daPa (decaPascal)
int dqfe = 0; // Local barometric pressure difference between 2 sensor reads cycle (in daPa)
int pqfe = 0; // Local barometric pressure of the previous read cycle (in daPa)
int qnh = 0;  // Barometric pressure calculated at sea level (in hPa)
int sdqfe = 0; // sum dqfe
int i = 0; // Loop control
boolean fqfeup = false; // flag qnh up
boolean fqfedown = false; // flag qnh down
boolean fqfewarn = false; // flag qnh fast down
byte cpt = 0; // cycle counter
int tdqfe[30] = {}; // history table of dqfe
//
void setup()
{
  if (acnt) {
    Serial.begin(9600);
    Serial.println(" ");
    Serial.println("*******************************************************");
    Serial.println(" ");
    Serial.println("BARO1-5-guyvano restarted! V.1 R.5 C.0 'Epic Ernest'");
  }
  //
  //   Define pins modes
  //
  pinMode(predled, OUTPUT);
  pinMode(pgreenled, OUTPUT);
  pinMode(pblueled, OUTPUT);
  //
  // Sensor
  //
  bme.begin(0x76);    // address of the BME280 I2C sensor
  //
  // Show the colors used from the lower to higher pressures
  //
  // Red
  digitalWrite(predled, HIGH);
  digitalWrite(pgreenled, LOW);
  digitalWrite(pblueled, LOW);
  delay(1000);
  // Purple
  digitalWrite(predled, HIGH);
  digitalWrite(pgreenled, LOW);
  digitalWrite(pblueled, HIGH);
  delay(1000);
  // Indigo
  digitalWrite(predled, LOW);
  delay(1000);
  // Yellow
  digitalWrite(predled, HIGH);
  digitalWrite(pgreenled, HIGH);
  digitalWrite(pblueled, LOW);
  delay(1000);
  // Green
  digitalWrite(predled, LOW);
  delay(1000);
  // Ice Blue
  digitalWrite(pgreenled, HIGH);
  digitalWrite(pblueled, HIGH);
  delay(1000);
  // Ice white
  digitalWrite(predled, HIGH);
  delay(1000);
  digitalWrite(pblueled, LOW);
  digitalWrite(predled, LOW);
  digitalWrite(pgreenled, LOW);
  delay(450);
  //
  // Let's go! letter R in morse (Ready!) .-.
  //
  digitalWrite(pgreenled, HIGH);
  delay(150);
  digitalWrite(pgreenled, LOW);
  delay(200);
  digitalWrite(pgreenled, HIGH);
  delay(450);
  digitalWrite(pgreenled, LOW);
  delay(200);
  digitalWrite(pgreenled, HIGH);
  delay(150);
  digitalWrite(pgreenled, LOW);
  delay(450);
  //
  qfe = (bme.readPressure() + 5.0F) / 10.0F; // locale pressure qfe in daPa rounded
  pqfe = qfe;
  // initialize history table of the 30 dqfe values with 0
  for (i = 0; i < 30; i++ ) {
    tdqfe[i] = 0;
  }
  cpt = 0;
}
void loop()
{
  qfe = (bme.readPressure() + 5.0F) / 10.0F;
  qnh = (qfe / 10.0F) + (myaltitude * 0.1205F);
  dqfe = qfe - pqfe;
  tdqfe[cpt] = dqfe;
  //
  sdqfe = 0;
  for (i = 0; i < 30; i++ ) {
    sdqfe = sdqfe + tdqfe[i];
  }
  //
  fqfeup = false;
  fqfedown = false;
  fqfewarn = false;
  //
  if ( 1 < sdqfe) {
    fqfeup = true;
  }
  //
  if (sdqfe < -1) {
    fqfedown = true;
  }
  //
  if (sdqfe < -4) {
    fqfewarn = true;
    fqfedown = false;
  }
  //
  // UP : Green flashing
  //
  if (fqfeup) {
    digitalWrite(pblueled, LOW);
    digitalWrite(predled, LOW);
    digitalWrite(pgreenled, LOW);
    delay(450);
    for (i = 0; i < 5; i++ ) {
      // flash U in morse code ..-
      digitalWrite(pgreenled, HIGH);
      delay(150);
      digitalWrite(pgreenled, LOW);
      delay(150);
      digitalWrite(pgreenled, HIGH);
      delay(150);
      digitalWrite(pgreenled, LOW);
      delay(150);
      digitalWrite(pgreenled, HIGH);
      delay(450);
      digitalWrite(pgreenled, LOW);
      delay(450);
    }
  }
  //
  // DOWN : Blue flashing
  //
  if (fqfedown) {
    digitalWrite(pblueled, LOW);
    digitalWrite(pgreenled, LOW);
    digitalWrite(predled, LOW);
    delay(450);
    for (i = 0; i < 5; i++ ) {
      // flash D in morse code -..
      digitalWrite(pblueled, HIGH);
      delay(450);
      digitalWrite(pblueled, LOW);
      delay(150);
      digitalWrite(pblueled, HIGH);
      delay(150);
      digitalWrite(pblueled, LOW);
      delay(150);
      digitalWrite(pblueled, HIGH);
      delay(150);
      digitalWrite(pblueled, LOW);
      delay(450);
    }
  }
  //
  // FAST FALLING WARNING : Red flashing
  //
  if (fqfewarn) {
    digitalWrite(pblueled, LOW);
    digitalWrite(pgreenled, LOW);
    digitalWrite(predled, LOW);
    delay(450);
    for (i = 0; i < 5; i++ ) {
      // flash W in morse code .--
      digitalWrite(predled, HIGH);
      delay(150);
      digitalWrite(predled, LOW);
      delay(150);
      digitalWrite(predled, HIGH);
      delay(450);
      digitalWrite(predled, LOW);
      delay(150);
      digitalWrite(predled, HIGH);
      delay(450);
      digitalWrite(predled, LOW);
      delay(450);
    }
  }
  //
  //   Long light on, depending of the qnh range
  //
  // QNH <= 995 : Red
  //
  if (qnh <= 995) {
    digitalWrite(predled, HIGH);
    digitalWrite(pgreenled, LOW);
    digitalWrite(pblueled, LOW);
  }
  //
  //  996 <= QNH <= 1005 : Purple
  //
  if ((996 <= qnh) & (qnh <= 1005)) {
    digitalWrite(predled, HIGH);
    digitalWrite(pgreenled, LOW);
    digitalWrite(pblueled, HIGH);
  }
  //
  //  1006 <= QNH <= 1010 : Indigo
  //
  if ((1006 <= qnh) & (qnh <= 1010)) {
    digitalWrite(predled, LOW);
    digitalWrite(pgreenled, LOW);
    digitalWrite(pblueled, HIGH);
  }
  //
  // 1011 <= QNH <= 1015 : Yellow
  //
  if ((1011 <= qnh) & (qnh <= 1015)) {
    digitalWrite(predled, HIGH);
    digitalWrite(pgreenled, HIGH);
    digitalWrite(pblueled, LOW);
  }
  //
  // 1016 <= QNH <= 1020 : Green
  //
  if ((1016 <= qnh) & (qnh <= 1020)) {
    digitalWrite(predled, LOW);
    digitalWrite(pgreenled, HIGH);
    digitalWrite(pblueled, LOW);
  }
  //
  // 1021 <= QNH <= 1030 : Light Blue
  //
  if ((1021 <= qnh) & (qnh <= 1030)) {
    digitalWrite(predled, LOW);
    digitalWrite(pgreenled, HIGH);
    digitalWrite(pblueled, HIGH);
  }
  //
  // 1031 <= QNH : Ice White
  //
  if (1031 <= qnh) {
    digitalWrite(predled, HIGH);
    digitalWrite(pgreenled, HIGH);
    digitalWrite(pblueled, HIGH);
  }
  //
  // serial control values if acnt set to true
  //
  if (acnt) {
    Serial.println(" ");
    Serial.print("cpt:");
    Serial.print(cpt);
    Serial.print(", qnh:");
    Serial.print(qnh);
    Serial.print(", qfe:");
    Serial.print(qfe);
    Serial.print(", pqfe:");
    Serial.print(pqfe);
    Serial.print(", dqfe:");
    Serial.print(dqfe);
    Serial.print(", sdqfe:");
    Serial.print(sdqfe);
    Serial.print(", fqfeup:");
    Serial.print(fqfeup);
    Serial.print(", fqfedown:");
    Serial.print(fqfedown);
    Serial.print(", fqfewarn:");
    Serial.print(fqfewarn);
    /*
      for (i = 0; i < 30; i++ ) {
      Serial.print(", tdqfe[");
      Serial.print(i);
      Serial.print("]:");
      Serial.print(tdqfe[i]);
      }
    */
  }
  //
  pqfe = qfe;
  cpt = (cpt + 1) % 30; // cpt+1 modulo 30, cpt return to 0 after 29.
  //
  delay(30000);  // 30000 means 30 seconds to wait before a new cycle
}
// End of the program BARO1-5-guyvano.ino - V.1 R.5 C.0 - Release "Epic Ernest" - Thanks for watching !

*** Guy F8ABX - 16/02/2021 ***

Mise à jour du programme BARO1-4 - new release for the simple but smart barometer

Une nouvelle mise à jour avec une bonne amélioration pour déterminer la tendance.
Je pense que là, le p'tit baro est un petit moins bête. Reste à lui apprendre à faire des prévisions, peut-être dans une prochaine version.

Voici le code :

/* Program name: BARO1-4-guyvano.ino
   Author: Guy Vanoverbeke @GuyVano
   Program last update (dd/mm/yyyy) : 15/02/2021 - V.1 R.4 C.0 "Desired Daisy"
   Arduino IDE V1.8.13
   Board: Arduino UNO R3
   Function: Using a BME280 sensor, display the range of barometric pressure and trend on a single RGB LED.
     Fixed purple: Barometric pressure (QNH) is lower or equal (<=) to 1000 hPa (hollow depression)
     Fixed indigo: 1001 <= QNH <= 1005 hPa
     Fixed blue:   1006 <= QNH <= 1010 hPa
     Fixed yellow: 1011 <= QNH <= 1015 hPa
     Fixed green:  1016 <= QNH <= 1020 hPa
     Fixed ice white: 1021 <= QNH
     Fixed Red + flashing Red each 30 seconds : barometric pressure fast falling warning (at least -0.5 hPa in the last 15 mn).
     Short green flashes each 30 seconds: barometric pressure has increased recently (at least +0.2 hPa in the last 15 minutes).
     Short blue flashes each 30 seconds: barometric pressure has decreased recently (at least -0.2 in the last 15 minutes).
   Disclaimer:
   This program (in other words: this code, this software or this application) is a personal creation made as part of a hobby
   and it is given without guarantee of any kind and no support is provided. It is free of rights
   and can be reused freely as you wish.
*/
#include <Wire.h>
//
// I2C Temperature, humidity and barometric pressure sensor
//
#include <Adafruit_BME280.h>
Adafruit_BME280 bme;
//
//  Define the 3 pins of the RGB LED
//
const byte pblueled = 9;
const byte pgreenled = 10;
const byte predled = 11;
//
const int myaltitude = 186;  // altitude above sea level in meter
const boolean acnt = false; // true for serial monitor/debug
//
// variables
//
int qfe = 0; // locale barometric pressure qfe in daPa (decaPascal)
int dqfe = 0; // Local barometric pressure difference between 2 sensor reads cycle (in daPa)
int pqfe = 0; // Local barometric pressure of the previous read cycle (in daPa)
int qnh = 0;  // Barometric pressure calculated at sea level (in hPa)
int sdqfe = 0; // sum dqfe
int i = 0; // Loop control
boolean fqfeup = false; // flag qnh up
boolean fqfedown = false; // flag qnh down
boolean fqfewarn = false; // flag qnh fast down
byte cpt = 0; // cycle counter
int tdqfe[30] = {}; // history table of dqfe
//
void setup()
{
  if (acnt) {
    Serial.begin(9600);
    Serial.println(" ");
    Serial.println("*******************************************************");
    Serial.println(" ");
    Serial.println("BARO1-4-guyvano restarted! V.1 R.4 C.0 'Desired Daisy'");
  }
  //
  //   Define pins modes
  //
  pinMode(predled, OUTPUT);
  pinMode(pgreenled, OUTPUT);
  pinMode(pblueled, OUTPUT);
  //
  // Sensor
  //
  bme.begin(0x76);    // address of the BME280 I2C sensor
  //
  // the colors used from the lower to higher pressures
  //
  // Purple
  digitalWrite(predled, HIGH);
  digitalWrite(pgreenled, LOW);
  digitalWrite(pblueled, HIGH);
  delay(1000);
  // Indigo
  digitalWrite(predled, LOW);
  delay(1000);
  // Blue
  digitalWrite(pgreenled, HIGH);
  delay(1000);
  // Yellow
  digitalWrite(pblueled, LOW);
  digitalWrite(predled, HIGH);
  delay(1000);
  // Green
  digitalWrite(predled, LOW);
  delay(1000);
  // Ice white
  digitalWrite(predled, HIGH);
  digitalWrite(pblueled, HIGH);
  delay(1000);
  digitalWrite(pblueled, LOW);
  digitalWrite(predled, LOW);
  digitalWrite(pgreenled, LOW);
  delay(1000);
  //
  // Let's go! letter R in morse (Ready!) .-.
  //
  digitalWrite(pgreenled, HIGH);
  delay(150);
  digitalWrite(pgreenled, LOW);
  delay(200);
  digitalWrite(pgreenled, HIGH);
  delay(450);
  digitalWrite(pgreenled, LOW);
  delay(200);
  digitalWrite(pgreenled, HIGH);
  delay(150);
  digitalWrite(pgreenled, LOW);
  delay(1000);
  //
  qfe = (bme.readPressure() + 5.0F) / 10.0F; // locale pressure qfe in daPa rounded
  pqfe = qfe;
  // initialize history table of the 30 dqfe values with 0
  for (i = 0; i < 30; i++ ) {
    tdqfe[i] = 0;
  }
  cpt = 0;
}
void loop()
{
  qfe = (bme.readPressure() + 5.0F) / 10.0F;
  qnh = (qfe / 10.0F) + (myaltitude * 0.1205F);
  dqfe = qfe - pqfe;
  tdqfe[cpt] = dqfe;
  //
  sdqfe = 0;
  for (i = 0; i < 30; i++ ) {
    sdqfe = sdqfe + tdqfe[i];
  }
  //
  fqfeup = false;
  fqfedown = false;
  fqfewarn = false;
  //
  if ( 1 < sdqfe) {
    fqfeup = true;
  }
  //
  if (sdqfe < -1) {
    fqfedown = true;
  }
  //
  if (sdqfe < -4) {
    fqfewarn = true;
    fqfedown = false;
  }
  //
  // UP : Green flashing
  //
  if (fqfeup) {
    digitalWrite(pblueled, LOW);
    digitalWrite(predled, LOW);
    digitalWrite(pgreenled, LOW);
    delay(1000);
    for (i = 0; i < 5; i++ ) {
      // flash U in morse code ..-
      digitalWrite(pgreenled, HIGH);
      delay(150);
      digitalWrite(pgreenled, LOW);
      delay(200);
      digitalWrite(pgreenled, HIGH);
      delay(150);
      digitalWrite(pgreenled, LOW);
      delay(200);
      digitalWrite(pgreenled, HIGH);
      delay(450);
      digitalWrite(pgreenled, LOW);
      delay(1000);
    }
  }
  //
  // DOWN : Blue flashing
  //
  if (fqfedown) {
    digitalWrite(pblueled, LOW);
    digitalWrite(pgreenled, LOW);
    digitalWrite(predled, LOW);
    delay(1000);
    for (i = 0; i < 5; i++ ) {
      // flash D in morse code -..
      digitalWrite(pblueled, HIGH);
      delay(450);
      digitalWrite(pblueled, LOW);
      delay(200);
      digitalWrite(pblueled, HIGH);
      delay(150);
      digitalWrite(pblueled, LOW);
      delay(200);
      digitalWrite(pblueled, HIGH);
      delay(150);
      digitalWrite(pblueled, LOW);
      delay(1000);
    }
  }
  //
  // FAST FALLING WARNING : Red flashing
  //
  if (fqfewarn) {
    digitalWrite(pblueled, LOW);
    digitalWrite(pgreenled, LOW);
    digitalWrite(predled, LOW);
    delay(1000);
    for (i = 0; i < 5; i++ ) {
      // flash W in morse code .--
      digitalWrite(predled, HIGH);
      delay(150);
      digitalWrite(predled, LOW);
      delay(200);
      digitalWrite(predled, HIGH);
      delay(450);
      digitalWrite(predled, LOW);
      delay(200);
      digitalWrite(predled, HIGH);
      delay(450);
      digitalWrite(predled, LOW);
      delay(1000);
    }
  }
  //
  //   Long light on, depending of the qnh range
  //
  // QNH <= 1000 : Purple
  //
  if (qnh <= 1000) {
    digitalWrite(predled, HIGH);
    digitalWrite(pblueled, HIGH);
    digitalWrite(pgreenled, LOW);
  }
  //
  //  1001 <= QNH <= 1005 : Indigo
  //
  if ((1001 <= qnh) & (qnh <= 1005)) {
    digitalWrite(pblueled, HIGH);
    digitalWrite(predled, LOW);
    digitalWrite(pgreenled, LOW);
  }
  //
  // 1006 <= QNH <= 1010 : Light Blue
  //
  if ((1006 <= qnh) & (qnh <= 1010)) {
    digitalWrite(pblueled, HIGH);
    digitalWrite(pgreenled, LOW);
    digitalWrite(predled, HIGH);
  }
  //
  // 1011 <= QNH <= 1015 : Yellow
  //
  if ((1011 <= qnh) & (qnh <= 1015)) {
    digitalWrite(pblueled, LOW);
    digitalWrite(pgreenled, HIGH);
    digitalWrite(predled, HIGH);
  }
  //
  // 1016 <= QNH <= 1020 : Green
  //
  if ((1016 <= qnh) & (qnh <= 1020)) {
    digitalWrite(pblueled, LOW);
    digitalWrite(pgreenled, HIGH);
    digitalWrite(predled, HIGH);
  }
  //
  // 1021 <= QNH : Ice White
  //
  if (1021 <= qnh) {
    digitalWrite(pblueled, HIGH);
    digitalWrite(pgreenled, HIGH);
    digitalWrite(predled, HIGH);
  }
  //
  // Warning : red (R)
  //
  if (fqfewarn) {
    digitalWrite(pblueled, LOW);
    digitalWrite(pgreenled, LOW);
    digitalWrite(predled, HIGH);
  }
  //
  // serial control values if acnt set to true
  //
  if (acnt) {
    Serial.println(" ");
    Serial.print("cpt:");
    Serial.print(cpt);
    Serial.print(", qnh:");
    Serial.print(qnh);
    Serial.print(", qfe:");
    Serial.print(qfe);
    Serial.print(", pqfe:");
    Serial.print(pqfe);
    Serial.print(", dqfe:");
    Serial.print(dqfe);
    Serial.print(", sdqfe:");
    Serial.print(sdqfe);
    Serial.print(", fqfeup:");
    Serial.print(fqfeup);
    Serial.print(", fqfedown:");
    Serial.print(fqfedown);
    Serial.print(", fqfewarn:");
    Serial.print(fqfewarn);
    for (i = 0; i < 30; i++ ) {
      Serial.print(", tdqfe[");
      Serial.print(i);
      Serial.print("]:");
      Serial.print(tdqfe[i]);
    }
  }
  //
  pqfe = qfe;
  cpt = (cpt + 1) % 30; // cpt+1 modulo 30, cpt return to 0 after 29.
  //
  delay(30000);  // 30000 means 30 seconds to wait before a new cycle
}
// End of the program - Thanks for watching !

edit 16/02/2021 : New release available here!

*** Guy F8ABX - 15-16/02/2021 ***

Mise à jour du programme BARO1-3 - new release for the simple but smart barometer

  Une nouvelle release - Valentine's Version  :-) - avec un  affichage par couleurs dont chacune représente cette fois une plage spécifique de valeurs de pression. Et toujours des clignotements verts ou bleus si la pression monte ou diminue, et un affichage en rouge et clignotements rouges en cas de chute rapide de la pression. Cette fois-ci, les clignotements sont des signaux morse visuels, U pour Up, D pour Down, W pour Warning.

A priori, ça devrait être l'avant-dernière pour ce projet, il reste encore un détail à régler pour éviter par moments des séries trop fréquentes Up et Down, vraisemblablement lorsque la valeur de la pression barométrique oscille légèrement autour d'une valeur entière et que la troncature de sa valeur la fait passer à + ou - 1 hPa. Il faudra donc mesurer la pression en dixième d'hecto-pascal et non plus seulement en valeur entière d'hecto-pascal. Mais là, tout-de-suite, je n'ai pas le temps...

Voici le code de la Valentine's Version :

/* Program name: BARO1-3-guyvano.ino
   Author: Guy Vanoverbeke @GuyVano
   Program last update (dd/mm/yyyy) : 14/02/2021 Valentine's Version (v.1 r.3 c.0)
   Arduino IDE V1.8.13
   Board: Arduino UNO R3
   Function: Using a BME280 sensor, display the range of barometric pressure and trend on a single RGB LED.
     Fixed purple: Barometric pressure(QNH) is lower or equal (<=) to 1000 hPa (hollow depression)
     Fixed indigo: 1001 <= QNH <= 1005 hPa 
     Fixed blue:   1006 <= QNH <= 1010 hPa 
     Fixed yellow: 1011 <= QNH <= 1015 hPa 
     Fixed green:  1016 <= QNH <= 1020 hPa 
     Fixed ice white: 1021 <= QNH
     Fixed Red + flashing Red each 30 seconds : barometric pressure fast falling warning (-3 hPa or more in the last 15 mn).
     Short green flashes each 30 seconds: barometric pressure has increased recently (in the last 15 minutes).
     Short blue flashes each 30 seconds: barometric pressure has decreased recently (in the last 15 minutes).
     If there is no variation for 15 minutes, the change and alert indicators are reset.
   Disclaimer:
   This program (in other words: this code, this software or this application) is a personal creation made as part of a hobby
   and it is given without guarantee of any kind and no support is provided. It is free of rights
   and can be reused freely as you wish.
*/
#include <Wire.h>
//
// I2C Temperature, humidity and barometric pressure sensor
//
#include <Adafruit_BME280.h>
Adafruit_BME280 bme;
//
//  Define the 3 pins of the RGB LED
//
const byte pblueled = 9;
const byte pgreenled = 10;
const byte predled = 11;
//
const int anticyc = 1013;  // define the Anticyclonic value
//
const int myaltitude = 186;  // altitude above sea level en meter
//
const boolean acnt = false; // true for serial monitor/debug
//
// variables
//
int qfe = 0; // Local barometric pressure
int dqfe = 0; // Local barometric pressure difference between 2 sensor reads cycle
int pqfe = 0; // Local barometric pressure of the previous read cycle
int qfesf = 0; // Local barometric pressure stored at the begining of the falling period
int qnh = 0;  // Barometric pressure calculated at sea level
int i = 0; // Loop control
boolean fqfeup = false; // flag mem qnh up
boolean fqfedown = false; // flag mem qnh down
boolean fqfewarn = false; // flag mem qnh fast down
byte blqfe = 0 ; // number of cycles before clearing flags mem qfe up or down
//
void setup()
{
  if (acnt) {
    Serial.begin(9600);
    Serial.println(" ");
    Serial.println("*******************************************************");
    Serial.println(" ");
    Serial.println("BARO1-3-guyvano restarted! Valentine's Version (v.1 r.3 c.0)");
  } else {};
  //
  //   Define pins modes
  //
  pinMode(predled, OUTPUT);
  pinMode(pgreenled, OUTPUT);
  pinMode(pblueled, OUTPUT);
  //
  // Sensor
  //
  bme.begin(0x76);    // address of the BME280 I2C sensor
  //
  // LED check
  //
  // Purple
  digitalWrite(predled, HIGH);
  digitalWrite(pgreenled, LOW);
  digitalWrite(pblueled, HIGH);
  delay(1000);
  // Indigo
  digitalWrite(predled, LOW);
  delay(1000);
  // Blue
  digitalWrite(pgreenled, HIGH);
  delay(1000);
  // Yellow
  digitalWrite(pblueled, LOW);
  digitalWrite(predled, HIGH);
  delay(1000);
  // Green
  digitalWrite(predled, LOW);
  delay(1000);
  // Ice white
  digitalWrite(predled, HIGH);
  digitalWrite(pblueled, HIGH); 
  delay(1000);
  digitalWrite(pblueled, LOW);
  digitalWrite(predled, LOW);
  digitalWrite(pgreenled, LOW);
  delay(1000);
  // R in morse (Ready!) ._.
  digitalWrite(pgreenled, HIGH);
  delay(150);
  digitalWrite(pgreenled, LOW);
  delay(200);
  digitalWrite(pgreenled, HIGH);
  delay(450);
  digitalWrite(pgreenled, LOW);
  delay(200);
  digitalWrite(pgreenled, HIGH);
  delay(150);
  digitalWrite(pgreenled, LOW);
  delay(1000);
  //
  qfe = bme.readPressure() / 100.0F;
  qnh = qfe + (myaltitude * 0.1205);
  pqfe = qfe;
}
void loop()
{
  qfe = bme.readPressure() / 100.0F;
  qnh = qfe + (myaltitude * 0.1205);
  dqfe = qfe - pqfe;
  //
  if ((dqfe > 0) & ~(fqfeup)) {
    blqfe = 30; // 30 corresponds to about 15 minutes for the short flashes periods, if delay at the end of loop is 30 seconds.
    fqfeup = true;
    fqfedown = false;
    fqfewarn = false;
  } else {};
  //
  if ((dqfe < 0) & ~(fqfedown)) {
    blqfe = 30; // 30 corresponds to about 15 minutes for the short flashes periods, if delay at the end of loop is 30 seconds.
    qfesf = qfe;
    fqfeup = false;
    fqfedown = true;
  } else {};
  //
  if ((qfesf - qfe) > 2 & (fqfedown)) {
    fqfewarn = true;
  }
  else {};
  //
  // QFE +/- flashing conditions
  //
  // UP (green flashing)
  //
  if ((fqfeup) & ~(fqfewarn)) {
    digitalWrite(pblueled, LOW);
    digitalWrite(predled, LOW);
    digitalWrite(pgreenled, LOW);
    delay(1000);
    for (i = 0; i < 5; i++ ) {
      // flash U in morse code ..-
      digitalWrite(pgreenled, HIGH);
      delay(150);
      digitalWrite(pgreenled, LOW);
      delay(200);
      digitalWrite(pgreenled, HIGH);
      delay(150);
      digitalWrite(pgreenled, LOW);
      delay(200);
      digitalWrite(pgreenled, HIGH);
      delay(450);
      digitalWrite(pgreenled, LOW);
      delay(1000);
    };
    blqfe = blqfe - 1;
  }
  else {};
  //
  // DOWN : Blue flashing
  //
  if ((fqfedown) & ~(fqfewarn)) {
    digitalWrite(pblueled, LOW);
    digitalWrite(pgreenled, LOW);
    digitalWrite(predled, LOW);
    delay(1000);
    for (i = 0; i < 5; i++ ) {
      // flash D in morse code -..
      digitalWrite(pblueled, HIGH);
      delay(450);
      digitalWrite(pblueled, LOW);
      delay(200);
      digitalWrite(pblueled, HIGH);
      delay(150);
      digitalWrite(pblueled, LOW);
      delay(200);
      digitalWrite(pblueled, HIGH);
      delay(150);
      digitalWrite(pblueled, LOW);
      delay(1000);
    };
    blqfe = blqfe - 1;
  }
  else {};
  //
  // FAST FALLING WARNING
  //
  if (fqfewarn) {
    digitalWrite(pblueled, LOW);
    digitalWrite(pgreenled, LOW);
    digitalWrite(predled, LOW);
    delay(1000);
    for (i = 0; i < 5; i++ ) {
      // flash W in morse code .--
      digitalWrite(predled, HIGH);
      delay(150);
      digitalWrite(predled, LOW);
      delay(200);
      digitalWrite(predled, HIGH);
      delay(450);
      digitalWrite(predled, LOW);
      delay(200);
      digitalWrite(predled, HIGH);
      delay(450);
      digitalWrite(predled, LOW);
      delay(1000);
    };
    blqfe = blqfe - 1;
  }
  else {};
  if (blqfe < 1) {
    fqfeup = false;
    fqfedown = false;
    fqfewarn = false;
  }
  else {};
  //
  //   Long light on conditions
  //
  // QNH <= 1000 : Purple
  //
  if (qnh <= 1000) {
    digitalWrite(predled, HIGH);
    digitalWrite(pblueled, HIGH);
    digitalWrite(pgreenled, LOW);
  }
  else {};
  //
  //  1001 <= QNH <= 1005 : Indigo
  //
  if ((1001 <= qnh) & (qnh <= 1005)) {
    digitalWrite(pblueled, HIGH);
    digitalWrite(predled, LOW);
    digitalWrite(pgreenled, LOW);
  } else {};
  //
  // 1006 <= QNH <= 1010 : Light Blue
  //
  if ((1006 <= qnh) & (qnh <= 1010)) {
    digitalWrite(pblueled, HIGH);
    digitalWrite(pgreenled, LOW);
    digitalWrite(predled, HIGH);
  } else {};
  //
  // 1011 <= QNH <= 1015 : Yellow
  //
  if ((1011 <= qnh) & (qnh <= 1015)) {
    digitalWrite(pblueled, LOW);
    digitalWrite(pgreenled, HIGH);
    digitalWrite(predled, HIGH);
  } else {};
  //
  // 1016 <= QNH <= 1020 : Green
  //
  if ((1016 <= qnh) & (qnh <= 1020)) {
    digitalWrite(pblueled, LOW);
    digitalWrite(pgreenled, HIGH);
    digitalWrite(predled, HIGH);
  } else {};
  //
  // 1021 <= QNH : Ice White
  //
  if (1021 <= qnh) {
    digitalWrite(pblueled, HIGH);
    digitalWrite(pgreenled, HIGH);
    digitalWrite(predled, HIGH);
  } else {};
  //
  // Warning : red (R)
  //
  if (fqfewarn) {
    digitalWrite(pblueled, LOW);
    digitalWrite(pgreenled, LOW);
    digitalWrite(predled, HIGH);
  } else {};
  //
  // serial control values
  //
  if (acnt) {
    Serial.println(" ");
    Serial.print("qnh:");
    Serial.print(qnh);
    Serial.print(", qfe:");
    Serial.print(qfe);
    Serial.print(", pqfe:");
    Serial.print(pqfe);
    Serial.print(", dqfe:");
    Serial.print(dqfe);
    Serial.print(", blqfe:");
    Serial.print(blqfe);
    Serial.print(", fqfeup:");
    Serial.print(fqfeup);
    Serial.print(", fqfedown:");
    Serial.print(fqfedown);
    Serial.print(", fqfewarn:");
    Serial.print(fqfewarn);
  } else {};
  //
  pqfe = qfe;
  //
  delay(30000);  // 30000 means 30 seconds to wait before a new cycle
}
// End of the program - Thanks for watching ! --...  ...--

edit 15/02/2021 : Nouvelle version disponible !

*** Guy F8ABX - 14-15/02/2021 ***

Mise à jour du programme BARO1-2 - new release for the simple but smart barometer

 Une nouvelle release avec une palette de couleur plus étendue pour voir de manière plus sympa l'évolution du temps et une alerte (en rouge) dans le cas où la pression chute rapidement.

Voici la version 1.2.0 du programme :

/* Program name: BARO1-2-guyvano.ino
   Author: Guy Vanoverbeke @GuyVano
   Program last update (dd/mm/yyyy) : 13/02/2021 (v.1 r.2 c.0)
   Arduino IDE V1.8.13
   Board: Arduino UNO R3
   Function: Using the BME280 sensor, we display the barometric pressure and trend on a single RGB LED.
     Fixed Purple + flashing Blue each 30 seconds :  barometric pressure is low (QNH < 1023 hPa) and falling during last the 15 minutes.

     Fixed Indigo : barometric pressure is low.
     Fixed Blue + flashing Green each 30 seconds : barometric pressure is low and rising during the last 15 minutes.
     Fixed Green + flashing Blue each 30 seconds : barometric pressure is high (QNH => 1023 hPa) and falling during last the 15 minutes.
     Fixed Yellow : barometric pressure is high.
     Fixed White + flashing Green each 30 seconds : barometric pressure is high and rising during last 15 minutes.
     Fixed Red + flashing Red each 30 seconds : barometric pressure fast falling warning.
     If there is no variation for 15 minutes, the change and alert indicators are reset.
   Disclaimer:
   This program (in other words: this code, this software or this application) is a personal creation made as part of a hobby
   and it is given without guarantee of any kind and no support is provided. It is free of rights
   and can be reused freely as you wish.
*/
#include <Wire.h>
//
// I2C Temperature, humidity and barometric pressure sensor
//
#include <Adafruit_BME280.h>
Adafruit_BME280 bme;
//
//  Define the 3 pins of the RGB LED
//
const byte pblueled = 9;
const byte pgreenled = 10;
const byte predled = 11;
//
const int anticyc = 1013;  // define the Anticyclonic value
//
const int myaltitude = 186;  // altitude above sea level en meter
//
const boolean acnt = false; // true for serial monitor/debug
//
// variables
//
int qfe = 0; // Local barometric pressure
int dqfe = 0; // Local barometric pressure difference between 2 sensor reads cycle
int pqfe = 0; // Local barometric pressure of the previous read cycle
int qfesf = 0; // Local barometric pressure stored at the begining of the falling period
int qnh = 0;  // Barometric pressure calculated at sea level
int i = 0; // Loop control
boolean fqfeup = false; // flag mem qnh up
boolean fqfedown = false; // flag mem qnh down
boolean fqfewarn = false; // flag mem qnh fast down
byte blqfe = 0 ; // number of cycles before clearing flags mem qfe up or down
//
void setup()
{
  if (acnt) {
    Serial.begin(9600);
    Serial.println(" ");
    Serial.println("*******************************************************");
    Serial.println(" ");
    Serial.println("BARO1-2-guyvano restarted! v.1 r.2 c.0");
  } else {};
  //
  //   Define pins modes
  //
  pinMode(predled, OUTPUT);
  pinMode(pgreenled, OUTPUT);
  pinMode(pblueled, OUTPUT);
  //
  // Sensor
  //
  bme.begin(0x76);    // address of the BME280 I2C sensor
  //
  // LED check
  //
  digitalWrite(predled, HIGH);
  digitalWrite(pblueled, HIGH);
  delay(1000);
  digitalWrite(predled, LOW);
  delay(1000);
  digitalWrite(pgreenled, HIGH);
  delay(1000);
  digitalWrite(pblueled, LOW);
  delay(1000);
  digitalWrite(predled, HIGH);
  delay(1000);
  digitalWrite(pgreenled, LOW);
  delay(1000);
  digitalWrite(pblueled, HIGH);
  digitalWrite(predled, HIGH);
  digitalWrite(pgreenled, HIGH);
  delay(1000);
  digitalWrite(pblueled, LOW);
  digitalWrite(predled, LOW);
  digitalWrite(pgreenled, LOW);
  for (i = 0; i < 5; i++ ) {
    digitalWrite(pblueled, HIGH);
    digitalWrite(predled, HIGH);
    digitalWrite(pgreenled, HIGH);
    delay(100);
    digitalWrite(pblueled, LOW);
    digitalWrite(predled, LOW);
    digitalWrite(pgreenled, LOW);
    delay(300);
  };
  //
  qfe = bme.readPressure() / 100.0F;
  qnh = qfe + (myaltitude * 0.1205);
  pqfe = qfe;
}
void loop()
{
  qfe = bme.readPressure() / 100.0F;
  qnh = qfe + (myaltitude * 0.1205);
  dqfe = qfe - pqfe;
  //
  if ((dqfe > 0) & ~(fqfeup)) {
    blqfe = 30; // 30 corrisponds to 15 minutes blinking when a cycle is 30 seconds
    fqfeup = true;
    fqfedown = false;
    fqfewarn = false;
  } else {};
  //
  if ((dqfe < 0) & ~(fqfedown)) {
    blqfe = 30; // 30 corrisponds to 15 minutes blinking when a cycle is 30 seconds
    qfesf = qfe;
    fqfeup = false;
    fqfedown = true;
  } else {};
  //
  if ((qfesf - qfe) > 2 & (fqfedown)) {
    fqfewarn = true;
  }
  else {};
  //
  // QFE +/- flashing conditions
  //
  // UP (green flashing)
  //
  if ((fqfeup) & ~(fqfewarn)) {
    digitalWrite(pblueled, LOW);
    digitalWrite(predled, LOW);
    digitalWrite(pgreenled, LOW);
    delay(200);
    for (i = 0; i < 5; i++ ) {
      digitalWrite(pgreenled, HIGH);
      delay(100);
      digitalWrite(pgreenled, LOW);
      delay(200);
    };
    blqfe = blqfe - 1;
  }
  else {};
  //
  // DOWN
  //
  if ((fqfedown) & ~(fqfewarn)) {
    digitalWrite(pblueled, LOW);
    digitalWrite(pgreenled, LOW);
    digitalWrite(predled, LOW);
    delay(200);
    for (i = 0; i < 5; i++ ) {
      digitalWrite(pblueled, HIGH);
      delay(100);
      digitalWrite(pblueled, LOW);
      delay(200);
    };
    blqfe = blqfe - 1;
  }
  else {};
  //
  // FAST FALLING WARNING
  //
  if (fqfewarn) {
    digitalWrite(pblueled, LOW);
    digitalWrite(pgreenled, LOW);
    digitalWrite(predled, LOW);
    delay(200);
    for (i = 0; i < 5; i++ ) {
      digitalWrite(predled, HIGH);
      delay(100);
      digitalWrite(predled, LOW);
      delay(200);
    };
    blqfe = blqfe - 1;
  }
  else {};
  if (blqfe < 1) {
    fqfeup = false;
    fqfedown = false;
    fqfewarn = false;
  }
  else {};
  //
  //   Long light on conditions
  //
  // depression and trend falling : Purple (R+G)
  //
  if ((qnh < anticyc) & (fqfedown)) {
    digitalWrite(predled, HIGH);
    digitalWrite(pblueled, HIGH);
    digitalWrite(pgreenled, LOW);
  }
  else {};
  //
  //  depression and stable : Indigo (B)
  //
  if ((qnh < anticyc) & ~(fqfedown) & ~(fqfeup)) {
    digitalWrite(pblueled, HIGH);
    digitalWrite(predled, LOW);
    digitalWrite(pgreenled, LOW);
  } else {};
  //
  // depression and trend rising : light blue (B+G)
  //
  if ((qnh < anticyc) & (fqfeup)) {
    digitalWrite(pblueled, HIGH);
    digitalWrite(pgreenled, HIGH);
    digitalWrite(predled, LOW);
  } else {};
  //
  // anticyclone and trend falling : green (G)
  //
  if ((anticyc <= qnh) & (fqfedown)) {
    digitalWrite(pblueled, LOW);
    digitalWrite(pgreenled, HIGH);
    digitalWrite(predled, LOW);
  } else {};
  //
  // anticyclone and stable : yellow (G+R)
  //
  if ((anticyc <= qnh) & ~(fqfedown) & ~(fqfeup)) {
    digitalWrite(pblueled, LOW);
    digitalWrite(pgreenled, HIGH);
    digitalWrite(predled, HIGH);
  } else {};
  //
  // anticlone and trend rising : white (R+G+B)
  //
  if ((anticyc <= qnh) & (fqfeup)) {
    digitalWrite(pblueled, HIGH);
    digitalWrite(pgreenled, HIGH);
    digitalWrite(predled, HIGH);
  } else {};
  //
  // Warning : red (R)
  //
  if (fqfewarn) {
    digitalWrite(pblueled, LOW);
    digitalWrite(pgreenled, LOW);
    digitalWrite(predled, HIGH);
  } else {};
  //
  // serial control values
  //
  if (acnt) {
    Serial.println(" ");
    Serial.print("qnh:");
    Serial.print(qnh);
    Serial.print(", qfe:");
    Serial.print(qfe);
    Serial.print(", pqfe:");
    Serial.print(pqfe);
    Serial.print(", dqfe:");
    Serial.print(dqfe);
    Serial.print(", blqfe:");
    Serial.print(blqfe);
    Serial.print(", fqfeup:");
    Serial.print(fqfeup);
    Serial.print(", fqfedown:");
    Serial.print(fqfedown);
    Serial.print(", fqfewarn:");
    Serial.print(fqfewarn);
  } else {};
  //
  pqfe = qfe;
  //
  delay(30000);  // 30000 means 30 seconds to wait before a new cycle
}
// End of the program - Thanks for watching !

edit 14/02/2021 : new program release available here !

*** Guy F8ABX - 13-14/02/2021 ***