first commit

loop/1_NPM/send_data.py

@@ -0,0 +1,405 @@
+"""
+Main loop to gather data from sensor:
+* NPM
+* Envea
+* I2C BME280
+* Noise sensor
+and send it to AirCarto servers via SARA R4 HTTP post requests
+
+CSV PAYLOAD
+    ATTENTION : do not change order !
+    {PM1},{PM25},{PM10},{temp},{hum},{press},{avg_noise},{max_noise},{min_noise},{envea_no2},{envea_h2s},{envea_o3},{4g_signal_quality}
+    0   -> PM1
+    1   -> PM25
+    2   -> PM10
+    3   -> temp
+    4   -> hum
+    5   -> press
+    6   -> avg_noise
+    7   -> max_noise
+    8   -> min_noise
+    9   -> envea_no2
+    10  -> envea_h2s
+    11  -> envea_o3
+    12  -> 4G signal quality
+
+JSON PAYLOAD
+    Same as NebuleAir wifi
+    {"nebuleairid": "82D25549434",
+     "software_version": "ModuleAirV2-V1-042022",
+      "sensordatavalues":
+      [
+      {"value_type":"NPM_P0","value":"1.54"},
+      {"value_type":"NPM_P1","value":"1.54"},
+      {"value_type":"NPM_P2","value":"1.54"},
+      {"value_type":"NPM_N1","value":"0.02"},
+      {"value_type":"NPM_N10","value":"0.02"},
+      {"value_type":"NPM_N25","value":"0.02"},
+      {"value_type":"MHZ16_CO2","value":"793.00"},
+      {"value_type":"SGP40_VOC","value":"29915.00"},
+      {"value_type":"samples","value":"134400"},
+      {"value_type":"min_micro","value":"137"},
+      {"value_type":"max_micro","value":"155030"},
+      {"value_type":"interval","value":"145000"},
+      {"value_type":"signal","value":"-80"},
+      {"value_type":"latitude","value":"43.2964"},
+      {"value_type":"longitude","value":"5.36978"},
+      {"value_type":"state_npm","value":"State: 00000000"},
+      {"value_type":"th_npm","value":"28.47 / 37.54"}
+      ]}
+    
+    
+"""
+import board
+import json
+import serial
+import time
+import busio
+import re
+
+
+import RPi.GPIO as GPIO
+from adafruit_bme280 import basic as adafruit_bme280
+
+# Record the start time of the script
+start_time = time.time()
+
+url="data.nebuleair.fr"
+payload = [None] * 20
+
+# Set up GPIO mode (for Blue LED: network status)
+GPIO.setwarnings(False)
+GPIO.setmode(GPIO.BCM)  # Use Broadcom pin numbering
+GPIO.setup(23, GPIO.OUT)  # Set GPIO23 as an output pin
+
+#get data from config
+def load_config(config_file):
+    try:
+        with open(config_file, 'r') as file:
+            config_data = json.load(file)
+        return config_data
+    except Exception as e:
+        print(f"Error loading config file: {e}")
+        return {}
+
+def update_json_key(file_path, key, value):
+    """
+    Updates a specific key in a JSON file with a new value.
+
+    :param file_path: Path to the JSON file.
+    :param key: The key to update in the JSON file.
+    :param value: The new value to assign to the key.
+    """
+    try:
+        # Load the existing data
+        with open(file_path, "r") as file:
+            data = json.load(file)
+        
+        # Check if the key exists in the JSON file
+        if key in data:
+            data[key] = value  # Update the key with the new value
+        else:
+            print(f"Key '{key}' not found in the JSON file.")
+            return
+        
+        # Write the updated data back to the file
+        with open(file_path, "w") as file:
+            json.dump(data, file, indent=2)  # Use indent for pretty printing
+        
+        print(f"Successfully updated '{key}' to '{value}'.")
+    except Exception as e:
+        print(f"Error updating the JSON file: {e}")
+
+# Define the config file path
+config_file = '/var/www/nebuleair_pro_4g/config.json'
+
+# Load the configuration data
+config = load_config(config_file)
+# Access the shared variables
+baudrate = config.get('SaraR4_baudrate', 115200)       #baudrate du sara R4
+device_id = config.get('deviceID', '').upper()         #device ID en maj
+need_to_log = config.get('loop_log', False)            #inscription des logs
+bme_280_config = config.get('i2c_BME', False)          #présence du BME280
+i2C_sound_config = config.get('i2C_sound', False)      #présence du capteur son
+envea_sondes = config.get('envea_sondes', [])
+connected_envea_sondes = [sonde for sonde in envea_sondes if sonde.get('connected', False)]
+
+ser_sara = serial.Serial(
+    port='/dev/ttyAMA2',
+    baudrate=baudrate, #115200 ou 9600
+    parity=serial.PARITY_NONE, #PARITY_NONE, PARITY_EVEN or PARITY_ODD
+    stopbits=serial.STOPBITS_ONE,
+    bytesize=serial.EIGHTBITS,
+    timeout = 2
+)
+
+
+ser_NPM = serial.Serial(
+    port='/dev/ttyAMA5',
+    baudrate=115200,
+    parity=serial.PARITY_EVEN,
+    stopbits=serial.STOPBITS_ONE,
+    bytesize=serial.EIGHTBITS,
+    timeout = 1
+        )
+        
+ser_envea = serial.Serial(
+    port='/dev/ttyAMA4',
+    baudrate=9600,
+    parity=serial.PARITY_NONE,
+    stopbits=serial.STOPBITS_ONE,
+    bytesize=serial.EIGHTBITS,
+    timeout = 1
+        )
+
+def read_complete_response(serial_connection, timeout=2, end_of_response_timeout=2):
+    response = bytearray()
+    serial_connection.timeout = timeout
+    end_time = time.time() + end_of_response_timeout
+
+    while True:
+        if serial_connection.in_waiting > 0:
+            data = serial_connection.read(serial_connection.in_waiting)
+            response.extend(data)
+            end_time = time.time() + end_of_response_timeout  # Reset timeout on new data
+        elif time.time() > end_time:
+            break
+        time.sleep(0.1)  # Short sleep to prevent busy waiting
+
+    return response.decode('utf-8')
+
+# Open and read the JSON file
+try:
+    # Send the command to request data (e.g., data for 60 seconds)
+    ser_NPM.write(b'\x81\x12\x6D')
+
+    # Read the response
+    byte_data = ser_NPM.readline()
+
+    #if npm is disconnected byte_data is empty
+
+    # Extract the state byte and PM data from the response
+    state_byte = int.from_bytes(byte_data[2:3], byteorder='big')
+    state_bits = [int(bit) for bit in bin(state_byte)[2:].zfill(8)]
+        
+    PM1 = int.from_bytes(byte_data[9:11], byteorder='big') / 10
+    PM25 = int.from_bytes(byte_data[11:13], byteorder='big') / 10
+    PM10 = int.from_bytes(byte_data[13:15], byteorder='big') / 10
+
+     # Create a dictionary with the parsed data
+    data = {
+        'sondeID': device_id,
+        'PM1': PM1,
+        'PM25': PM25,
+        'PM10': PM10
+    }
+         
+    message = f"{data['PM1']},{data['PM25']},{data['PM10']}"
+    payload[0] = data['PM1'] 
+    payload[1] = data['PM25']
+    payload[2] = data['PM10']
+
+    # Sonde BME280 connected
+    if bme_280_config:
+        #on récupère les infos du BME280 et on les ajoute au payload
+        i2c = busio.I2C(board.SCL, board.SDA)
+        bme280 = adafruit_bme280.Adafruit_BME280_I2C(i2c, address=0x76)
+        bme280.sea_level_pressure = 1013.25  # Update this value for your location
+        data['temp'] =  round(bme280.temperature, 2)
+        data['hum'] =  round(bme280.humidity, 2)
+        data['press'] =  round(bme280.pressure, 2)
+        message += f",{data['temp']},{data['hum']},{data['press']}"
+        payload[3] = data['temp'] 
+        payload[4] = data['hum']
+        payload[5] = data['press']
+    
+    # Sonde Bruit connected
+    if i2C_sound_config:
+            #on récupère les infos de sound_metermoving et on les ajoute au message
+            file_path_data_noise = "/var/www/nebuleair_pro_4g/sound_meter/moving_avg_minute.txt"
+            # Read the file and extract the numbers
+            try:
+                with open(file_path_data_noise, "r") as file:
+                    content = file.read().strip()
+                    avg_noise, max_noise, min_noise = map(int, content.split())
+
+                    # Append the variables to the JSON and to the message
+                    data['avg_noise'] = avg_noise
+                    data['max_noise'] = max_noise
+                    data['min_noise'] = min_noise
+
+                    #get BME280 data (SAFE: it returns none if the key do not exist)
+
+                    message = f"{data.get('PM1', '')},{data.get('PM25', '')},{data.get('PM10', '')},{data.get('temp', '')},{data.get('hum', '')},{data.get('press', '')},{avg_noise},{max_noise},{min_noise}"
+                    payload[6] = data['avg_noise'] 
+                    payload[7] = data['max_noise']
+                    payload[8] = data['min_noise']
+                    print(message)  # Display the message or send it further
+
+            except FileNotFoundError:
+                print(f"Error: File {file_path} not found.")
+            except ValueError:
+                print("Error: File content is not valid numbers.")
+    
+    # Sondes Envea
+    if connected_envea_sondes:
+        # Pour chacune des sondes
+        for device in connected_envea_sondes:
+            print(f"Connected envea Sonde: {device.get('name', 'Unknown')} on port {device.get('port', 'Unknown')} and coefficient {device.get('coefficient', 'Unknown')} ")
+            ser_envea.write(b'\xFF\x02\x13\x30\x01\x02\x03\x04\x05\x06\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x12\xAF\x88\x03')     
+            data_envea = ser_envea.readline()
+            coefficient = device.get('coefficient', 'Unknown')
+            if len(data_envea) >= 20:
+                byte_20 = data_envea[19]
+                byte_20 = byte_20 * coefficient
+                payload[10] = byte_20
+                print(f"Data from envea {byte_20}")
+            else:
+                print("Données reçues insuffisantes pour extraire le 20ème octet.")
+    
+    # Getting the LTE Signal
+    print("-> Getting signal <-")
+    ser_sara.write(b'AT+CSQ\r')
+    response2 = read_complete_response(ser_sara)
+    print("Response:")
+    print(response2)
+    print("<----")
+    match = re.search(r'\+CSQ:\s*(\d+),', response2)
+    if match:
+        signal_quality = match.group(1)
+        print("Signal Quality:", signal_quality)
+        payload[12]=signal_quality
+        time.sleep(1)
+
+    
+    #Write Data to saraR4
+    #1. Open sensordata.json (with correct data size)
+    csv_string = ','.join(str(value) if value is not None else '' for value in payload)
+    size_of_string = len(csv_string)
+    command = f'AT+UDWNFILE="sensordata.json",{size_of_string}\r'
+    ser_sara.write((command + '\r').encode('utf-8'))
+    response_SARA_1 = read_complete_response(ser_sara)
+    #if need_to_log:        
+        #print("Open JSON:")
+        #print(response_SARA_1)
+    time.sleep(1)
+    #2. Write to shell
+    ser_sara.write(csv_string.encode())
+    response_SARA_2 = read_complete_response(ser_sara)
+    if need_to_log:        
+        print("Write to memory:")
+        print(response_SARA_2)
+    #3. Send to endpoint (with device ID)
+    command= f'AT+UHTTPC=0,4,"/pro_4G/data.php?sensor_id={device_id}","server_response.txt","sensordata.json",4\r'                                                                                            
+    ser_sara.write((command + '\r').encode('utf-8'))
+    response_SARA_3 = read_complete_response(ser_sara)
+    if need_to_log:        
+        print("Send data:")
+        print(response_SARA_3)
+        
+        # Les types de réponse 
+
+        # 1.La commande n'a pas fonctionné
+        # +CME ERROR: No connection to phone
+        # +CME ERROR: Operation not allowed
+
+        # 2.La commande fonctionne: elle renvoie un code
+        # +UUHTTPCR: <profile_id>,<http_command>,<http_result>
+        # <http_result>: 1 pour sucess et 0 pour fail
+        # +UUHTTPCR: 0,4,1 -> OK
+        # +UUHTTPCR: 0,4,0 -> error
+
+        # Split response into lines
+        lines = response_SARA_3.strip().splitlines()
+
+        # 1.Vérifier si la réponse contient un message d'erreur CME
+        if "+CME ERROR" in lines[-1]:
+            print("*****")
+            print('<span style="color: red;font-weight: bold;">ATTENTION: CME ERROR</span>')
+            print("error:", lines[-1])
+            print("*****")
+            update_json_key(config_file, "SARA_R4_network_status", "disconnected")
+
+            # Gestion de l'erreur spécifique
+            if "No connection to phone" in lines[-1]:
+                print("No connection to the phone. Retrying or reset may be required.")
+                # Actions spécifiques pour ce type d'erreur (par exemple, réinitialiser ou tenter de reconnecter)
+            elif "Operation not allowed" in lines[-1]:
+                print("Operation not allowed. This may require a different configuration.")
+                # Actions spécifiques pour ce type d'erreur
+
+            # Clignotement LED en cas d'erreur
+            GPIO.output(23, GPIO.LOW)  # Éteindre la LED définitivement
+            for _ in range(4):
+                GPIO.output(23, GPIO.HIGH)  # Allumer la LED
+                time.sleep(0.1)
+                GPIO.output(23, GPIO.LOW)  # Éteindre la LED
+                time.sleep(0.1)
+            GPIO.output(23, GPIO.LOW)  # Turn off the LED
+
+        else:
+        # 2.Si la réponse contient une réponse HTTP valide
+        # Extract HTTP response code from the last line
+        # ATTENTION: lines[-1] renvoie l'avant dernière ligne et il peut y avoir un soucis avec le OK
+        # rechercher plutot 
+            http_response = lines[-1]  # "+UUHTTPCR: 0,4,0"
+            parts = http_response.split(',')
+
+            # 2.1 code 0 (HTTP failed)
+            if len(parts) == 3 and parts[-1] == '0':  # The third value indicates success
+                print("*****")
+                print('<span style="color: red;font-weight: bold;">ATTENTION: HTTP operation failed</span>')
+                update_json_key(config_file, "SARA_R4_network_status", "disconnected")
+                print("*****")
+                print("resetting the URL (domain name):")
+                print("Turning off the blue LED...")
+                for _ in range(4):  # Faire clignoter 4 fois
+                    GPIO.output(23, GPIO.HIGH)  # Allumer la LED
+                    time.sleep(0.1)  # Attendre 100 ms
+                    GPIO.output(23, GPIO.LOW)  # Éteindre la LED
+                    time.sleep(0.1)  # Attendre 100 ms
+                GPIO.output(23, GPIO.LOW)  # Turn off the LED
+                command = f'AT+UHTTP=0,1,"{url}"\r'
+                ser_sara.write((command + '\r').encode('utf-8'))
+                response_SARA_31 = read_complete_response(ser_sara)
+                if need_to_log:
+                    print(response_SARA_31)
+
+            # 2.2 code 1 (HHTP succeded)
+            else:
+                # Si la commande HTTP a réussi
+                print('<span style="color: green; font-weight: bold;">HTTP operation successful.</span>')
+                update_json_key(config_file, "SARA_R4_network_status", "connected")
+                print("Turning on the blue LED...")
+                for _ in range(4):  # Faire clignoter 4 fois
+                    GPIO.output(23, GPIO.HIGH)  # Allumer la LED
+                    time.sleep(0.1)  # Attendre 100 ms
+                    GPIO.output(23, GPIO.LOW)  # Éteindre la LED
+                    time.sleep(0.1)  # Attendre 100 ms
+                GPIO.output(23, GPIO.HIGH)  # Turn on the LED
+                #4. Read reply from server                                                                            
+                ser_sara.write(b'AT+URDFILE="server_response.txt"\r')              
+                response_SARA_4 = read_complete_response(ser_sara)
+                if need_to_log:
+                    print("Reply from server:")
+                    print(response_SARA_4)
+
+    #5. empty json
+    ser_sara.write(b'AT+UDELFILE="sensordata.json"\r')
+    response_SARA_5 = read_complete_response(ser_sara)
+    if need_to_log:
+        print("Empty JSON:")
+        print(response_SARA_5)
+
+    
+
+    # Calculate and print the elapsed time
+    elapsed_time = time.time() - start_time
+    if need_to_log:
+        print(f"Elapsed time: {elapsed_time:.2f} seconds")
+        print("----------------------------------------")
+        print("----------------------------------------")
+
+
+except Exception as e:
+    print(f"Error reading the JSON file: {e}")

