Fitness-uhr

- auf dem runden 1.28-Zoll-IPS-LCD-Display 240 x 240 Pixel
- nutzt den ACC Beschleunigungssensor in Micropython

Hardware

- Rundes 1,28-Zoll-IPS-LCD-Display
- RP Pico 2040 (inclusive)
- USB-A zu USB-C Kabel
- 3.7V 100mAh Lithium Polymer Akku (z.B. von hier)

Es wird wieder der 3-Achsen ACC Sensor genutzt, wie schon in der 1. Anleitung, um die Schritte zu zählen. Zuätzlich wird in dieser Anleitung die exakte Uhrzeit, auch wenn das Gerät nicht am PC angeschlossen ist, angezeigt. Dazu wird diese auf dem Pico-Laufwerk gespeichert und zur Stromversorgung wird ein kleiner Akku ins Gehäuse integriert. Es geht also
- um die Stromversorgung beim runden Pico-LCD-Display mit einem kleinen 3.7V 100mAh Lithium Polymer Akku
- um die exakte Erfassung der Zeit auf Basis des Prozessortaktes (unabhängig von time.sleep()) und,
- um Schreib- und Lesevorgänge unter Micropython beim Pico.

Los gehts

1.

Ich gehe als erstes auf die Stromversorgung ein. Der vorgeschlagene 3,7 V Litium-Polymer Akku mit 100 mAh ist größenmäßig gut in ein Uhrengehäuse integrierbar. Im Betrieb fließen beim runden Pico-LCD-Display etwa 60 mA Strom, so dass die Akkukapazität ohne nachladen für ca. 1,5 Stunden reicht. Zum Aufladen kann die Fitnessuhr ohne Funktionsunterbrechung an den USB-C Anschluss angeschlossen werden. So gesehen besser als beim E-Auto. Die Fitnessuhr muss zwar auch häufig an die "Ladesäule" aber braucht dabei nicht mal anzuhalten.

Ganz wichtig: Ein Anbieter der Displays hat darauf hingewiesen, dass der Batterieanschluss ein wenig gebräuchlicher MX1.25-Stecker mit 1.25 mm Rastermaß ist. Den passenden Stecker habe ich (z.B. hier bestellt). Zu beachten ist, dass bei der Richtung, wie der Stecker in die Inline-Buchse am Display kommt, die Farbkennzeichnung der Polung verkehrt ist. Dass bedeuted, dass Sie beim Anlöten der Kabel an den Akku bewußt schwarz auf rot und rot auf schwarz löten müssen. Bei meinen gelieferten Kabeln war es auf jeden Fall so!

Bildbox (klick hier)
2.

Weiter geht es mit dem Einrichten der Uhrfunktion. Der Programmanfang stimmt mit dem in der vorherigen Anleitung überein ( wird am Ende noch einmal komplett zum Kopieren eingefügt). Ab Zeile 93 werden zwei Funktionen definiert, die den Bildschirm aufbauen.

  
def refresh():
    # Hintergrundbildschirm
    LCD.fill(LCD.black)
    circle(120,120,114,LCD.beige)
    circle(120,120,86,LCD.black)
    circle(120,120,75,LCD.darkgray)
    ring(step,ziel)
    printstring("Schritte",90,90,1,LCD.white)
    triangle2(x3,y3,x4,y4)
    LCD.fill_rect(30,210,160,50,LCD.black)
    triangle1(x1,y1,x2,y2)
    # Spannung in % anzeigen anzeigen
    LCD.rect(90,220,30,10,LCD.white)
    LCD.rect(120,222,2,5,LCD.white)
    LCD.fill_rect(92,222,24,6,LCD.glade)
    reading = Vbat.read_u16()*3.3/65535*2
    printstring(str(int(reading/4.5*100)) + " %",130,220,1,LCD.white)
    LCD.show()

def ring(step,ziel):
    for i in range (step*120/ziel):
        xpos_neu = int(width/2 + 100*math.cos((i/2+15)*math.pi/30))
        ypos_neu = int(height/2 + 100*math.sin((i/2+15)*math.pi/30))
        circle(xpos_neu,ypos_neu,17,LCD.red)
        time.sleep(0.01)
        LCD.show()


