from machine import Pin, I2C
from HX711 import HX711
from MPU6050 import MPU6050
import sav
from com import CSCService  # Import du module BLE
import time
import json

# Def pins
with open("cst.json", "r") as fichier:
    pins = json.load(fichier)["Pins"]
    SCL = pins["MPU6050"]["SCL"]
    SDA = pins["MPU6050"]["SDA"]
    DOUT = pins["HX711"]["DOUT"]
    SCK = pins["HX711"]["SCK"]
pin_OUT = Pin(DOUT, Pin.IN, pull=Pin.PULL_DOWN)
pin_SCK = Pin(SCK, Pin.OUT)
i2c = I2C(0, scl=Pin(SCL), sda=Pin(SDA))
hx711 = HX711(pin_SCK, pin_OUT)
mpu = MPU6050(i2c)

# Def variables 
dernier_affichage = time.time()
temperature_initiale = mpu.read_temperature()
with open("cst.json", "r") as fichier:
    constantes = json.load(fichier)["Constantes"]
    a = constantes["Coefficient thermique"]
    m = constantes["Coefficient unites"]
    maj = constantes["Intervalle de mise a jour (s)"]

# Tare et echelle du HX711
hx711.set_scale(m) # m valeurs/N
hx711.tare()

# Range du gyroscope
mpu.set_gyro_range(0x10)  # Sensibilité du gyroscope : ±250°/s0
#   Plage (°/s)	    Code (hexadécimal)
#    ±250	          0x00
#    ±500	          0x08
#    ±1000	          0x10
#    ±2000	          0x18
'''
# Initialisation du service BLE
communication_BLE = CSCService()
communication_BLE.start_advertising()
'''

# Variables pour le calcul des révolutions
cumulative_angle = 0  # Angle total accumulé (en degrés)
cumulative_revolutions = 0  # Révolutions accumulées
last_update_time = time.time()

try:
    while True:
        current_time = time.time()
        
        # HX711 capteurs
        valeur = hx711.read_average(times = 10)
        force = (valeur - hx711.OFFSET) / hx711.SCALE
        # MPU6050 capteurs
        gyro_data = mpu.read_gyro_data()  # Vitesses angulaires en °/s
        
        # Calcul de l'angle parcouru pendant delta_time
        delta_time = current_time - last_update_time  # Temps écoulé depuis la dernière mise à jour
        angular_velocity_z = gyro_data['z']  # Utilisation de l'axe Z pour le pédalier
        delta_angle = angular_velocity_z * delta_time  # Angle en degrés
        cumulative_angle += delta_angle
    
        # Vérification des révolutions complètes
        if cumulative_angle >= 360:
            cumulative_revolutions += int(cumulative_angle // 360)
            cumulative_angle %= 360  # Conserver le reste pour l'angle accumulé

        # Mise à jour des données BLE toutes les `maj` secondes
        if current_time - dernier_affichage >= maj:

            temperature = mpu.read_temperature()
            force_temp = force - a * (temperature - temperature_initiale)
            # Calcul de la cadence en RPM
            cadence_rpm = angular_velocity_z * (1/6)
            
            sauvgarde = {
                "Temps": current_time,
                "Temperature": temperature,
                "Cadence": cadence_rpm,
                "Force": force_temp
                        }
            #sav.ecrire_donnees_json_async(sauvgarde)

            # Affichage des données
            print("=" * 30)
            print(f"Révolutions accumulées : {cumulative_revolutions}")
            print(f"Cadence : {cadence_rpm:.0f} RPM")
            print(f"Température : {temperature:.0f} C")
            print(f"HX711 : {valeur:.0f}")
            print(f"HX711 unit : {force:.0f}")
            print(f"HX711 unit ajusté à la température : {force_temp:.0f}")
            print("=" * 30, '\n')

    
            '''
            # Mise à jour des données BLE
            power = int(valeur)
            crank_revs = cumulative_revolutions
            crank_time = int((current_time * 1024) % 0x10000)  # Horodatage en unités de 1/1024 sec

            communication_BLE.send_measurement(crank_revs, crank_time, power)

            # Réinitialisation pour le prochain intervalle
            cumulative_revolutions = 0
            '''
            dernier_affichage = current_time
        last_update_time = current_time

except KeyboardInterrupt:
    print("\nArrêt du programme.")