loop/1_NPM/send_data_mqtt.py

@@ -0,0 +1,312 @@
+"""
+Main loop to gather data from sensor:
+* NPM
+* I2C BME280
+* Noise sensor
+and send it to AirCarto servers via SARA R4 MQTT requests
+"""
+import board
+import json
+import serial
+import time
+import busio
+
+import RPi.GPIO as GPIO
+from adafruit_bme280 import basic as adafruit_bme280
+
+# Record the start time of the script
+start_time = time.time()
+
+url="data.nebuleair.fr"
+
+# Set up GPIO mode (for Blue LED: network status)
+GPIO.setwarnings(False)
+GPIO.setmode(GPIO.BCM)  # Use Broadcom pin numbering
+GPIO.setup(23, GPIO.OUT)  # Set GPIO23 as an output pin
+
+ # Add yellow color to the output
+yellow_color = "\033[33m"  # ANSI escape code for yellow
+red_color = "\033[31m"     # ANSI escape code for red
+reset_color = "\033[0m"   # Reset color to default
+green_color = "\033[32m"   # Green
+
+#get data from config
+def load_config(config_file):
+    try:
+        with open(config_file, 'r') as file:
+            config_data = json.load(file)
+        return config_data
+    except Exception as e:
+        print(f"Error loading config file: {e}")
+        return {}
+
+def update_json_key(file_path, key, value):
+    """
+    Updates a specific key in a JSON file with a new value.
+
+    :param file_path: Path to the JSON file.
+    :param key: The key to update in the JSON file.
+    :param value: The new value to assign to the key.
+    """
+    try:
+        # Load the existing data
+        with open(file_path, "r") as file:
+            data = json.load(file)
+        
+        # Check if the key exists in the JSON file
+        if key in data:
+            data[key] = value  # Update the key with the new value
+        else:
+            print(f"Key '{key}' not found in the JSON file.")
+            return
+        
+        # Write the updated data back to the file
+        with open(file_path, "w") as file:
+            json.dump(data, file, indent=2)  # Use indent for pretty printing
+        
+        print(f"Successfully updated '{key}' to '{value}'.")
+    except Exception as e:
+        print(f"Error updating the JSON file: {e}")
+
+# Define the config file path
+config_file = '/var/www/nebuleair_pro_4g/config.json'
+
+# Load the configuration data
+config = load_config(config_file)
+# Access the shared variables
+baudrate = config.get('SaraR4_baudrate', 115200)       #baudrate du sara R4
+device_id = config.get('deviceID', '').upper()          #device ID en maj
+need_to_log = config.get('loop_log', False)             #inscription des logs
+bme_280_config = config.get('i2c_BME', False)                  #présence du BME280
+i2C_sound_config = config.get('i2C_sound', False)                  #présence du BME280
+
+ser = serial.Serial(
+    port='/dev/ttyAMA2',
+    baudrate=baudrate, #115200 ou 9600
+    parity=serial.PARITY_NONE, #PARITY_NONE, PARITY_EVEN or PARITY_ODD
+    stopbits=serial.STOPBITS_ONE,
+    bytesize=serial.EIGHTBITS,
+    timeout = 2
+)
+
+ser_NPM = serial.Serial(
+    port='/dev/ttyAMA5',
+    baudrate=115200,
+    parity=serial.PARITY_EVEN,
+    stopbits=serial.STOPBITS_ONE,
+    bytesize=serial.EIGHTBITS,
+    timeout = 1
+        )
+
+def read_complete_response(serial_connection, timeout=2, end_of_response_timeout=2):
+    response = bytearray()
+    serial_connection.timeout = timeout
+    end_time = time.time() + end_of_response_timeout
+
+    while True:
+        if serial_connection.in_waiting > 0:
+            data = serial_connection.read(serial_connection.in_waiting)
+            response.extend(data)
+            end_time = time.time() + end_of_response_timeout  # Reset timeout on new data
+        elif time.time() > end_time:
+            break
+        time.sleep(0.1)  # Short sleep to prevent busy waiting
+
+    # Decode the response and filter out empty lines
+    decoded_response = response.decode('utf-8')
+    non_empty_lines = "\n".join(line for line in decoded_response.splitlines() if line.strip())     
+
+    # Add yellow color to the output
+    
+    colored_output = f"{yellow_color}{non_empty_lines}\n{reset_color}"
+
+    return colored_output
+
+# Open and read the JSON file
+try:
+    # Send the command to request data (e.g., data for 60 seconds)
+    ser_NPM.write(b'\x81\x12\x6D')
+
+    # Read the response
+    byte_data = ser_NPM.readline()
+
+    #if npm is disconnected byte_data is empty
+
+    # Extract the state byte and PM data from the response
+    state_byte = int.from_bytes(byte_data[2:3], byteorder='big')
+    state_bits = [int(bit) for bit in bin(state_byte)[2:].zfill(8)]
+        
+    PM1 = int.from_bytes(byte_data[9:11], byteorder='big') / 10
+    PM25 = int.from_bytes(byte_data[11:13], byteorder='big') / 10
+    PM10 = int.from_bytes(byte_data[13:15], byteorder='big') / 10
+
+     # Create a dictionary with the parsed data
+    data = {
+        'sondeID': device_id,
+        'PM1': PM1,
+        'PM25': PM25,
+        'PM10': PM10
+    }
+         
+    message = f"{data['PM1']},{data['PM25']},{data['PM10']}"
+
+    if bme_280_config:
+        #on récupère les infos du BME280 et on les ajoute au message
+        i2c = busio.I2C(board.SCL, board.SDA)
+        bme280 = adafruit_bme280.Adafruit_BME280_I2C(i2c, address=0x76)
+        bme280.sea_level_pressure = 1013.25  # Update this value for your location
+        data['temp'] =  round(bme280.temperature, 2)
+        data['hum'] =  round(bme280.humidity, 2)
+        data['press'] =  round(bme280.pressure, 2)
+        message += f",{data['temp']},{data['hum']},{data['press']}"
+    
+    if i2C_sound_config:
+            #on récupère les infos de sound_metermoving et on les ajoute au message
+            file_path_data_noise = "/var/www/nebuleair_pro_4g/sound_meter/moving_avg_minute.txt"
+            # Read the file and extract the numbers
+            try:
+                with open(file_path_data_noise, "r") as file:
+                    content = file.read().strip()
+                    avg_noise, max_noise, min_noise = map(int, content.split())
+
+                    # Append the variables to the JSON and to the message
+                    data['avg_noise'] = avg_noise
+                    data['max_noise'] = max_noise
+                    data['min_noise'] = min_noise
+
+                    #get BME280 data (SAFE: it returns none if the key do not exist)
+
+                    message = f"{data.get('PM1', '')},{data.get('PM25', '')},{data.get('PM10', '')},{data.get('temp', '')},{data.get('hum', '')},{data.get('press', '')},{avg_noise},{max_noise},{min_noise}"
+
+                    print(message)  # Display the message or send it further
+
+            except FileNotFoundError:
+                print(f"Error: File {file_path} not found.")
+            except ValueError:
+                print("Error: File content is not valid numbers.")
+
+    # Print the content of the JSON file
+    if need_to_log:        
+        print("Data from sensors:")
+        print(json.dumps(data, indent=4))  # Pretty print the JSON data
+
+    
+    
+    
+    #Write Data to saraR4
+
+    #1. MQTT profile configuration
+    # Note: you need to logout first to change the config
+    print("")
+
+    #print("1.PROFILE CONFIG")
+    #print(" 1.A. READ CONFIG")
+    #command = f'AT+UMQTT?\r'
+    #ser.write((command + '\r').encode('utf-8'))
+    #response_SARA_1 = read_complete_response(ser)
+    #if need_to_log:
+    #    print(response_SARA_1)
+
+    # La config s'efface à chaque redémarrage!
+    need_to_update_config = False
+    if need_to_update_config:
+        print("1.B. SET CONFIG")
+        #command = f'AT+UMQTT=1,1883\r'            #MQTT local TCP port number  
+        command = f'AT+UMQTT=2,"aircarto.fr"\r'    #MQTT server name
+        #command = f'AT+UMQTT=3,"193.252.54.10"\r'    # MQTT server IP address
+        #command = f'AT+UMQTT=12,1\r'    # MQTT clean session
+        ser.write((command + '\r').encode('utf-8'))
+        response_SARA_1 = read_complete_response(ser)
+        if need_to_log:
+            print(response_SARA_1)
+            lines = response_SARA_1.strip().splitlines()
+            for line in lines:
+                if line.startswith("+UMQTT"):
+                    # Split the line by commas and get the last number
+                    parts = line.split(',')
+                    last_number = parts[-1].strip()  # Get the last part and strip any whitespace
+
+                    if int(last_number) == 1:
+                        print(f"{green_color}MQTT profile configuration SUCCEDED{reset_color}")
+                    else:
+                        print(f"{green_color}ERROR: MQTT profile configuration fail{reset_color}")
+
+    
+    #2. MQTT login
+    need_to_update_login = False
+    if need_to_update_login:
+        print("")
+        print("2.MQTT LOGIN")
+        #command = f'AT+UMQTTC=1\r'                  #MQTT login
+        command = f'AT+UMQTTC=0\r'                  #MQTT logout
+
+        ser.write((command + '\r').encode('utf-8'))
+        response_SARA_2 = read_complete_response(ser, 8, 8)
+        if need_to_log:
+            print(response_SARA_2)
+            lines = response_SARA_2.strip().splitlines()
+            for line in lines:
+
+                if line.startswith("+UMQTTC"):
+                    parts = line.split(',')
+                    first_number = parts[0].replace("+UMQTTC:", "").strip()
+                    last_number = parts[-1].strip()  # Get the last part and strip any whitespace
+                    #print(f"Last number: {last_number}")
+                    if int(first_number) == 0:
+                        print("MQTT logout command ->")
+                    if int(first_number) == 1:
+                        print("MQTT login command ->")
+                    if int(last_number) == 1:
+                        print(f"{green_color}SUCCESS{reset_color}")
+                    else:
+                        print(f"{red_color}FAIL{reset_color}")
+                        
+                if line.startswith("+UUMQTTC"):
+                    parts = line.split(',')
+                    first_number = parts[0].replace("+UUMQTTC:", "").strip()
+                    last_number = parts[-1].strip()  # Get the last part and strip any whitespace
+                    if int(first_number) == 1:
+                        print("MQTT login result ->")
+                    if int(last_number) == 0:
+                        print(f"{green_color}connection accepted{reset_color}")
+                    if int(last_number) == 1:
+                        print(f"{green_color}the server does not support the level of the MQTT protocol requested by the Client{reset_color}")
+                    if int(last_number) == 2:
+                        print(f"{green_color} the client identifier is correct UTF-8 but not allowed by the Server{reset_color}")
+                    if int(last_number) == 3:
+                        print(f"{green_color} the network connection has been made but the MQTT service is unavailable{reset_color}")
+                
+    
+    #3. MQTT publish
+    print("")
+    print("3.MQTT PUBLISH")
+    command = f'AT+UMQTTC=2,0,0,"nebuleair/pro/{device_id}/data","{message}"\r'
+    ser.write((command + '\r').encode('utf-8'))
+    response_SARA_3 = read_complete_response(ser)
+    if need_to_log:
+        print(response_SARA_3)
+        lines = response_SARA_3.strip().splitlines()
+        for line in lines:
+            if line.startswith("+UMQTTC"):
+                parts = line.split(',')
+                first_number = parts[0].replace("+UMQTTC:", "").strip()
+                last_number = parts[-1].strip()  # Get the last part and strip any whitespace
+                if int(first_number) == 2:
+                    print("MQTT Publish ->")
+                if int(last_number) == 1:
+                    print(f"{green_color}SUCCESS{reset_color}")
+                else:
+                    print(f"{red_color}FAIL{reset_color}")
+    
+
+    # Calculate and print the elapsed time
+    elapsed_time = time.time() - start_time
+    if need_to_log:
+        print("")
+        print(f"Elapsed time: {elapsed_time:.2f} seconds")
+        print("----------------------------------------")
+        print("----------------------------------------")
+
+
+except Exception as e:
+    print(f"Error reading the JSON file: {e}")

