i’m new here.

i would like to link my backend code to a frontend app, to display results of my predictive maintenance app on a dashboard but i don’t know how to go about it. i also tried flask but it won’t work how i want it

find my backend below:

from datetime import datetime
import random
import numpy as np
import time
from keras.models import load_model

# Charger les modèles entraînés
trained_model_courant_moteur1 = load_model('best_model_courant_moteur1_brut.keras')
trained_model_courant_moteur2 = load_model('best_model_courant_moteur2_brut.keras')
trained_model_pression = load_model('best_model_pression_brut.keras')

# Définir le seuil de différence entre la valeur lue et la valeur prédite
SEUIL_DIFFERENCE = 1
SEUIL_DIFFERENCE2 = 0.1

# Définir le seuil de la variable courant moteur 1
SEUIL_COURANT_MOTEUR1 = 0.8
SEUIL_COURANT_MOTEUR2 = 0.8
SEUIL_PRESSION = 0.8

# Ouvrir un fichier CSV pour écrire les données des RMS et de la pression RMS
csvfile = open('donnees_rms.csv', 'w', newline='')
fieldnames = ['date', 'timestamp', 'courant_moteur1_rms', 'courant_moteur2_rms', 'charge_moteur1_rms', 'charge_moteur2_rms',
              'temperature_rms', 'humidite_rms', 'pression_rms']
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
writer.writeheader()

# Variables pour stocker les séquences de données
sequence_courant_moteur1 = []
sequence_courant_moteur2 = []
sequence_charge_moteur1 = []
sequence_charge_moteur2 = []
sequence_temperature = []
sequence_humidite = []
sequence_pression = []


# Fonction pour calculer la moyenne quadratique d'une séquence de données
def calculate_rms(sequence):
    rms = np.sqrt(np.mean(np.square(sequence)))
    return rms


# Fonction pour calculer le taux de changement dans une séquence
def taux_de_changement(sequence):
    differences = [abs((sequence[i + 1] - sequence[i]) / sequence[i]) for i in range(len(sequence) - 1)]
    return np.mean(differences)