93  def refresh():
94     # Hintergrundbildschirm
95     LCD.fill(LCD.black)
96     circle(120,120,114,LCD.beige)
97     circle(120,120,86,LCD.black)
98     circle(120,120,75,LCD.darkgray)
99     ring(step,ziel)
100     printstring("Schritte",90,90,1,LCD.white)
101     triangle2(x3,y3,x4,y4)
102     LCD.fill_rect(30,210,160,50,LCD.black)
103     triangle1(x1,y1,x2,y2)
104     # Spannung in % anzeigen anzeigen
105     LCD.rect(90,220,30,10,LCD.white)
106     LCD.rect(120,222,2,5,LCD.white)
107     LCD.fill_rect(92,222,24,6,LCD.glade)
108     reading = Vbat.read_u16()*3.3/65535*2
109     printstring(str(int(reading/4.5*100)) + " %",130,220,1,LCD.white)
110     LCD.show()
111
112 def ring(step,ziel):
113     for i in range (step*120/ziel):
114         xpos_neu = int(width/2 + 100*math.cos((i/2+15)*math.pi/30))
115         ypos_neu = int(height/2 + 100*math.sin((i/2+15)*math.pi/30))
116         circle(xpos_neu,ypos_neu,17,LCD.red)
117         time.sleep(0.01)
118         LCD.show()

Danach werden Werte aus der Datei 'last_time.txt' vom Pico-Laufwerk gelesen. Darin ist die Stunde und Minute der letzten bekannten Uhrzeit und die Anzahl der Schritte abgelegt. In diesem Teil des Programms wird auch ermittelt, ob der Pico am PC angeschlossen ist. Wenn ja, liefert 'time.localtime()' die aktuelle Uhrzeit an das Tupel 'current_time'. Diese wird in den Zeilen 141 bis 150 sofort neu in die Datei gespeichert. Ist hingegen 'current_time[0]=2021', dann bedeuted das, dass der Pico ohne Rechneranschluss gestartet wurde. 'time.localtime()' beginnt in diesem Fall am 1.1.2021 die Sekunden zu zählen. Für die Stunde und die Minuten wird dann die letzte bekannte Zeit verwendet. Wenn man also den USB Anschluss des Pico vom Rechner abzieht und innerhalb einer Minute an eine andere Spannungsversorgung anklemmt, verliert man max. eine Minute, die man ja im Bereich der Zeilen 151 bis 157 hinzuaddieren könnte. Ist hingegen der Akku angeschlossen, kommt es zu keiner Unterbrechung, also auch zu keinem Zeitverlust, da der Timer nicht neu startet.

  
# Schritte auslesen
with open("last_time.txt", "r") as f:
    hour = int(f.readline())
    minute = int(f.readline())
    step = int(f.readline())
f.close()

current_time = time.localtime()
hour = current_time[3]
minute = current_time[4]
second = current_time[5]
if current_time[0] > 2021:
    with open("/last_time.txt", "w") as f:
        f.write(str(hour)+"\n")
        f.write(str(minute)+"\n")
        f.write(str(step))
    f.close()
if current_time[0] == 2021:
    with open("last_time.txt", "r") as f:
        hour = int(f.readline())
        minute = int(f.readline())
        step = int(f.readline())
    f.close()
    second = current_time[5]

refresh()
start = time.ticks_ms()


134 # Schritte auslesen
135 with open("last_time.txt", "r") as f:
136     hour = int(f.readline())
137     minute = int(f.readline())
138     step = int(f.readline())
139 f.close()
140
141 current_time = time.localtime()
142 hour = current_time[3]
143 minute = current_time[4]
144 second = current_time[5]
145 if current_time[0] > 2021:
146     with open("/last_time.txt", "w") as f:
147         f.write(str(hour)+"\n")
148         f.write(str(minute)+"\n")
149         f.write(str(step))
150     f.close()
151 if current_time[0] == 2021:
152     with open("last_time.txt", "r") as f:
153         hour = int(f.readline())
154         minute = int(f.readline())
155         step = int(f.readline())
156     f.close()
157     second = current_time[5]
158
159 refresh()
160 start = time.ticks_ms()

3.