loop/3_NPM/data.json

@@ -0,0 +1,6 @@
+{
+    "sondeID": "Average_USB2_USB3",
+    "PM1": 0.0,
+    "PM25": 0.0,
+    "PM10": 0.0
+}

loop/3_NPM/get_data.py

@@ -0,0 +1,101 @@
+import serial
+import json
+import time
+
+# Initialize serial ports for the three sensors
+ser3 = serial.Serial(
+    port='/dev/ttyAMA3',
+    baudrate=115200,
+    parity=serial.PARITY_EVEN,
+    stopbits=serial.STOPBITS_ONE,
+    bytesize=serial.EIGHTBITS,
+    timeout = 1
+)
+
+ser4 = serial.Serial(
+    port='/dev/ttyAMA4',
+    baudrate=115200,
+    parity=serial.PARITY_EVEN,
+    stopbits=serial.STOPBITS_ONE,
+    bytesize=serial.EIGHTBITS,
+    timeout = 1
+)
+
+ser5 = serial.Serial(
+    port='/dev/ttyAMA5',
+    baudrate=115200,
+    parity=serial.PARITY_EVEN,
+    stopbits=serial.STOPBITS_ONE,
+    bytesize=serial.EIGHTBITS,
+    timeout = 1
+)
+
+# Function to read and parse sensor data
+def read_sensor_data(ser, sonde_id):
+    try:
+        # Send the command to request data (e.g., data for 60 seconds)
+        ser.write(b'\x81\x12\x6D')
+
+        # Read the response
+        byte_data = ser.readline()
+
+        # Extract the state byte and PM data from the response
+        state_byte = int.from_bytes(byte_data[2:3], byteorder='big')
+        state_bits = [int(bit) for bit in bin(state_byte)[2:].zfill(8)]
+        
+        PM1 = int.from_bytes(byte_data[9:11], byteorder='big') / 10
+        PM25 = int.from_bytes(byte_data[11:13], byteorder='big') / 10
+        PM10 = int.from_bytes(byte_data[13:15], byteorder='big') / 10
+
+        # Create a dictionary with the parsed data
+        data = {
+            'sondeID': sonde_id,
+            'PM1': PM1,
+            'PM25': PM25,
+            'PM10': PM10
+        }
+
+        return data
+    except Exception as e:
+        print(f"Error reading from sensor {sonde_id}: {e}")
+        return None
+
+# Function to create a JSON object with all sensor data
+def collect_all_sensor_data():
+    all_data = {}
+
+    # Read data from each sensor and add to the all_data dictionary
+    sensor_data_3 = read_sensor_data(ser3, 'USB2')
+    sensor_data_4 = read_sensor_data(ser4, 'USB3')
+    sensor_data_5 = read_sensor_data(ser5, 'USB4')
+
+    # Store the data for each sensor in the dictionary
+    if sensor_data_3:
+        all_data['sensor_3'] = sensor_data_3
+    if sensor_data_4:
+        all_data['sensor_4'] = sensor_data_4
+    if sensor_data_5:
+        all_data['sensor_5'] = sensor_data_5
+
+    return all_data
+
+# Main script to run once
+if __name__ == "__main__":
+    try:
+        # Collect data from all sensors
+        data = collect_all_sensor_data()
+
+        # Convert data to JSON
+        json_data = json.dumps(data, indent=4)
+
+        # Define the output file path
+        output_file = "/var/www/nebuleair_pro_4g/loop/data.json"  # Change this to your desired file path
+
+        # Write the JSON data to the file
+        with open(output_file, 'w') as file:
+            file.write(json_data)
+        
+        print(f"Data successfully written to {output_file}")
+
+    except Exception as e:
+        print(f"Error: {e}")