# Fonction pour prédire les valeurs RMS et la pression RMS sur les nouvelles données générées
def predict_on_generated_data():
    global sequence_courant_moteur1, sequence_courant_moteur2, sequence_charge_moteur1, sequence_charge_moteur2, sequence_temperature, sequence_humidite, sequence_pression

    for data_point in generate_data():
        courant_moteur1, courant_moteur2, charge_moteur1, charge_moteur2, temperature, humidite, pression, timestamp = data_point

        # Ajouter les données à la séquence respective
        sequence_courant_moteur1.append(courant_moteur1)
        sequence_courant_moteur2.append(courant_moteur2)
        sequence_charge_moteur1.append(charge_moteur1)
        sequence_charge_moteur2.append(charge_moteur2)
        sequence_temperature.append(temperature)
        sequence_humidite.append(humidite)
        sequence_pression.append(pression)

        # Vérifier si les séquences ont atteint une taille de 10
        if len(sequence_courant_moteur1) == 10:
            # Calculer les valeurs RMS
            rms_courant_moteur1 = calculate_rms(sequence_courant_moteur1)
            rms_courant_moteur2 = calculate_rms(sequence_courant_moteur2)
            rms_charge_moteur1 = calculate_rms(sequence_charge_moteur1)
            rms_charge_moteur2 = calculate_rms(sequence_charge_moteur2)
            rms_temperature = calculate_rms(sequence_temperature)
            rms_humidite = calculate_rms(sequence_humidite)
            rms_pression = calculate_rms(sequence_pression)

            # Écrire les données RMS normalisées dans le fichier CSV avec la date
            writer.writerow({'date': datetime.now().strftime("%Y-%m-%d"),
                             'timestamp': timestamp,
                             'courant_moteur1_rms': rms_courant_moteur1,
                             'courant_moteur2_rms': rms_courant_moteur2,
                             'charge_moteur1_rms': rms_charge_moteur1,
                             'charge_moteur2_rms': rms_charge_moteur2,
                             'temperature_rms': rms_temperature,
                             'humidite_rms': rms_humidite,
                             'pression_rms': rms_pression})

            # Effacer les séquences pour commencer à enregistrer de nouvelles données
            sequence_courant_moteur1 = sequence_courant_moteur1[5:]
            sequence_courant_moteur2 = sequence_courant_moteur2[5:]
            sequence_charge_moteur1 = sequence_charge_moteur1[5:]
            sequence_charge_moteur2 = sequence_charge_moteur2[5:]
            sequence_temperature = sequence_temperature[5:]
            sequence_humidite = sequence_humidite[5:]
            sequence_pression = sequence_pression[5:]

            # Préparer les données d'entrée normalisées pour la prédiction du courant moteur 1
            input_data_courant_moteur1 = np.array(
                [[rms_courant_moteur1, rms_charge_moteur1, rms_temperature, rms_humidite]])
            input_data_courant_moteur1 = np.expand_dims(input_data_courant_moteur1,
                                                        axis=0)  # Ajouter une dimension pour la longueur de la séquence

            # Effectuer la prédiction pour le courant moteur 1
            prediction_courant_moteur1 = trained_model_courant_moteur1.predict(input_data_courant_moteur1)

            print("Prédiction RMS du courant moteur 1 :", prediction_courant_moteur1[0][0])

            # Calculer la différence entre la valeur prédite et la valeur lue pour le courant moteur 1
            difference_courant_moteur1 = abs(prediction_courant_moteur1[0][0] - rms_courant_moteur1)
            print("Différence entre la valeur prédite et la valeur lue pour le courant moteur 1 :",
                  difference_courant_moteur1)

            # Vérifier si la différence pour le courant moteur 1 dépasse le seuil
            if difference_courant_moteur1 > SEUIL_DIFFERENCE:
                print("Différence entre la valeur prédite et la valeur lue pour le courant moteur 1 dépasse le seuil.")
                # Calculer le taux de changement pour le courant moteur 1
                taux_changement_courant_moteur1 = taux_de_changement(sequence_courant_moteur1)
                print("Taux de changement pour le courant moteur 1 :", taux_changement_courant_moteur1)

                # Calculer le RUL pour le courant moteur 1
                rul_courant_moteur1 = (SEUIL_COURANT_MOTEUR1 - rms_courant_moteur1) / taux_changement_courant_moteur1
                print("RUL pour le courant moteur 1 :", rul_courant_moteur1)

            # Préparer les données d'entrée normalisées pour la prédiction du courant moteur 2
            input_data_courant_moteur2 = np.array(
                [[rms_courant_moteur2, rms_charge_moteur2, rms_temperature, rms_humidite]])
            input_data_courant_moteur2 = np.expand_dims(input_data_courant_moteur2,
                                                        axis=0)  # Ajouter une dimension pour la longueur de la séquence

            # Effectuer la prédiction pour le courant moteur 2
            prediction_courant_moteur2 = trained_model_courant_moteur2.predict(input_data_courant_moteur2)

            print("Prédiction RMS du courant moteur 2 :", prediction_courant_moteur2[0][0])

            # Calculer la différence entre la valeur prédite et la valeur lue pour le courant moteur 2
            difference_courant_moteur2 = abs(prediction_courant_moteur2[0][0] - rms_courant_moteur2)
            print("Différence entre la valeur prédite et la valeur lue pour le courant moteur 2 :",
                  difference_courant_moteur2)

            # Vérifier si la différence pour le courant moteur 2 dépasse le seuil
            if difference_courant_moteur2 > SEUIL_DIFFERENCE:
                print("Différence entre la valeur prédite et la valeur lue pour le courant moteur 2 dépasse le seuil.")
                # Calculer le taux de changement pour le courant moteur 2
                taux_changement_courant_moteur2 = taux_de_changement(sequence_courant_moteur2)
                print("Taux de changement pour le courant moteur 2 :", taux_changement_courant_moteur2)

                # Calculer le RUL pour le courant moteur 2
                rul_courant_moteur2 = (SEUIL_COURANT_MOTEUR2 - rms_courant_moteur2) / taux_changement_courant_moteur2
                print("RUL pour le courant moteur 2 :", rul_courant_moteur2)

            if difference_courant_moteur1 <= SEUIL_DIFFERENCE and difference_courant_moteur2 <= SEUIL_DIFFERENCE:

                # Préparer les données d'entrée normalisées pour la prédiction de la pression
                input_data_pression = np.array([[rms_courant_moteur1, rms_courant_moteur2, rms_temperature, rms_humidite, rms_pression]])
                input_data_pression = np.expand_dims(input_data_pression,axis=0)  # Ajouter une dimension pour la longueur de la séquence

                # Effectuer la prédiction pour la pression
                prediction_pression = trained_model_pression.predict(input_data_pression)

                print("Prédiction RMS de la pression :", prediction_pression[0][0])

                # Calculer la différence entre la valeur prédite et la valeur lue pour la pression
                difference_pression = abs(prediction_pression[0][0] - rms_pression)
                print("Différence entre la valeur prédite et la valeur lue pour la pression :", difference_pression)

                # Vérifier si la différence pour la pression dépasse le seuil
                if difference_pression > SEUIL_DIFFERENCE2:
                    print("Différence entre la valeur prédite et la valeur lue pour la pression dépasse le seuil.")
                    # Calculer le taux de changement pour la pression
                    taux_changement_pression = taux_de_changement(sequence_pression)
                    print("Taux de changement pour la pression :", taux_changement_pression)

                    # Calculer le RUL pour la pression
                    rul_pression = (SEUIL_PRESSION - rms_pression) / taux_changement_pression
                    print("RUL pour la pression :", rul_pression)

        time.sleep(1)