In Zeile 160 wird die Variable Start mit time.ticks_ms() gesetzt. Damit wird später in der while Schleife nach 5 Minuten (300 s) der Bildschirm refreshed, wodurch wieder der aktuelle Batteriezustand angezeigt wird. In der 'while' Schleife erfolgt dann das Auslesen des Sensors und die Zeitanzeige. Wenn die Sekunde 59 erreicht ist, wird hochgezählt und die Stunde, Minute und Schritte in der Datei aktualisiert. Damit der Speichervorgang in der Sekunde 59 nicht mehrfach ausgeführt wird, ist in Zeile 194 eine Pause von 1s, die aber auf den Sekundentakt von 'time.localtime()' keinen Einfluss hat. Es kommt also nicht zu einer Zeitverspätung.

  
    if second == 59:
        printstring(zeit,50,120,3,LCD.darkgray)
        minute += 1
        if minute == 60:
            minute = 0
            hour += 1
            if hour == 24:
                hour = 0
        with open("/last_time.txt", "w") as f:
            f.write(str(hour)+"\n")
            f.write(str(minute)+"\n")
            f.write(str(step))
        f.close()
        time.sleep(1)
    zeit = str(hour) + ":" + str(minute)
    if minute < 10:
        zeit = str(hour) + ":0" + str(minute)
    printstring(zeit,50,120,3,LCD.white)
    meter = int(step * 0.762)
    printstring(str(meter)+" m",105,175,1,LCD.white)
    #cal = int(int(step * 0.38)*4.18)/1000
    cal = int(int(step * 0.38)*4.18)
    printstring(str(cal)+" J",105,190,1,LCD.white)
    if second < 10:
        printstring(":0" + str(second),157,123,2,LCD.white)
    else:
        printstring(":" + str(second),157,123,2,LCD.white)
    LCD.show()


181     if second == 59:
182         printstring(zeit,50,120,3,LCD.darkgray)
183         minute += 1
184         if minute == 60:
185             minute = 0
186             hour += 1
187             if hour == 24:
188                 hour = 0
189         with open("/last_time.txt", "w") as f:
190             f.write(str(hour)+"\n")
191             f.write(str(minute)+"\n")
192             f.write(str(step))
193         f.close()
194         time.sleep(1)
195     zeit = str(hour) + ":" + str(minute)
196     if minute < 10:
197         zeit = str(hour) + ":0" + str(minute)
198     printstring(zeit,50,120,3,LCD.white)
199     meter = int(step * 0.762)
200     printstring(str(meter)+" m",105,175,1,LCD.white)
201     #cal = int(int(step * 0.38)*4.18)/1000
202     cal = int(int(step * 0.38)*4.18)
203     printstring(str(cal)+" J",105,190,1,LCD.white)
204     if second < 10:
205         printstring(":0" + str(second),157,123,2,LCD.white)
206     else:
207         printstring(":" + str(second),157,123,2,LCD.white)
208    LCD.show()

In den Zeilen 209 bis 236 wird die Bewegung des Sensors, wie bereits aus der 1. Anleitung bekannt, erfasst. Wie versprochen gebe ich jetzt noch einmal den kompletten Programmcode zu Kopieren an. Klicken Sie dazu auf die Schaltfläche 'Code kopieren' und setzen ihn im Thonny ein. Bevor Sie das Programm starten, stellen Sie sicher, dass sich die Dateien init_lcd_1_28.py, font.py und last_time.txt auf dem Picolaufwerk befinden. Die beiden ersten Dateien können Sie noch einmal hier herunterladen . Die Textdatei legen Sie einfach im Thonny an, indem Sie auf Datei hinzufügen klicken, dann eine Stunde[Enter]Minute [Enter]Schritte[Enter] eingeben und unter dem o.g. Namen speichern.

Updated : 15.08.2023
- Batterieanzeige in extra Funktion und Prozentanzeige bezogen auf die Abschaltspannung (< 3.3 V).

  
# SPDX-FileCopyrightText: 2023 Detlef Gebhardt, written for MicroPython
# SPDX-FileCopyrightText: Copyright (c) 2023 Detlef Gebhardt
#
# SPDX-License-Identifier: GEBMEDIA
from machine import Pin,I2C,SPI,PWM,ADC
import framebuf
import time
import init_lcd_1_28
import font
import math
import random

Vbat_Pin = 29

LCD = init_lcd_1_28.LCD_1inch28()
LCD.set_bl_pwm(65535)
qmi8658=init_lcd_1_28.QMI8658()
Vbat= ADC(Pin(Vbat_Pin))   

LCD.white    = 0xffff
LCD.black    = 0x0000
LCD.gray     = 0x0300
LCD.darkgray = 0xc618
LCD.red      = 0x07E0
LCD.green    = 0x001f
LCD.glade    = 0x0134
LCD.blue     = 0xf800
LCD.yellow   = 0xE0FF
LCD.cyan     = 0x780F
LCD.purple   = 0x7be0
LCD.creme    = 0x7BEF
LCD.beige    = 0xAFE5
LCD.brown    = 0x8059

