Poeles-Dragon-Calculator/bin/data.py

import bin.functions as fc
import numpy as np
import os
import time


class Arduino_data():

    def __init__(self):
        self.nb_captor_signals = 0
        self.data_file_path = ''
        self.data_array = np.empty((1,1))
        self.data_path_dir = os.path.abspath(os.path.dirname(__file__)) + "/../data"
        if(not(os.path.isdir(self.data_path_dir))): #creer dossier si non existant
            os.mkdir(self.data_path_dir, 0o777)
        self.raw_data_temp = [[]]
        self.captors = []


    def add_captors_from_file(self, file):
        """Importation, à partir d'un fichier, des capteurs déjà enregistrés."""
        try: # ouverture fichier
            captors_file = open(file, "r")
        except: # si fichier non existant, création du fichier et ajout de capteur
            print("Le fichier des capteurs n'existe pas encore. Ajoutez au moins 1 capteur:\n")
            captors_file = open(file,"w") #création du fichier
            captors_file.close()
            self.add_captor_manually(file)
        else: # fichier existant
            lines = captors_file.readlines()
            self.nb_captor_signals = len(lines)
            if(self.nb_captor_signals == 0):
                captors_file.close()
                print("Ajoutez au moins 1 capteur avant de commencer:\n")
                self.add_captor_manually(file)
                captors_file = open(file, "r")
                lines = captors_file.readlines()
                self.nb_captor_signals = len(lines)
            self.data_array = np.empty((1,self.nb_captor_signals))
            for i in range(self.nb_captor_signals):
                captor_line = lines[i]
                capt = Captor_data();
                capt.read_captor(captor_line)
                self.captors.append(capt)
            captors_file.close()
            self.raw_data_temp = np.empty((1,self.nb_captor_signals))

    def add_captor_manually(self, file):
        """Ajout manuel de capteurs (nom, unité, type de données (raw/real))"""
        self.nb_captor_signals += 1
        capt = Captor_data()

        coma = ","
        capt.captor_name = str(input("Nom du capteur : "))
        while(capt.captor_name.find(coma) != -1):
            capt.captor_name = str(input("Nom du capteur ("," non accepté): "))
        capt.unit = str(input("Unité : "))
        while(capt.unit.find(coma) != -1):
            capt.unit = str(input("Unité (\",\" non accepté): "))
        capt.data_type = -1
        while(capt.data_type <= -1 or capt.data_type >= 2):
            capt.data_type = int(input("Type de données : 0 (raw) ou 1 (real): "))
        self.captors.append(capt)

        captors_file = open(file, "a")
        captors_file.write(capt.captor_file_line())
        captors_file.close()
        np.append(self.raw_data_temp, [])
        self.data_array = np.empty((1,self.nb_captor_signals))
        print("Capteur ajouté")

    def captors_print_list(self, file):
        """Affichage des capteurs listés dans le fichier, dans l'ordre"""
        captors_file = open(file, "r")
        print("              Nom      Unit  Type(raw/real)")
        for i in range(self.nb_captor_signals):
            print("Capteur n°" + str(i+1) + " : " + str(captors_file.readline()))
        captors_file.close()

    def del_captor(self, file):
        """Suppression d'un capteur"""
        self.captors_print_list(file)
        captor_to_del = int(input("\nNumero du capteur a supprimer : "))-1
        del self.captors[captor_to_del-1]
        captors_file = open(file, "r")
        lines = captors_file.readlines();
        captors_file.close()
        captors_file = open(file, "w")
        for i in range(self.nb_captor_signals):
            if(i != captor_to_del):
                captor_line = lines[i]
                captors_file.write(captor_line)
            else:
                break;
        captors_file.close()
        self.nb_captor_signals = self.nb_captor_signals-1

    def change_captors_order(self, file):
        """Changement de l'ordre des capteurs, pour correspondre à l'ordre des
        valeurs correspondantes aux capteurs de l'Arduino"""
        capt_temp = self.captors[:]
        self.captors_print_list(file)
        captors_file = open(file, "r")
        lines = captors_file.readlines();
        captors_file.close()
        captors_order = []
        print("Assigner ligne par ligne les anciens numéros de capteur à leur nouvelle place:")
        for i in range(self.nb_captor_signals):
            captors_order.append(int(input("nouveau n°" + str(i+1) + " : ancien n° : ")))

        captors_file = open(file, "w")
        for i in range(self.nb_captor_signals):
            self.captors[i] = capt_temp[captors_order[i]-1]
            captor_line = lines[captors_order[i]-1]
            captors_file.write(captor_line)
        captors_file.close()
        print("\nNouvel ordre des capteurs")
        self.captors_print_list(file)

    def extract_data_to_array(self, raw_data_txt):
        """Lecture d'une ligne envoyée par Arduino, et parsing des données
        par rapport aux virgules dans un tableau"""
        coma = ","
        coma_places = raw_data_txt.find(coma)
        if(type(coma_places) == type(int())):
            coma_places = [coma_places]
        if(coma_places == -1 and len(raw_data_txt) < 2):
            print("Donnees non transmises par l'Arduino.")
        elif(coma_places == -1 and len(raw_data_txt) > 2):
            raw_data_temp[0,0] = int(raw_data_txt)
        if(len(coma_places) != self.nb_captor_signals-1):
            if(len(coma_places) < self.nb_captor_signals-1):
                print("Il y a moins de donnees transmises que de capteurs. Vérifiez les donnees transmises.")
            else:
                print("Il y a plus de donnees transmises que de capteurs.\nLes " + str(len(coma_places)-self.nb_captor_signals-1) + " donnees de fin seront supprimees")
        else:
            # insertion de la place du début et de la fin du string
            coma_places.insert(0,-1)
            coma_places.append(len(raw_data_txt))
            for i in range(min(len(coma_places)-1, self.nb_captor_signals)):
                self.raw_data_temp[0,i] = int(raw_data_txt[coma_places[i]+1:coma_places[i+1]])
            self.data_array = np.append(self.data_array, self.raw_data_temp, axis=0)

    def create_data_file(self):
        """Création du fichier csv où sont enregistrées les données, avec comme nom
        l'horodatage du fichier"""
        self.data_file_path = self.data_path_dir + "/" + time.asctime()+".csv"
        file = open(self.data_file_path,"w") #mode append
        file.close()

    def append_data_to_file(self, data):
        """Écriture, à la fin du fichier csv, des données tampon"""
        file = open(self.data_file_path,"a") #mode append
        file.write(data)
        file.close()




class Captor_data():

    def __init__(self):
        self.captor_name = ""
        self.unit = ""
        self.data_type = 0 #type possibles : donnee brute raw a convertir (0), donnees reelles utilisables en l'etat (1)

    def set_captor_name(self, name):
        self.captor_name = name

    def set_unit(self, unit):
        self.unit = unit

    def set_data_type(self, data_type):
        self.data_type = data_type

    def read_captor(self, line):
        for j in range(3):
            carac_coma_nb = 1
            while((line[carac_coma_nb] != ',') and (line[carac_coma_nb:carac_coma_nb+2] != "\n")): #fin de la donnee ou de la ligne
                carac_coma_nb +=1
            if(j == 0):
                self.captor_name = line[0:carac_coma_nb]
            elif(j == 1):
                self.unit = line[0:carac_coma_nb]
            elif(j == 2):
                self.data_type = int(line[0:carac_coma_nb])
            line = line[carac_coma_nb+1:]

    def captor_string(self):
        type_txt = ["raw", "real"]
        return self.captor_name + "(" + self.unit + " " + type_txt[self.data_type] + ")"

    def captor_file_line(self):
        return self.captor_name + "," + self.unit + "," + str(self.data_type) + "\n"