#la resistenza da mettere in serie per ottenere la tensione,è gi aposta all'interno del termistore su wokwi(nella realta bisogna porre noi la Rs)


from struct import pack, unpack
from machine import ADC, Pin, UART
from time import sleep,ticks_ms,ticks_diff
from machine import Pin,I2C
import ssd1306
from math import log

def calcola_media(buffer):
    media=None
    buffer.append(T)
    if(len(buffer)==5):
        media=sum(buffer)/5
        print("la media e ",media)
        buffer.clear()
    return media

#FUNZIONI SULL'ADC

def analogSensor_init(p):
    s = ADC(Pin(p))
    s.atten(ADC.ATTN_11DB)
    return s


def get_analogValue(s):
    level = s.read()
    analog = level * 3.6/ 4095 #usiamo la V_ref che è 3.3 o 3.6
    return analog, level


def find_peaks(d, peak_buffer, th):
    
    peak_buffer.append(d)
    
    if len(peak_buffer) < 3:
        return None

    if peak_buffer[1] > th and peak_buffer[1] > peak_buffer[0] and peak_buffer[1] > peak_buffer[2]:
        peak = peak_buffer[1]
    else:
        peak = None

    peak_buffer.pop(0)

    return peak


def pinLED_init(p):
    l = Pin(p, Pin.OUT)
    l.value(0)
    return l


def blinkLed (l):
    l.value(1)
    sleep(0.01)
    l.value(0)

def initButton(p):
    button=Pin(p,Pin.IN)
    return button    


#FUNZIONI SU COMUNICAZIONE SERIALE

def serialReceiver_init():
    uart = UART(1, baudrate=9600, tx=Pin(33), rx=Pin(32))
    return uart

def serialSender_init():
    uart = UART(2, baudrate=9600, tx=Pin(17), rx=Pin(16))
    return uart

def send_data(data, uart):
    data = int(data)
    data_bytes = pack('!H', data) # Converte un valore intero in 2 byte big-endian
    uart.write(data_bytes) # Invia i byte tramite UART

def receive_data(uart):
    number = None
    n= uart.any() 
    if n >= 2: # Controlla se ci sono dati disponibili
        data = uart.read(2) # Legge i 2 byte più vecchi del buffer UART
        number = unpack('!H', data)[0] # Decodifica i byte in intero (big-endian, 2 byte)
    return number

def receive_last_data(uart):
    number = None
    n= uart.any() 
    if n >= 2: # Controlla se ci sono dati disponibili
        if n > 2:
            uart.read(n-2) #Se ci sono piu di 2 byte, legge (e scarta) i primi n-2
        data = uart.read(2) # Legge i 2 byte rimasti nel buffer UART
        number = unpack('!H', data)[0] # Decodifica i byte in intero (big-endian, 2 byte)
    return number


#FUNZIONI SU DISPLAY


def init_display():
    i2c=I2C(0,sda=Pin(19),scl=Pin(18))
    display=ssd1306.SSD1306_I2C(128,64,i2c)
    return display


sensor=analogSensor_init(32)
display=init_display()

t="by gio e simox"; x=(128-len(t)*8)//2; y=54-len(t)//2
display.fill(0); 
display.text(t,x+1,y+1); 
display.text(t,x,y); 
display.hline(x,y+10,len(t)*8,1); 
display.show()
 

while True:

    t1=ticks_ms()

    analog_value,level=get_analogValue(sensor)
    print(f"Raw:{level}       Voltage:{analog_value:.2f}")

    display.fill_rect(0,0,128,12,0)
    display.fill_rect(0,20,128,12,0)

    display.text(f"Raw: {level}",0,0,1)
    display.fill_rect(0,20,128,12,0)
    display.text(f"Voltage: {analog_value:.2f}",0,20,1)
    display.show()
    
    t2=ticks_ms()

    sleep(1/10-(ticks_diff(t1,t2)/1000))