xpos=120
ypos=120
width=240
height=240
ziel = 600
faktor = 120/ziel
step = 0
stepstop = 0
# start = 0
zeit = 0
x1=65
y1=209
x2=185
y2=209
x3=75
y3=185
x4=175
y4=185

def printchar(letter,xpos,ypos,size,color):
    origin = xpos
    charval = ord(letter)
    index = charval-32
    character = font.cmap[index]
    rows = [character[i:i+5] for i in range(0,len(character),5)]
    for row in rows:
        for bit in row:
            if bit == '1':
                LCD.pixel(xpos,ypos,color)
                if size==2:
                    LCD.pixel(xpos,ypos+1,color)
                    LCD.pixel(xpos+1,ypos,color)
                    LCD.pixel(xpos+1,ypos+1,color)
                if size==3:
                    LCD.pixel(xpos,ypos+1,color)
                    LCD.pixel(xpos,ypos+2,color)
                    LCD.pixel(xpos+1,ypos,color) 
                    LCD.pixel(xpos+2,ypos,color)
                    LCD.pixel(xpos+1,ypos+1,color)
                    LCD.pixel(xpos+2,ypos+2,color)
            xpos+=size
        xpos=origin
        ypos+=size

def printstring(string,xpos,ypos,size,color):
    if size == 1:
        spacing = 8
    if size == 2:
        spacing = 14
    if size == 3:
        spacing = 22
    for i in string:
        printchar(i,xpos,ypos,size,color)
        xpos+=spacing

def circle(x,y,r,c):
    LCD.hline(x-r,y,r*2,c)
    for i in range(1,r):
        a = int(math.sqrt(r*r-i*i))
        LCD.hline(x-a,y+i,a*2,c)
        LCD.hline(x-a,y-i,a*2,c)

def refresh():
    # Hintergrundbildschirm
    LCD.fill(LCD.black)
    circle(120,120,114,LCD.beige)
    circle(120,120,86,LCD.black)
    circle(120,120,75,LCD.darkgray)
    ring(step,ziel)
    printstring("Schritte",90,90,1,LCD.white)
    triangle2(x3,y3,x4,y4)
    LCD.fill_rect(30,210,160,50,LCD.black)
    triangle1(x1,y1,x2,y2)
    LCD.show()
    
def spannung():
    # Spannung in % anzeigen anzeigen
    global reading
    LCD.rect(90,220,30,10,LCD.white)
    LCD.rect(120,222,2,5,LCD.white)
    LCD.fill_rect(92,222,24,6,LCD.glade)
    reading = 4.5 - Vbat.read_u16()*3.3/65535*2
    printstring(str(int(reading/0.8*100)) + " %",130,220,1,LCD.white)
    #printstring(str(int(reading/4.5*100)) + " %",130,220,1,LCD.white)
    #printstring(str(int(reading*10)/10) + " V",130,220,1,LCD.white)
    return reading
    LCD.show()

def ring(step,ziel):
    for i in range (step*120/ziel):
        xpos_neu = int(width/2 + 100*math.cos((i/2+15)*math.pi/30))
        ypos_neu = int(height/2 + 100*math.sin((i/2+15)*math.pi/30))
        circle(xpos_neu,ypos_neu,17,LCD.red)
        time.sleep(0.01)
        LCD.show()

def triangle1(x1,y1,x2,y2):
  for j in range(45):
      LCD.line(x1+j,y1-j,x2-j,y2-j,LCD.red)
def triangle2(x3,y3,x4,y4):
  for j in range(30):
      LCD.line(x3+j,y3-j,x4-j,y4-j,LCD.black)

def pos(step,faktor):
    xpos_neu = int(width/2 + 100*math.cos((faktor*step/2+15)*math.pi/30))
    ypos_neu = int(height/2 + 100*math.sin((faktor*step/2+15)*math.pi/30))
    circle(xpos_neu,ypos_neu,17,LCD.red)
    #time.sleep(0.01)
    LCD.show()

# Schritte auslesen
with open("last_time.txt", "r") as f:
    hour = int(f.readline())
    minute = int(f.readline())
    step = int(f.readline())
f.close()

current_time = time.localtime()
hour = current_time[3]
minute = current_time[4]
second = current_time[5]
if current_time[0] > 2021:
    with open("/last_time.txt", "w") as f:
        f.write(str(hour)+"\n")
        f.write(str(minute)+"\n")
        f.write(str(step))
    f.close()
if current_time[0] == 2021:
    with open("last_time.txt", "r") as f:
        hour = int(f.readline())
        minute = int(f.readline())
        step = int(f.readline())
    f.close()
    second = current_time[5]