# Fonction pour générer aléatoirement des données de courants moteurs, température, humidité et pression
def generate_data():
    while True:
        courant_moteur1 = random.uniform(0, 10)  # Générer un courant moteur 1 aléatoire
        courant_moteur2 = random.uniform(0, 10)  # Générer un courant moteur 2 aléatoire
        charge_moteur1 = random.uniform(4, 5)  # Générer une première charge moteur aléatoire
        charge_moteur2 = random.uniform(4, 5)  # Générer une deuxième charge moteur aléatoire
        temperature = random.uniform(24, 34)  # Générer une température aléatoire
        humidite = random.uniform(60, 98)  # Générer une humidité aléatoire
        pression = random.uniform(0, 5)  # Générer une pression aléatoire
        timestamp = datetime.now().strftime("%H:%M:%S")  # Obtenir le timestamp actuel

        # Normaliser les données
        normalized_courant_moteur1 = (courant_moteur1 - 0) / (10 - 0)
        normalized_courant_moteur2 = (courant_moteur2 - 0) / (10 - 0)
        normalized_charge_moteur1 = (charge_moteur1 - 4) / (5 - 4)
        normalized_charge_moteur2 = (charge_moteur2 - 4) / (5 - 4)
        normalized_temperature = (temperature - 24) / (34 - 24)
        normalized_humidite = (humidite - 60) / (98 - 60)
        normalized_pression = (pression - 0) / (5 - 0)

        yield normalized_courant_moteur1, normalized_courant_moteur2, normalized_charge_moteur1, normalized_charge_moteur2, normalized_temperature, normalized_humidite, normalized_pression, timestamp
        time.sleep(1)  # Attendre une seconde avant de générer les prochaines données


# Lancer la prédiction sur les données générées
predict_on_generated_data()

i tried to create paths for http requests using flask, but i won’t work