loop/3_NPM/get_data_closest_pair.py

@@ -0,0 +1,182 @@
+import serial
+import json
+import time
+import math
+
+# Record the start time of the script
+start_time = time.time()
+
+#get config
+def load_config(config_file):
+    try:
+        with open(config_file, 'r') as file:
+            config_data = json.load(file)
+        return config_data
+    except Exception as e:
+        print(f"Error loading config file: {e}")
+        return {}
+
+# Define the config file path
+config_file = '/var/www/nebuleair_pro_4g/config.json'
+# Load the configuration data
+config = load_config(config_file)
+# Access the shared variables
+need_to_log = config.get('loop_log', False)
+
+# Initialize serial ports for the three sensors
+ser3 = serial.Serial(
+    port='/dev/ttyAMA3',
+    baudrate=115200,
+    parity=serial.PARITY_EVEN,
+    stopbits=serial.STOPBITS_ONE,
+    bytesize=serial.EIGHTBITS,
+    timeout=1
+)
+
+ser4 = serial.Serial(
+    port='/dev/ttyAMA4',
+    baudrate=115200,
+    parity=serial.PARITY_EVEN,
+    stopbits=serial.STOPBITS_ONE,
+    bytesize=serial.EIGHTBITS,
+    timeout=1
+)
+
+ser5 = serial.Serial(
+    port='/dev/ttyAMA5',
+    baudrate=115200,
+    parity=serial.PARITY_EVEN,
+    stopbits=serial.STOPBITS_ONE,
+    bytesize=serial.EIGHTBITS,
+    timeout=1
+)
+
+# Function to read and parse sensor data
+def read_sensor_data(ser, sonde_id):
+    try:
+        # Send the command to request data (e.g., data for 60 seconds)
+        ser.write(b'\x81\x12\x6D')
+
+        # Read the response
+        byte_data = ser.readline()
+
+        # Extract the state byte and PM data from the response
+        PM1 = int.from_bytes(byte_data[9:11], byteorder='big') / 10
+        PM25 = int.from_bytes(byte_data[11:13], byteorder='big') / 10
+        PM10 = int.from_bytes(byte_data[13:15], byteorder='big') / 10
+
+        # Create a dictionary with the parsed data
+        data = {
+            'sondeID': sonde_id,
+            'PM1': PM1,
+            'PM25': PM25,
+            'PM10': PM10
+        }
+
+        return data
+    except Exception as e:
+        print(f"Error reading from sensor {sonde_id}: {e}")
+        return None
+
+# Function to calculate the Euclidean distance between two sensor readings
+def calculate_distance(sensor1, sensor2):
+    PM1_diff = sensor1['PM1'] - sensor2['PM1']
+    PM25_diff = sensor1['PM25'] - sensor2['PM25']
+    PM10_diff = sensor1['PM10'] - sensor2['PM10']
+    return math.sqrt(PM1_diff**2 + PM25_diff**2 + PM10_diff**2)
+
+# Function to select the closest pair of sensors and average their data
+def average_closest_pair(data):
+    # List of sensor names and their data
+    sensors = list(data.items())
+
+    # Variable to keep track of the smallest distance and corresponding pair
+    min_distance = float('inf')
+    closest_pair = None
+
+    # Compare each pair of sensors to find the closest one
+    for i in range(len(sensors)):
+        for j in range(i + 1, len(sensors)):
+            sensor1 = sensors[i][1]
+            sensor2 = sensors[j][1]
+
+            # Calculate the distance between the two sensors
+            distance = calculate_distance(sensor1, sensor2)
+
+            # Update the closest pair if a smaller distance is found
+            if distance < min_distance:
+                min_distance = distance
+                closest_pair = (sensor1, sensor2)
+
+    # If a closest pair is found, average their values
+    if closest_pair:
+        sensor1, sensor2 = closest_pair
+        averaged_data = {
+            'sondeID': f"Average_{sensor1['sondeID']}_{sensor2['sondeID']}",
+            'PM1': round((sensor1['PM1'] + sensor2['PM1']) / 2, 2),
+            'PM25': round((sensor1['PM25'] + sensor2['PM25']) / 2, 2),
+            'PM10': round((sensor1['PM10'] + sensor2['PM10']) / 2, 2)
+        }
+        return averaged_data
+    else:
+        return None
+
+# Function to create a JSON object with all sensor data
+def collect_all_sensor_data():
+    all_data = {}
+
+    # Read data from each sensor and add to the all_data dictionary
+    sensor_data_3 = read_sensor_data(ser3, 'USB2')
+    sensor_data_4 = read_sensor_data(ser4, 'USB3')
+    sensor_data_5 = read_sensor_data(ser5, 'USB4')
+
+    # Store the data for each sensor in the dictionary
+    if sensor_data_3:
+        all_data['sensor_3'] = sensor_data_3
+    if sensor_data_4:
+        all_data['sensor_4'] = sensor_data_4
+    if sensor_data_5:
+        all_data['sensor_5'] = sensor_data_5
+
+    return all_data
+
+# Main script to run once and average data for the closest sensors
+if __name__ == "__main__":
+    try:
+        # Collect data from all sensors
+        data = collect_all_sensor_data()
+        if need_to_log:
+            print("Getting Data from all sensors:")
+            print(data)
+
+        # Average the closest pair of sensors
+        averaged_data = average_closest_pair(data)
+        if need_to_log:
+            print("Average the closest pair of sensors:")
+            print(averaged_data)
+
+
+        if averaged_data:
+            # Convert the averaged data to JSON
+            json_data = json.dumps(averaged_data, indent=4)
+
+            # Define the output file path
+            output_file = "/var/www/nebuleair_pro_4g/loop/data.json"  # Change this to your desired file path
+
+            # Write the JSON data to the file
+            with open(output_file, 'w') as file:
+                file.write(json_data)
+            
+            if need_to_log:
+                print(f"Data successfully written to {output_file}")
+        else:
+            print("No closest pair found to average.")
+
+        # Calculate and print the elapsed time
+        elapsed_time = time.time() - start_time
+        if need_to_log:
+            print(f"Elapsed time: {elapsed_time:.2f} seconds")
+            print("-----------------")
+
+    except Exception as e:
+        print(f"Error: {e}")