refresh()
spannung()
start = time.ticks_ms()

while True:
    if (time.ticks_ms() - start)/ 1000 > 300:
        printstring(str(int(reading/0.8*100)) + " %",130,220,1,LCD.black)
        #printstring(str(int(reading*10)/10) + " V",130,220,1,LCD.black)
        spannung()
        start = time.ticks_ms()
    if second < 10:
        printstring(":0" + str(second),157,123,2,LCD.darkgray)
    else:
        printstring(":" + str(second),157,123,2,LCD.darkgray)
    current_time = time.localtime()
    second = current_time[5]
    #read QMI8658
    xyz=qmi8658.Read_XYZ()
    # Display wird rel. zur x-Achse bewegt
    wert_x = (10)*xyz[0]
    # Display wird rel. zur y-Achse bewegt
    wert_y = (10)*xyz[1]
    # Display wird rel. zur z-Achse bewegt
    wert_z = (10)*xyz[2]
    # Zeit anzeigen
    if second == 59:
        printstring(zeit,50,120,3,LCD.darkgray)
        minute += 1
        if minute == 60:
            minute = 0
            hour += 1
            if hour == 24:
                hour = 0
        with open("/last_time.txt", "w") as f:
            f.write(str(hour)+"\n")
            f.write(str(minute)+"\n")
            f.write(str(step))
        f.close()
        time.sleep(1)
    zeit = str(hour) + ":" + str(minute)
    if minute < 10:
        zeit = str(hour) + ":0" + str(minute)
    printstring(zeit,50,120,3,LCD.white)
    meter = int(step * 0.762)
    printstring(str(meter)+" m",105,175,1,LCD.white)
    #cal = int(int(step * 0.38)*4.18)/1000
    cal = int(int(step * 0.38)*4.18)
    printstring(str(cal)+" J",105,190,1,LCD.white)
    if second < 10:
        printstring(":0" + str(second),157,123,2,LCD.white)
    else:
        printstring(":" + str(second),157,123,2,LCD.white)
    LCD.show()
    #    
    # Arm noch oben bewegen
    #
    if (abs(wert_x) < 7 and abs(wert_y) > 3 or abs(wert_x) < 7 and abs(wert_z) > 3) and stepstop == 0:
        start = time.ticks_ms()
        printstring(str(meter)+" m",105,175,1,LCD.red)
        printstring(str(cal)+" J",105,190,1,LCD.red) 
        step += 1
        stepstop = 1            
        printstring(str(step-1)+"/"+str(ziel),70,70,2,LCD.darkgray)
        LCD.show()
    #
    # Arm wieder nach unten
    #
    if (abs(wert_x) > 7 and abs(wert_y) < 3 or abs(wert_x) > 7 and abs(wert_z) < 3) and stepstop == 1:
        if (time.ticks_ms() - start)> 1000:
            stepstop = 0
    printstring(str(step)+"/"+str(ziel),70,70,2,LCD.white)
    pos(step,faktor)
    if second < 10:
        printstring(":0" + str(second),157,123,2,LCD.white)
    else:
        printstring(":" + str(second),157,123,2,LCD.white)
    if step == ziel:
        alpha = 1
        refresh()
    LCD.show()
    time.sleep(0.2)


1   # SPDX-FileCopyrightText: 2023 Detlef Gebhardt, written for MicroPython
2   # SPDX-FileCopyrightText: Copyright (c) 2023 Detlef Gebhardt
3   #
4   # SPDX-License-Identifier: GEBMEDIA
5   from machine import Pin,I2C,SPI,PWM,ADC
6   import framebuf
7   import time
8   import init_lcd_1_28
9   import font
...
...
...
235         printstring(":" + str(second),157,123,2,LCD.white)
236     if step == ziel:
237         alpha = 1
238         refresh()
239     LCD.show()
240    time.sleep(0.2)

Fitness-uhr - auf dem runden 1.28-Zoll-IPS-LCD-Display 240 x 240 Pixel- nutzt den ACC Beschleunigungssensor in Micropython

Fitness-uhr

Hardware

Los gehts

Viel Spass und Erfolg beim Ausprobieren. echteAnaloguhr elektronischeWasserwaage

Fitness-uhr

- auf dem runden 1.28-Zoll-IPS-LCD-Display 240 x 240 Pixel
- nutzt den ACC Beschleunigungssensor in Micropython

Viel Spass und Erfolg beim Ausprobieren.