DIY: Tisch-Uhr mit e-Ink-Display (Waveshare Pico e-Paper 3.7) und Raspberry Pi Pico

from Pico_ePaper import Eink
import framebuf
from writer import Writer
import utime
from utime import sleep
from machine import RTC
import gc
import time
from fonts import inter_bold_44
import machine
import network
import urequests
import network
import sys
import time
import usocket as socket
import ustruct as struct

import img.n0 as n0
import img.n1 as n1
import img.n2 as n2
import img.n3 as n3
import img.n4 as n4
import img.n5 as n5
import img.n6 as n6
import img.n7 as n7
import img.n8 as n8
import img.n9 as n9
import img.space as space

import img.line1 as line1
import img.line2 as line2

ssid = 'YOUR_SSID'
password = 'YOUR_PASSWORD'

class DummyDevice(framebuf.FrameBuffer):
    def __init__(self, width, height, buf_format):
        self.width = width
        self.height = height
        self._buf = bytearray(self.width * self.height // 8)
        super().__init__(self._buf, self.width, self.height, buf_format)
        self.fill(1)

def display_digit(image, x, y):
    img_tmp = framebuf.FrameBuffer(image.img_bw, image.width, image.height, framebuf.MONO_HLSB)
    epd.blit(img_tmp, x, y)

def fetch_weather_data():
    url = "https://api.open-meteo.com/v1/forecast?latitude=52.028953201377355&longitude=8.533312390444614&current=temperature_2m&daily=temperature_2m_max&timezone=Europe%2FBerlin&forecast_days=1"
    response = urequests.get(url)

    if response.status_code == 200:
        weather_data = response.json()
        response.close()
        return weather_data
    else:
        print("Fehler bei der API-Anfrage. Status-Code:", response.status_code)
        response.close()
        return None

def fetch_power_data():
    url = "YOUR_API_URL"
    response = urequests.get(url)

    if response.status_code == 200:
        power_data = response.json()
        response.close()
        return power_data
    else:
        print("Fehler bei der API-Anfrage. Status-Code:", response.status_code)
        response.close()
        return None    

def display_text(writer, text, x, y):
    Writer.set_textpos(dummy, x, y)
    writer.set_clip(row_clip=True, col_clip=True, wrap=True)
    writer.printstring(text, invert=True)

# Winterzeit / Sommerzeit
GMT_OFFSET = 3600 * 1 # 3600 = 1 h (Winterzeit)
#GMT_OFFSET = 3600 * 2 # 3600 = 1 h (Sommerzeit)

# NTP-Host
NTP_HOST = 'pool.ntp.org'

# Funktion: WLAN-Verbindung
def wlanConnect():
    wlan = network.WLAN(network.STA_IF)
    if not wlan.isconnected():
        print('WLAN-Verbindung herstellen')
        wlan.active(True)
        wlan.connect(ssid, password)
        for i in range(10):
            if wlan.status() < 0 or wlan.status() >= 3:
                break
            print('.')
            time.sleep(1)
    if wlan.isconnected():
        print('WLAN-Verbindung hergestellt / WLAN-Status:', wlan.status())
    else:
        print('Keine WLAN-Verbindung')
        print('WLAN-Status:', wlan.status())

# Funktion: Zeit per NTP holen
def getTimeNTP():
    NTP_DELTA = 2208988800
    NTP_QUERY = bytearray(48)
    NTP_QUERY[0] = 0x1B
    addr = socket.getaddrinfo(NTP_HOST, 123)[0][-1]
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    try:
        s.settimeout(1)
        res = s.sendto(NTP_QUERY, addr)
        msg = s.recv(48)
    finally:
        s.close()
    ntp_time = struct.unpack("!I", msg[40:44])[0]
    return time.gmtime(ntp_time - NTP_DELTA + GMT_OFFSET)

# Funktion: RTC-Zeit setzen
def setTimeRTC():
    # NTP-Zeit holen
    tm = getTimeNTP()
    machine.RTC().datetime((tm[0], tm[1], tm[2], tm[6] + 1, tm[3], tm[4], tm[5], 0))

# WLAN-Verbindung herstellen
wlanConnect()

# Zeit setzen
setTimeRTC()

epd = Eink(rotation=180)

# Zeitstempel für die Aktualisierung
last_update = 0

while True:
    
    rtc = RTC()
    datetime = rtc.datetime()
    
    gc.collect()
    gc.mem_free()

    # Überprüfen, ob seit der letzten Aktualisierung 5 Minuten vergangen sind
    current_time = utime.time()
    
    if current_time - last_update >= 300:
        
        img_tmp = framebuf.FrameBuffer(space.img_bw, space.width, space.height, framebuf.MONO_HLSB)
        epd.blit(img_tmp, 30, 340)
        epd.blit(img_tmp, 143, 340)
        
        # WLAN-Verbindung herstellen
        wlanConnect()

        # Wetterdaten abrufen
        weather_data = fetch_weather_data()

        if weather_data:
            
            current_temperature_2m = weather_data["current"]["temperature_2m"]
            daily_temperature_2m_max = weather_data["daily"]["temperature_2m_max"][0]

            print("Aktuelle Temperatur_2m:", current_temperature_2m, "°C")
            print("Tägliche Temperatur_2m_max:", daily_temperature_2m_max, "°C")
            
            gc.collect()
            gc.mem_free()
            print("Speicherverbrauch nach manueller GC:", gc.mem_alloc() / 1024, "KiB")

            dummy = DummyDevice(epd.width, epd.height, framebuf.MONO_HLSB)
            wri = Writer(dummy, inter_bold_44)

            display_text(wri, f'{current_temperature_2m}', 346, 35)
            display_text(wri, f'{daily_temperature_2m_max}', 346, 141)

            epd.blit(dummy, 0, 0, key=1, ram=epd.RAM_BW)
               
            gc.collect()
            gc.mem_free()
            print("Speicherverbrauch nach manueller GC:", gc.mem_alloc() / 1024, "KiB")

            # Zeitstempel für die letzte Aktualisierung aktualisieren
            last_update = current_time

        '''
        # Stromdaten abrufen
        power_data = fetch_power_data()
        
        if power_data:
            
            now = power_data["now"]
            total_sun_day = power_data["total_sun_day"]
            
            gc.collect()
            gc.mem_free()
            print("Speicherverbrauch nach manueller GC:", gc.mem_alloc() / 1024, "KiB")

            dummy = DummyDevice(epd.width, epd.height, framebuf.MONO_HLSB)
            wri = Writer(dummy, inter_bold_44)

            display_text(wri, f'{now}', 406, 35)
            display_text(wri, f'{total_sun_day}', 406, 141)
            
            epd.blit(dummy, 0, 0, key=1, ram=epd.RAM_BW)
                
            gc.collect()
            gc.mem_free()
            print("Speicherverbrauch nach manueller GC:", gc.mem_alloc() / 1024, "KiB")

        '''       
  
    hour_first_digit = datetime[4] // 10
    hour_second_digit = datetime[4] % 10
    display_digit(eval(f'n{hour_first_digit}'), 30, 50)
    display_digit(eval(f'n{hour_second_digit}'), 30 + eval(f'n{hour_first_digit}').width, 50)
    display_digit(space, 30 + eval(f'n{hour_first_digit}').width + eval(f'n{hour_second_digit}').width, 50)

    minute_first_digit = datetime[5] // 10
    minute_second_digit = datetime[5] % 10
    display_digit(eval(f'n{minute_first_digit}'), 30, 50 + eval(f'n{hour_first_digit}').height)
    display_digit(eval(f'n{minute_second_digit}'), 30 + eval(f'n{minute_first_digit}').width, 50 + eval(f'n{hour_first_digit}').height)
    display_digit(space, 30 + eval(f'n{minute_first_digit}').width + eval(f'n{minute_second_digit}').width, 50 + eval(f'n{hour_first_digit}').height)

    img_tmp = framebuf.FrameBuffer(line1.img_bw, line1.width, line1.height, framebuf.MONO_HLSB)
    epd.blit(img_tmp, 10, 340)
    
    '''
    img_tmp = framebuf.FrameBuffer(line2.img_bw, line2.width, line2.height, framebuf.MONO_HLSB)
    epd.blit(img_tmp, 10, 400)
    '''

    gc.collect()
    gc.mem_free()
    print("Speicherverbrauch nach manueller GC:", gc.mem_alloc() / 1024, "KiB")

    epd.show()
    epd.sleep()
    sleep(60)
    epd.reinit()