loop/3_NPM/send_data.py

@@ -0,0 +1,142 @@
+import json
+import serial
+import time
+
+# Record the start time of the script
+start_time = time.time()
+
+# Define the path to the JSON file
+file_path = "/var/www/nebuleair_pro_4g/loop/data.json"  # Replace with your actual file path
+
+url="data.nebuleair.fr"
+
+#get config
+def load_config(config_file):
+    try:
+        with open(config_file, 'r') as file:
+            config_data = json.load(file)
+        return config_data
+    except Exception as e:
+        print(f"Error loading config file: {e}")
+        return {}
+
+# Define the config file path
+config_file = '/var/www/nebuleair_pro_4g/config.json'
+# Load the configuration data
+config = load_config(config_file)
+# Access the shared variables
+baudrate = config.get('SaraR4_baudrate', 115200)
+device_id = config.get('deviceID', '').upper()
+need_to_log = config.get('loop_log', False)
+
+ser = serial.Serial(
+    port='/dev/ttyAMA2',
+    baudrate=baudrate, #115200 ou 9600
+    parity=serial.PARITY_NONE, #PARITY_NONE, PARITY_EVEN or PARITY_ODD
+    stopbits=serial.STOPBITS_ONE,
+    bytesize=serial.EIGHTBITS,
+    timeout = 2
+)
+
+def read_complete_response(serial_connection, timeout=2, end_of_response_timeout=2):
+    response = bytearray()
+    serial_connection.timeout = timeout
+    end_time = time.time() + end_of_response_timeout
+
+    while True:
+        if serial_connection.in_waiting > 0:
+            data = serial_connection.read(serial_connection.in_waiting)
+            response.extend(data)
+            end_time = time.time() + end_of_response_timeout  # Reset timeout on new data
+        elif time.time() > end_time:
+            break
+        time.sleep(0.1)  # Short sleep to prevent busy waiting
+
+    return response.decode('utf-8')
+
+# Open and read the JSON file
+try:
+    with open(file_path, 'r') as file:
+        # Load the data from the file
+        data = json.load(file)
+        
+        # Print the content of the JSON file
+        if need_to_log:        
+            print("Data from JSON file:")
+            print(json.dumps(data, indent=4))  # Pretty print the JSON data
+        
+        message = f"{data['PM1']},{data['PM25']},{data['PM10']}"
+
+        #Write Data to saraR4
+        #1. Open sensordata.json (with correct data size)
+        size_of_string = len(message)
+        command = f'AT+UDWNFILE="sensordata.json",{size_of_string}\r'
+        ser.write((command + '\r').encode('utf-8'))
+        response_SARA_1 = read_complete_response(ser)
+        if need_to_log:        
+            print("Open JSON:")
+            print(response_SARA_1)
+        time.sleep(1)
+        #2. Write to shell
+        ser.write(message.encode())
+        response_SARA_2 = read_complete_response(ser)
+        if need_to_log:        
+            print("Write to memory:")
+            print(response_SARA_2)
+        #3. Send to endpoint (with device ID)
+        command= f'AT+UHTTPC=0,4,"/pro_4G/data.php?sensor_id={device_id}","server_response.txt","sensordata.json",4\r'                                                                                            
+        ser.write((command + '\r').encode('utf-8'))
+        response_SARA_3 = read_complete_response(ser)
+        if need_to_log:        
+            print("Send data:")
+            print(response_SARA_3)
+            # Split response into lines
+            lines = response_SARA_3.strip().splitlines()
+                # +UUHTTPCR: <profile_id>,<http_command>,<http_result>
+                # <http_result>: 1 pour sucess et 0 pour fail
+                # +UUHTTPCR: 0,4,1 -> OK
+                # +UUHTTPCR: 0,4,0 -> error
+
+            # Extract HTTP response code from the last line
+            http_response = lines[-1]  # "+UUHTTPCR: 0,4,0"
+            parts = http_response.split(',')
+
+            # Check HTTP result
+            if len(parts) == 3 and parts[-1] == '0':  # The third value indicates success
+                print("*****")
+                print("!ATTENTION!")
+                print("error: HTTP operation failed.")
+                print("*****")
+                print("resetting the URL (domain name):")
+                command = f'AT+UHTTP=0,1,"{url}"\r'
+                ser.write((command + '\r').encode('utf-8'))
+                response_SARA_31 = read_complete_response(ser)
+                if need_to_log:
+                    print(response_SARA_31)
+
+            else:
+                print("HTTP operation successful.")
+                #4. Read reply from server                                                                            
+                ser.write(b'AT+URDFILE="server_response.txt"\r')              
+                response_SARA_4 = read_complete_response(ser)
+                if need_to_log:
+                    print("Reply from server:")
+                    print(response_SARA_4)
+
+        #5. empty json
+        ser.write(b'AT+UDELFILE="sensordata.json"\r')
+        response_SARA_5 = read_complete_response(ser)
+        if need_to_log:
+            print("Empty JSON:")
+            print(response_SARA_5)
+
+    
+
+        # Calculate and print the elapsed time
+        elapsed_time = time.time() - start_time
+        if need_to_log:
+            print(f"Elapsed time: {elapsed_time:.2f} seconds")
+            print("-----------------")
+
+except Exception as e:
+    print(f"Error reading the JSON file: {e}")