NiceGUI – Doku: Text-Elemente

24. September 2025 · Kommentieren · Kategorien: Allgemein

Hier ist noch viel Überarbeitung nötig!

https://nicegui.io/documentation/section_text_elements

Text Elements

Etikett

Zeigt einen Text an.

Text:den Inhalt des Etiketts

main.py

from nicegui import ui

ui.label('some label')

ui.run()

NiceGUI

irgendein Etikett

Siehe mehr…

Link

Erstellen Sie einen Hyperlink.

Um zu einer bestimmten Stelle innerhalb einer Seite zu springen, können Sie mit ui.link_target(„name“) verlinkbare Anker setzen und mit ui.link(target=“#name“) darauf verlinken.

Text:Anzeigetext
Ziel:Seitenfunktion, NiceGUI-Element auf derselben Seite oder String, der eine absolute URL oder ein relativer Pfad von der Basis-URL ist
neue_tab:Link in neuer Registerkarte öffnen (Standard: False)

main.py

from nicegui import ui

ui.link('NiceGUI on GitHub', 'https://github.com/zauberzeug/nicegui')

ui.run()

NiceGUI

NiceGUI auf GitHub

See more…

Chat Message

Based on Quasar’s Chat Message component.

text:the message body (can be a list of strings for multiple message parts)
name:the name of the message author
label:renders a label header/section only
stamp:timestamp of the message
avatar:URL to an avatar
sent:render as a sent message (so from current user) (default: False)
text_html:render text as HTML (default: False)

main.py

from nicegui import ui

ui.chat_message('Hello NiceGUI!',
                name='Robot',
                stamp='now',
                avatar='https://robohash.org/ui')

ui.run()

NiceGUI

Robot

Hello NiceGUI!

now

See more…

Generic Element

This class is the base class for all other UI elements. But you can use it to create elements with arbitrary HTML tags.

tag:HTML tag of the element
_client:client for this element (for internal use only)

main.py

from nicegui import ui

with ui.element('div').classes('p-2 bg-blue-100'):
    ui.label('inside a colored div')

ui.run()

NiceGUI

inside a colored div

See more…

Markdown Element

Renders Markdown onto the page.

content:the Markdown content to be displayed
extras:list of markdown2 extensions (default: [‚fenced-code-blocks‘, ‚tables‘])

main.py

from nicegui import ui

ui.markdown('This is **Markdown**.')

ui.run()

NiceGUI

This is Markdown.

See more…

ReStructuredText

Renders ReStructuredText onto the page.

content:the ReStructuredText content to be displayed

main.py

from nicegui import ui

ui.restructured_text('This is **reStructuredText**.')

ui.run()

NiceGUI

This is reStructuredText.

See more…

Mermaid Diagrams

Renders diagrams and charts written in the Markdown-inspired Mermaid language. The mermaid syntax can also be used inside Markdown elements by providing the extension string ‚mermaid‘ to the ui.markdown element.

The optional configuration dictionary is passed directly to mermaid before the first diagram is rendered. This can be used to set such options as

{’securityLevel‘: ‚loose‘, …}

– allow running JavaScript when a node is clicked{‚logLevel‘: ‚info‘, …}

– log debug info to the console

Refer to the Mermaid documentation for the mermaid.initialize() method for a full list of options.

content:the Mermaid content to be displayed
config:configuration dictionary to be passed to mermaid.initialize()

main.py

from nicegui import ui

ui.mermaid('''
graph LR;
    A --> B;
    A --> C;
''')

ui.run()

NiceGUI

A

B

C

See more…

HTML Element

Rendert beliebigen HTML-Code auf die Seite, umhüllt von dem angegebenen Tag. Tailwind kann für das Styling verwendet werden. Sie können auch ui.add_head_html verwenden, um HTML-Code in den Kopf des Dokuments einzufügen und ui.add_body_html , um ihn in den Körper einzufügen.

Inhalt:der anzuzeigende HTML-Code
Tag:das HTML-Tag, in das der Inhalt eingebettet wird (Standard: „div“)

main.py

from nicegui import ui

ui.html('This is <strong>HTML</strong>.')

ui.run()

NiceGUI

Dies ist HTML.

Siehe mehr…

Other HTML Elements

Es gibt auch ein html Modul, mit dem Sie andere HTML-Elemente wie <span>, <div>, <p>, usw. einfügen können. Es ist gleichbedeutend mit der Verwendung der Methode ui.element mit dem Argument tag.

Wie bei jedem anderen Element können Sie Klassen, Stile, Requisiten, Tooltips und Ereignisse hinzufügen. Ein Vorteil ist, dass die Schlüsselwortargumente automatisch zum Requisiten-Wörterbuch des Elements hinzugefügt werden.

Hinzugefügt in Version 2.5.0

main.py

from nicegui import html, ui

with html.section().style('font-size: 120%'):
    html.strong('This is bold.') \
        .classes('cursor-pointer') \
        .on('click', lambda: ui.notify('Bold!'))
    html.hr()
    html.em('This is italic.').tooltip('Nice!')
    with ui.row():
        html.img().props('src=https://placehold.co/60')
        html.img(src='https://placehold.co/60')

ui.run()

NiceGUIDas ist kühn.

Dies ist kursiv.

NiceGUI – Versuch einer deutschen Dokumentation

24. September 2025 · Kommentieren · Kategorien: Allgemein · Tags: , ,

Da ich es mit dem Englischen nicht so habe versuche ich englische Texte mit DeepL.com zu übersetzen. Damit ich das nicht immer wieder machen muss, speichere ich die Übersetzungen auf meinen Webseiten. Hier versuche ich mich an NiceGUI. Hier folgt die erste Seite der offiziellen NiceGUI-Dokumentation:

https://nicegui.io/documentation

NiceGUI Dokumentation

Referenz, Demos und mehr

Übersicht

NiceGUI ist eine Open-Source-Python-Bibliothek zum Schreiben von grafischen Benutzeroberflächen, die im Browser laufen. Sie hat eine sehr leichte Lernkurve und bietet dennoch die Möglichkeit für fortgeschrittene Anpassungen. NiceGUI folgt einer Backend-First-Philosophie: Es kümmert sich um alle Details der Webentwicklung. Sie können sich auf das Schreiben von Python-Code konzentrieren. Dies macht es ideal für eine breite Palette von Projekten, einschließlich kurzer Skripte, Dashboards, Robotik-Projekte, IoT-Lösungen, Smart Home Automation und maschinelles Lernen.

Wie Sie diesen Leitfaden verwenden

Diese Dokumentation erklärt, wie man NiceGUI benutzt. Jede der Kacheln behandelt ein NiceGUI Thema im Detail. Es wird empfohlen, mit der Lektüre der gesamten Einführungsseite zu beginnen und sich dann bei Bedarf auf andere Abschnitte zu beziehen.

Grundlegende Konzepte

NiceGUI bietet UI Elemente wie Schaltflächen, Schieberegler, Text, Bilder, Diagramme und mehr. Ihre Anwendung fügt diese Komponenten zu Seiten zusammen. Wenn der Benutzer mit einem Element auf einer Seite interagiert, löst NiceGUI ein Ereignis (oder Aktion) aus. Sie definieren Code für die Behandlung jedes Ereignisses, z.B. was zu tun ist, wenn ein Benutzer auf eine Schaltfläche klickt, einen Wert ändert oder einen Schieberegler betätigt. Elemente können auch an ein Modell (Datenobjekt) gebunden werden, das die Benutzeroberfläche automatisch aktualisiert, wenn sich der Modellwert ändert.

Die Anordnung der Elemente auf einer Seite erfolgt über eine „deklarative Benutzeroberfläche“ oder „codebasierte Benutzeroberfläche“. Das bedeutet, dass Sie Strukturen wie Raster, Karten, Registerkarten, Karussells, Erweiterungen, Menüs und andere Layout-Elemente direkt in Code schreiben. Dieses Konzept wurde mit Flutter und SwiftUI populär gemacht. Zur besseren Lesbarkeit nutzt NiceGUI die with ...-Anweisung von Python. Dieser Kontextmanager bietet eine schöne Möglichkeit, den Code so einzurücken, dass er dem Layout der Benutzeroberfläche ähnelt.

Die Gestaltung und das Aussehen können auf verschiedene Weise gesteuert werden. Die meisten Elemente akzeptieren optionale Argumente für allgemeine Styling- und Verhaltensänderungen, wie z.B. Schaltflächensymbole oder Textfarbe. Da NiceGUI ein Web-Framework ist, können Sie fast jedes Aussehen eines Elements mit CSS ändern. Aber Elemente bieten auch .classes und .props Methoden, um Tailwind CSS und Quasar-Eigenschaften anzuwenden, die auf höherer Ebene angesiedelt und im Alltag einfacher zu benutzen sind, nachdem man den Dreh raus hat.

Aktionen, Ereignisse und Aufgaben

NiceGUI verwendet eine async/await-Ereignisschleife für die Gleichzeitigkeit, was ressourceneffizient ist und den großen Vorteil hat, dass man sich nicht um die Threadsicherheit kümmern muss. Dieser Abschnitt zeigt, wie man Benutzereingaben und andere Ereignisse wie Timer und Tastaturbindungen behandelt. Außerdem werden Hilfsfunktionen beschrieben, mit denen sich lang laufende Aufgaben in asynchrone Funktionen verpacken lassen, um die Benutzeroberfläche reaktionsfähig zu halten. Denken Sie daran, dass alle Aktualisierungen der Benutzeroberfläche auf dem Hauptthread mit seiner Ereignisschleife erfolgen müssen.

Umsetzung

NiceGUI ist mit HTML-Komponenten implementiert, die von einem HTTP-Server (FastAPI) bedient werden, auch für native Fenster. Wenn Sie HTML bereits kennen, wird Ihnen alles sehr vertraut vorkommen. Wenn Sie HTML nicht kennen, ist das auch in Ordnung! NiceGUI abstrahiert die Details, so dass Sie sich auf die Erstellung schöner Oberflächen konzentrieren können, ohne sich Gedanken darüber zu machen, wie diese implementiert werden.

NiceGUI Anwendungen ausführen

Es gibt mehrere Optionen für die Bereitstellung von NiceGUI. Standardmäßig läuft NiceGUI auf einem Server auf localhost und führt Ihre Anwendung als eine private Webseite auf dem lokalen Rechner aus. Auf diese Weise wird Ihre Anwendung in einem Webbrowser-Fenster angezeigt. Sie können NiceGUI auch in einem eigenen Fenster, getrennt von einem Webbrowser, laufen lassen. Oder Sie können NiceGUI auf einem Server laufen lassen, der viele Clients bedient – die Webseite, die Sie gerade lesen, wird von NiceGUI bedient.

Nachdem Sie Ihre Anwendungsseiten mit Komponenten erstellt haben, rufen Sie ui.run() auf, um den NiceGUI Server zu starten. Optionale Parameter für ui.run setzen Dinge wie die Netzwerkadresse und den Port an den sich der Server bindet, ob die Anwendung im nativen Modus läuft, die anfängliche Fenstergröße und viele andere Optionen. Der Abschnitt Konfiguration und Bereitstellung behandelt die Optionen der ui.run() Funktion und das FastAPI Framework auf dem sie basiert.

Personalisierung

Wenn Sie mehr Anpassungen in Ihrer Anwendung wünschen, können Sie die zugrunde liegenden Tailwind-Klassen und Quasar-Komponenten verwenden, um den Stil oder das Verhalten Ihrer Komponenten zu steuern. Sie können die verfügbaren Komponenten auch erweitern, indem Sie bestehende NiceGUI-Komponenten subklassifizieren oder neue Komponenten aus Quasar importieren. All dies ist optional. NiceGUI bietet von Haus aus alles, was Sie brauchen, um moderne, stilvolle und reaktionsfähige Benutzeroberflächen zu erstellen.

Prüfung

NiceGUI bietet ein umfassendes Test-Framework auf der Basis von pytest , mit dem Sie das Testen Ihrer Benutzeroberfläche automatisieren können. Sie können die screen fixture verwenden, die einen echten (headless) Browser startet, um mit Ihrer Anwendung zu interagieren. Dies ist ideal, wenn Sie browserspezifisches Verhalten testen möchten.

Aber die meiste Zeit ist das neu eingeführte Benutzer-Fixture von NiceGUI besser geeignet: Es simuliert die Benutzerinteraktion nur auf Python-Ebene und ist daher rasend schnell. Die klassische Testpyramide, in der UI-Tests als langsam und teuer gelten, gilt damit nicht mehr. Dies kann enorme Auswirkungen auf Ihre Entwicklungsgeschwindigkeit, Qualität und Ihr Vertrauen haben.

Karte von NiceGUI

Diese Übersicht zeigt die Struktur von NiceGUI. Es ist eine Karte des NiceGUI Namensraumes und dessen Inhalt. Sie ist nicht vollständig, aber sie gibt Ihnen eine gute Vorstellung von dem, was verfügbar ist. Ein laufendes Ziel ist es, diese Karte vollständiger zu machen und fehlende Links zur Dokumentation hinzuzufügen.

ui

UI-Elemente und andere wesentliche Elemente für den Betrieb einer NiceGUI-Anwendung.

app

App-weiter Speicher, Einhängepunkte und Lebenszyklus-Hooks.

  • app.storage:
    • app.storage.tab: im Speicher des Servers abgelegt, eindeutig pro Tab
    • app.storage.client: wird im Speicher des Servers gespeichert, einmalig für jeden mit einer Seite verbundenen Client
    • app.storage.user: in einer Datei auf dem Server gespeichert, eindeutig pro Browser
    • app.storage.general: in einer Datei auf dem Server gespeichert, die von der gesamten Anwendung genutzt wird
    • app.storage.browser: gespeichert im lokalen Speicher des Browsers, eindeutig pro Browser
  • Lebenszyklus-Haken:
    • app.on_connect(): wird aufgerufen, wenn ein Client eine Verbindung herstellt
    • app.on_disconnect(): wird aufgerufen, wenn ein Client die Verbindung trennt
    • app.on_startup(): wird aufgerufen, wenn die Anwendung startet
    • app.on_shutdown(): wird aufgerufen, wenn die Anwendung heruntergefahren wird
    • app.on_exception(): wird aufgerufen, wenn eine Ausnahme auftritt
    • app.on_page_exception(): wird aufgerufen, wenn beim Aufbau einer Seite eine Ausnahme auftritt
  • app.shutdown(): Beendet die Anwendung
  • statische Dateien:
  • app.native: konfiguriert die App, wenn sie im nativen Modus läuft

html

Reine HTML-Elemente:

a, abbr, acronym, address, area, article, aside, audio, b, basefont, bdi, bdo, big, blockquote, br, button, canvas, caption, cite, code, col, colgroup, data, datalist, dd, del_, details, dfn, dialog, div, dl, dt, em, embed, fieldset, figcaption, figure, footer, form, h1, header, hgroup, hr, i, iframe, img, input_, ins, kbd, label, legend, li, main, map_, mark, menu, meter, nav, object_, ol, optgroup, option, output, p, param, picture, pre, progress, q, rp, rt, ruby, s, samp, search, section, select, small, source, span, strong, sub, summary, sup, svg, table, tbody, td, template, textarea, tfoot, th, thead, time, tr, track, u, ul, var, video, wbr

background_tasks

Führen Sie asynchrone Funktionen im Hintergrund aus.

  • create(): Erstellen einer Hintergrundaufgabe
  • create_lazy(): verhindert, dass zwei Aufgaben mit demselben Namen gleichzeitig laufen
  • await_on_shutdown: markiert eine Coroutine-Funktion, die beim Herunterfahren erwartet wird (standardmäßig werden alle Hintergrundaufgaben abgebrochen)

run

Führen Sie IO- und CPU-gebundene Funktionen in separaten Threads und Prozessen aus.

  • run.cpu_bound(): Ausführung einer CPU-gebundenen Funktion in einem separaten Prozess
  • run.io_bound(): Ausführung einer IO-gebundenen Funktion in einem separaten Thread

binding

Eigenschaften von Objekten aneinander binden.

observables

Beobachtbare Sammlungen, die Beobachter benachrichtigen, wenn sich ihr Inhalt ändert.

  • ObservableCollection: Basisklasse
  • ObservableDict: ein beobachtbares Wörterbuch
  • ObservableList: eine beobachtbare Liste
  • ObservableSet: eine beobachtbare Menge

testing

Schreiben Sie automatisierte UI-Tests, die in einem Headless-Browser (langsam) oder vollständig in Python simuliert (schnell) ablaufen.

  • Screen fixture: Start eines echten (headless) Browsers zur Interaktion mit Ihrer Anwendung
  • Benutzer fixture: Simulation der Benutzerinteraktion auf Python-Ebene (schnell)

Soweit die DeepL Übersetzung.

Die Links führen noch zu den englischen Originalseiten. Wenn ich mich mit einem Thema näher beschäfftige werde ich diese Seite auch auf deutsch übersetzen lassen.

Links zu den speziellen Themenbereichen:

Hier sind die Links aus der originalen ersten Seite der NiceGUI-Dokumentation zu speziellen Themenbereichen. Sie sind noch in der Bearbeitung. Es befinden sich aber die Links zu den Originalseiten darin.

NiceGUI – Doku: Text-Elemente

NiceGUI – Doku: Kontrollstrukturen

NiceGUI – Doku: Audiovisuelle Elemente

NiceGUI – Doku: Daten Elemente

NiceGUI – Doku: Bindung Eigenschaften

NiceGUI – Doku: Seiten Layout

NiceGUI – Doku: Styling & Erscheinungsbild

NiceGUI – Doku: Aktion & Ereignisse

NiceGUI – Doku: Seiten & Weiterleitung

NiceGUI – Doku: Konfiguration & Einsatz

NiceGUI – Doku: Prüfung

Zu den Beispielen geht es hier: https://nicegui.io/#examples

Auf Github befindet NiceGUI sich hier: https://github.com/zauberzeug/nicegui

NiceGUI – ein Mini-Manual von ChatGPT

24. September 2025 · Kommentieren · Kategorien: Allgemein · Tags: , ,

📘 Mini-Manual zu NiceGUI (Deutsch)

1. Einführung

NiceGUI ist ein Python-Framework zur schnellen Erstellung von Weboberflächen. Es basiert auf Vue.js und Quasar, erfordert aber nur Python-Kenntnisse. Damit lassen sich Dashboards, GUIs und interaktive Apps mit wenigen Zeilen Code erstellen.

2. Installation

pip install nicegui
python main.py

Standardmäßig ist die Oberfläche unter http://localhost:8080 erreichbar.

3. Erste Schritte

Beispiel: „Hello World“

from nicegui import ui

ui.label('Hallo Welt!')

ui.run()

Buttons und Aktionen

from nicegui import ui

def begruessung():
    ui.notify('Willkommen bei NiceGUI!')

ui.button('Klick mich', on_click=begruessung)
ui.run()

4. Wichtige UI-Elemente

  • Labels: ui.label('Text')
  • Buttons: ui.button('Titel', on_click=funktion)
  • Textfelder: ui.input('Name')
  • Checkboxen: ui.checkbox('Option')
  • Slider: ui.slider(min=0, max=100)
  • Diagramme: ui.line_chart(...)
  • Tabellen: ui.table(columns=[...], rows=[...])

5. Layouts

Spalten und Reihen

with ui.row():
    ui.label('Links')
    ui.label('Rechts')

with ui.column():
    ui.button('Oben')
    ui.button('Unten')

Karten

with ui.card():
    ui.label('Eine Karte')
    ui.button('Aktion')

6. Datenbindung

name = ui.input('Dein Name')
ui.label().bind_text_from(name, 'value')

Das Label zeigt immer den aktuellen Eingabewert.

7. Navigation

from nicegui import ui

@ui.page('/seite1')
def seite1():
    ui.label('Dies ist Seite 1')

ui.run()

Die Seite ist erreichbar unter http://localhost:8080/seite1.

8. Benachrichtigungen und Dialoge

ui.notify('Dies ist eine Nachricht')

with ui.dialog() as dialog, ui.card():
    ui.label('Bist du sicher?')
    ui.button('Ja', on_click=dialog.close)

ui.button('Dialog öffnen', on_click=dialog.open)

9. Integration mit Python

NiceGUI läuft vollständig in Python, sodass sich Daten aus Skripten, Datenbanken oder Sensoren direkt einbinden lassen.

Beispiel: Counter

counter = 0
label = ui.label(f'Zähler: {counter}')

def hochzaehlen():
    global counter
    counter += 1
    label.text = f'Zähler: {counter}'

ui.button('++', on_click=hochzaehlen)
ui.run()

10. Deployment

  • Lokal: Standardmäßig über ui.run()
  • Docker:
FROM python:3.11-slim
RUN pip install nicegui
COPY main.py .
CMD ["python", "main.py"]
  • Server: per uvicorn oder in Cloud-Diensten wie Heroku, Railway, Fly.io.

11. Nützliche Links

✅ Mit diesem Mini-Manual hast du die wichtigsten Grundlagen auf Deutsch. Du kannst direkt starten und GUIs mit Python entwickeln!

Windows Bootloader wiederherstellen und Backup

15. September 2025 · Kommentieren · Kategorien: Allgemein · Tags: ,

Perfekt! Dann gehen wir Schritt für Schritt vor, um Windows wieder bootfähig zu machen, ohne die Daten zu löschen. Ich erkläre es für Windows 10. Du brauchst dafür ein Windows-Installationsmedium (USB-Stick oder DVD).

Schritt 1: Windows-Installationsmedium vorbereiten

  1. Lade das Windows 10 Media Creation Tool herunter: Microsoft Downloadseite
  2. Erstelle damit einen bootfähigen USB-Stick (mindestens 8 GB).

Schritt 2: Vom Installationsmedium booten

  1. Rechner vom USB-Stick starten (Boot-Menü oder BIOS/UEFI wählen).
  2. Sprache und Tastatur auswählen, dann „Computerreparaturoptionen“ → „Problembehandlung“ → „Eingabeaufforderung“.

Schritt 3: Bootloader reparieren

Im Eingabeaufforderungs-Fenster folgende Befehle ausführen:

  1. Bootpartition markieren:
<code>
diskpart 
list disk 
select disk 0 (deine Windows-Festplatte auswählen) 
list partition 
select partition 1 (sda1 – System Reserved) 
active (Partition als aktiv markieren) 
exit
</code>

2. Bootloader reparieren:

<code>
bootrec /fixmbr 
bootrec /fixboot 
bootrec /scanos 
bootrec /rebuildbcd
</code>

3. Optional:

Wenn bootrec /fixboot Zugriff verweigert, kann man folgendes versuchen:

 <code>
bootsect /nt60 SYS /mbr
</code>

    Schritt 4: Neustart

    • USB-Stick entfernen, Rechner neu starten.
    • Windows sollte nun wieder booten.

    Schritt 5: Backup machen

    Sobald Windows wieder startet:

    • Am besten ein vollständiges Image von sda2 erstellen (z. B. mit Macrium Reflect Free oder Acronis True Image).
    • So hast du ein sicheres Backup, bevor du erneut Linux probierst.

    Wenn du willst, kann ich dir danach auch zeigen, wie du Linux parallel installieren kannst, ohne den Windows-Boot zu zerstören.

    Willst du, dass ich das vorbereite?

    Dieses Rezept habe ich nicht mehr ausprobiert weil ich GRUB zum Laufen bekommen habe und so wieder auf das Windowssystem zugreifen konnte.

    GRUB beleuchtet

    15. September 2025 · Kommentieren · Kategorien: Allgemein · Tags: ,

    Ich habe bei einer Dualboot-Installation von Windows 10 und Linux-Mint / LUBUNTU / XUBUNTU große Probleme mit GRUB bekommen. Bisher hat das nie Probleme bereitet aber bei diesem alten PC klappt es nicht. Die Hinweise von CHATGPT waren sicher richtig, haben mich aber auch nicht wirklich weiter gebracht, weil die KI doch recht viel geschwafelt hat und die Vorschläge nicht wirklich zielführend waren. Deshalb habe ich mich entschlossen ein wenig hinter die Kulissen von GRUB zu schauen um es selbst zu verstehen und entsprechend einrichten zu können.

    Wie funktionier GRUB?

    Diese Frage habe ich CHATGPT gestellt. Die Antwort:

    Grub (GRUB = GRand Unified Bootloader) ist ein Bootloader, also das Programm, das gestartet wird, sobald ein PC eingeschaltet wird, um ein Betriebssystem zu laden. Ich erkläre dir Schritt für Schritt, wie er funktioniert und warum er so nützlich ist:

    1. Boot-Reihenfolge im PC

    Wenn ein PC eingeschaltet wird, passiert folgendes:

    1. BIOS/UEFI startet: Prüft Hardware und sucht ein Boot-Medium.
    2. Bootloader wird geladen: BIOS/UEFI lädt den Bootloader (z. B. GRUB) von der ersten Boot-Partition (MBR oder EFI-Systempartition).

    2. GRUB selbst

    GRUB ist ein flexibler Bootloader, der mehrere Betriebssysteme starten kann. Er besteht typischerweise aus mehreren Stufen:

    a) Stage 1 (kleinster Teil, MBR oder EFI)

    • Liegt am Anfang der Festplatte oder EFI-Partition.
    • Kann nur sehr wenig Speicher nutzen.
    • Lädt Stage 2 oder direkt die Konfiguration.

    b) Stage 2 (größerer Teil)

    • Hat Zugriff auf Dateienysteme (ext4, NTFS, FAT32…).
    • Kann die GRUB-Konfigurationsdatei lesen: grub.cfg.
    • Zeigt das Bootmenü an.
    • Ermöglicht Auswahl zwischen mehreren Betriebssystemen, Kernel-Optionen usw.

    3. Bootmenü

    • GRUB zeigt eine Liste von Betriebssystemen oder Kernel-Versionen an.
    • Der Benutzer kann auswählen oder GRUB startet automatisch nach einer Zeitüberschreitung.
    • Ein Kernel wird ausgewählt → GRUB lädt Kernel + initrd (initial RAM disk) in den Speicher.

    4. Kernel starten

    • GRUB übergibt die Kontrolle an den Kernel.
    • Kernel startet die Hardware und das Betriebssystem vollständig.

    5. Besondere Features von GRUB

    • Unterstützt mehrere Betriebssysteme (Linux, Windows, BSD…).
    • Kann Dateisysteme direkt lesen → man muss keine festen Sektoradressen kennen.
    • Hat eine Kommandozeile, falls etwas schiefgeht (grub rescue>).
    • Kann auch Netzwerk-Boot (PXE) oder verschlüsselte Partitionen starten.

    Kurz gesagt:
    GRUB ist das Bindeglied zwischen BIOS/UEFI und deinem Betriebssystem. Er liest die Boot-Konfiguration, zeigt ein Menü an, lädt den Kernel und übergibt dann die Kontrolle an das Betriebssystem.

    Wenn du willst, kann ich auch eine grafische Übersicht zeigen, wie GRUB von BIOS bis Kernel arbeitet – das macht es sehr anschaulich. Willst du, dass ich das mache?

    Gut… noch nicht sehr erhellend aber ich lass dass erst mal so stehen.

    Die grafische Übersicht habe ich hier nicht übernommen, da sie, wie meistens bei CHATGPT, eher verwirrt als hilft.

    Wenn GRUB kaputt ist

    Die Antwort von CHATGPT:

    Wenn GRUB kaputt ist (z. B. nach einem Update, einer falschen Konfiguration oder weil ein anderes OS den Bootloader überschrieben hat), gibt es mehrere Möglichkeiten, das Problem zu beheben. Hier eine Übersicht, was du tun kannst:

    1. Mit einem Live-System starten

    • Lade dir ein Linux-Live-ISO (z. B. Ubuntu, Debian, Linux Mint) herunter.
    • Starte den Rechner von USB oder DVD.
    • Öffne ein Terminal.

    2. Root-Partition einhängen

    Angenommen, deine Linux-Root liegt auf /dev/sda2:

    sudo mount /dev/sda2 /mnt

    Falls du eine separate Boot-Partition hast, auch die mounten:

    sudo mount /dev/sda1 /mnt/boot

    UEFI-Systeme: EFI-Partition mounten (meist /dev/sda1 mit FAT32):

    sudo mount /dev/sda1 /mnt/boot/efi

    3. System-Umgebung vorbereiten

    sudo mount --bind /dev /mnt/dev
sudo mount --bind /proc /mnt/proc
sudo mount --bind /sys /mnt/sys

    Dann ins System wechseln:

    sudo chroot /mnt

    4. GRUB neu installieren

    Für BIOS/Legacy-Systeme:

    grub-install /dev/sda

    Für UEFI-Systeme:

    grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=GRUB

    Danach Konfiguration neu erzeugen:

    update-grub

    oder (je nach Distro):

    grub-mkconfig -o /boot/grub/grub.cfg

    5. Neustarten

    exit
sudo umount -R /mnt
reboot

    6. Alternative: Boot-Repair

    Es gibt das Tool Boot-Repair, das viele Schritte automatisch erledigt. Unter Ubuntu kannst du es so installieren (im Live-System):

    sudo add-apt-repository ppa:yannubuntu/boot-repair
sudo apt update
sudo apt install -y boot-repair
boot-repair

    Damit kannst du oft mit einem Klick GRUB reparieren.

    👉 Wichtig: Sag mir, ob du BIOS (Legacy) oder UEFI nutzt und welche Linux-Distribution du hast – dann kann ich dir eine maßgeschneiderte Schritt-für-Schritt-Anleitung geben.

    Möchtest du, dass ich dir gleich ein Minimal-„Rettungsrezept“ für UEFI + Ubuntu/Debian schreibe?

    Wie bekomme ich heraus ob mein Rechner im BIOS- oder UEFI-Modus bootet?

    Sehr gute Frage 👍 – das ist entscheidend, weil GRUB unterschiedlich installiert wird, je nachdem ob dein System im Legacy-BIOS-Modus oder im UEFI-Modus läuft.

    Hier ein paar einfache Methoden:

    1. Unter Linux (wenn du das System noch starten kannst)

    Prüfen ob /sys/firmware/efi existiert:

    ls /sys/firmware/efi
    • Wenn der Ordner existiert und Dateien enthält → UEFI-Boot.
    • Wenn er nicht existiert → Legacy-BIOS-Boot.

    2. Im Live-System (von USB gestartet)

    Auch hier kannst du wie oben prüfen:

    ls /sys/firmware/efi

    Wenn der Ordner leer oder nicht vorhanden ist → dann bist du im Legacy-BIOS-Modus gebootet.

    3. Unter Windows (falls Dual-Boot)

    • Win + R → msinfo32 eingeben.
    • Dort steht bei BIOS-Modus:
      • „UEFI“ → UEFI-Boot
      • „Legacy“ → BIOS-Boot

    4. Boot-Struktur auf der Festplatte ansehen

    • Wenn deine Festplatte eine EFI-Systempartition (FAT32, ca. 100–500 MB, gemountet unter /boot/efi) hat, ist das fast sicher ein UEFI-System.
    • Wenn es stattdessen nur eine MBR-Partitionstabelle ohne EFI-Partition gibt → Legacy-BIOS.

    👉 Empfehlung: Wenn du gerade im Live-Linux bist, probiere direkt mal:

    ls /sys/firmware/efi

    Willst du, dass ich dir ein Kochrezept für die Reparatur von GRUB schreibe, je nachdem ob das Ergebnis UEFI oder BIOS ist?

    Mein System ist kein UEFI sondern ein BIOS-System. Dafür hat mir CHATGPT die folgende Anleitung gegeben:

    Danke für die Ausgabe 👍 – das macht die Sache klarer.

    Analyse deiner Partitionstabelle

    • /dev/sda1 (100 MB NTFS) → Das ist keine EFI-Systempartition, sondern eine klassische Windows-„System-reserviert“-Partition.
    • /dev/sda2 (≈160 GB NTFS) → Windows 10 selbst.
    • /dev/sda3 (500 MB NTFS) → wahrscheinlich Windows Recovery.
    • /dev/sda4 (erweitert) + /dev/sda5 (63 GB Linux, Typ 83) → hier liegt dein Lubuntu.

    👉 Es gibt keine EFI-Systempartition (FAT32), stattdessen nur eine MBR-Partitionstabelle mit NTFS und ext4.

    Schlussfolgerung

    • Dein Windows läuft im Legacy-BIOS-Modus (MBR).
    • Dein Lubuntu wurde auch im BIOS-Modus installiert.
    • GRUB gehört also in den MBR der Festplatte (/dev/sda), nicht in eine EFI-Partition.

    Reparaturschritte für GRUB (aus Live-Lubuntu)

    1. Root-Partition mounten:
    sudo mount /dev/sda5 /mnt
    1. Wichtige Systemverzeichnisse einbinden:
    sudo mount --bind /dev /mnt/dev
sudo mount --bind /proc /mnt/proc
sudo mount --bind /sys /mnt/sys
    1. In dein installiertes System wechseln:
    sudo chroot /mnt
    1. GRUB in den MBR von /dev/sda schreiben:
    grub-install /dev/sda
update-grub
    1. Rausgehen und aushängen:
    exit
sudo umount -R /mnt
    1. Neustarten:
    reboot

    Danach sollte beim Starten wieder der GRUB-Bootloader erscheinen, mit Auswahl zwischen Windows 10 und Lubuntu.

    👉 Willst du, dass ich dir dafür ein komplettes Copy&Paste-Skript schreibe, das du im Live-Lubuntu nur durchlaufen lassen musst?

    Das hat im Prinzip funktioniert. Allerdings wird kein Bootmenue angezeigt, sondern gleich Lubuntu gestartet. Da dort die Grafikkarte nicht richtig eingerichtet wird bleibt der Bildschirm nach der Anzeige des Logos schwarz.

    Das Verhalten von GRUB einstellen.

    Dazu lieferte CHATGPT folgende Anleitung:

    Verstanden 👍 – wenn dein installiertes Lubuntu nicht richtig bis zum Desktop bootet (wegen Grafiktreiber), kannst du die GRUB-Konfiguration auch aus dem Live-System anpassen.

    Dazu im Prinzip dieselbe Vorgehensweise wie bei der GRUB-Reparatur:

    1. Lubuntu-Partition mounten

    sudo mount /dev/sda5 /mnt

    2. Systemverzeichnisse einbinden

    sudo mount --bind /dev /mnt/dev
sudo mount --bind /proc /mnt/proc
sudo mount --bind /sys /mnt/sys

    3. Chroot ins installierte System

    sudo chroot /mnt

    4. GRUB-Konfiguration bearbeiten

    nano /etc/default/grub

    Ändere/füge ein (falls Zeilen fehlen, einfach hinzufügen):

    GRUB_TIMEOUT_STYLE=menu
GRUB_TIMEOUT=5
GRUB_DISABLE_OS_PROBER=false

    ⚠️ Wichtig: GRUB_DISABLE_OS_PROBER=false ist nötig, damit Windows 10 automatisch erkannt und ins Menü aufgenommen wird.

    5. GRUB aktualisieren

    update-grub

    Du solltest dann etwas sehen wie:

    Found Windows Boot Manager on /dev/sda1

    6. Beenden und aushängen

    exit
sudo umount -R /mnt
reboot

    Damit solltest du beim nächsten Booten aus dem MBR-GRUB-Menü Windows 10 auswählen können – selbst wenn Lubuntu wegen Grafikproblemen schwarz bleibt.

    👉 Soll ich dir gleich eine komplette Minimalversion von /etc/default/grub hier hinschreiben, die du 1:1 ins Live-System kopieren kannst?

    Nun funktioniert der Bootvorgang so wie er soll.

    Wie findet GRUB die Betriebssysteme?

    Das scheint automatisch zu gehen. Ich werde das vielleicht später mal klären.


    Linux aus einem Dualbootsystem sichern und zurückspielen.

    14. September 2025 · Kommentieren · Kategorien: Allgemein

    Ich stelle meinen alten Lenovo IdeaCenter B500 gerade auf Linux um. Dazu möchte ich parallel zum Win10 verschiedene schmale Linux-Distributionen testen. Das es bei dieser alten Hardware und DVD-Bootmedium Stunden dauert ein System aufzuspielen möchte ich laufende Testsysteme auf einer externen USBHDD speichern.

    Chatgpt.com hat mir dazu folgenden Anleitung geliefert:

    Perfekt! Ich schreibe dir eine klare Schritt-für-Schritt-Anleitung, wie du nur dein Linux-Mint-System aus einem Dualboot auf eine externe USB-HDD sichern kannst und später wieder zurückspielst. Sie ist so strukturiert, dass du sie direkt in WordPress einfügen kannst.

    Backup und Restore von Linux-Mint in einem Dualboot-System

    Voraussetzungen

    • Dualboot-PC mit Windows 10 + Linux-Mint.
    • Externe USB-HDD groß genug für die Linux-Mint-Partition(en).
    • Live-USB oder Live-DVD von Linux (z. B. Mint, Lubuntu, Xubuntu).
    • Grundkenntnisse im Terminal.

    1️⃣ USB-HDD vorbereiten

    1. USB-HDD anschließen.
    2. Im Terminal prüfen, wie die Platte erkannt wird:
    lsblk
    • Beispiel:
    sda  500G  <--- interne Festplatte
sdb  1T    <--- externe USB-HDD
    1. Partitionieren & formatieren (optional, z. B. EXT4 für Linux-Backup):
    sudo mkfs.ext4 /dev/sdb1
    1. Mountpoint erstellen:
    sudo mkdir /mnt/usbbackup
sudo mount /dev/sdb1 /mnt/usbbackup

    2️⃣ Linux-Mint sichern (rsync-Methode)

    1. Starte von Live-USB → verhindert, dass laufende Prozesse die Dateien sperren.
    2. Linux-Mint-Partition mounten:
    sudo mkdir /mnt/linux
sudo mount /dev/sdaX /mnt/linux
    • sdaX ist deine Linux-Mint-Rootpartition.
    • Wenn du eine separate /home-Partition hast, mounten:
    sudo mkdir /mnt/home
sudo mount /dev/sdaY /mnt/home
    1. Backup mit rsync:
    sudo rsync -aAXv --exclude={"/dev/*","/proc/*","/sys/*","/tmp/*","/run/*","/mnt/*","/media/*","/lost+found"} /mnt/linux/ /mnt/usbbackup/linux-root/
    • Wenn /home separat ist:
    sudo rsync -aAXv /mnt/home/ /mnt/usbbackup/linux-home/

    ✅ Vorteil: Flexibel, Backup auf Partition beliebiger Größe, kein Risiko der gesamten HDD.

    3️⃣ Bootloader sichern (GRUB)

    Damit du später Linux-Mint wieder booten kannst, auch in Dualboot:

    1. GRUB auf der USB-HDD sichern:
    sudo grub-install --boot-directory=/mnt/usbbackup/linux-root/boot /dev/sdb
sudo update-grub

    4️⃣ Linux-Mint wiederherstellen

    Wenn du das Backup zurückspielen willst:

    1. Starte wieder von Live-USB.
    2. Partitionen vorbereiten:
    sudo mkfs.ext4 /dev/sdaX    # Root
sudo mkfs.ext4 /dev/sdaY    # Home, falls separat
    1. Mounten:
    sudo mount /dev/sdaX /mnt/linux
sudo mount /dev/sdaY /mnt/home
sudo mount /dev/sdb1 /mnt/usbbackup
    1. Restore mit rsync:
    sudo rsync -aAXv /mnt/usbbackup/linux-root/ /mnt/linux/
sudo rsync -aAXv /mnt/usbbackup/linux-home/ /mnt/home/
    1. GRUB wiederherstellen:
    sudo grub-install --boot-directory=/mnt/linux/boot /dev/sda
sudo update-grub

    5️⃣ Hinweise

    • Datei vs. 1:1-Kopie: Mit rsync sicherst du nur Linux, Windows bleibt unberührt.
    • Vollständige 1:1-Kopie: Willst du die gesamte Festplatte klonen, kannst du dd verwenden, dann wird auch Windows gesichert.
    • Sicherheit: Immer Live-System verwenden, um aktive Partitionen nicht zu beschädigen.
    • Testen: Nach Restore unbedingt prüfen, ob GRUB die Dualboot-Auswahl korrekt anzeigt.

    So hast du ein komplettes Linux-Mint-Backup, kannst neue Systeme testen und Linux-Mint später problemlos wiederherstellen, ohne Windows zu beeinträchtigen.

    Wenn du willst, kann ich noch eine kompakte Version für WordPress schreiben, mit sauberen Codeblöcken und Nummerierung, damit sie direkt wie eine Anleitung im Blog aussieht. Willst du, dass ich das mache?

    Genaue DC mit PWM und Pico2 erzeugen.

    13. September 2025 · Kommentieren · Kategorien: Allgemein, Pico · Tags:

    Ich möchte untersuchen wie genau eine Gleichspannung sein kann, die mittels PWM mit einem Pico2 erzeugt werden kann. Dazu habe ich Chatgpt.com befragt:

    Natürlich 👍 – ich fasse dir unseren Chat in einen gut lesbaren Artikeltext zusammen, den du direkt in WordPress einfügen kannst (als normalen Beitrag oder Seite).

    PWM und GPIO-Treiber beim Raspberry Pi Pico2 (RP2350)

    Der neue Raspberry Pi Pico2 (RP2350) bietet einige interessante Features, die auch für Anwendungen mit PWM-Ausgabe und GPIO-Treibern wichtig sind. Hier findest du eine Zusammenfassung der wichtigsten Punkte aus der Praxis.

    Einstellbarer Ausgangsstrom der GPIOs

    Die GPIO-Pins des RP2040 und RP2350 lassen sich in ihrer Treiberstärke (Drive Strength) konfigurieren. Es gibt vier Stufen:

    • 2 mA
    • 4 mA
    • 8 mA
    • 12 mA

    Zusätzlich kann die Slew-Rate (Flankensteilheit) zwischen „slow“ und „fast“ eingestellt werden.

    Damit lässt sich sowohl die Belastbarkeit (z. B. LEDs oder andere Bauteile treiben) als auch das EMV-Verhalten optimieren.

    Beispiel in MicroPython

    Über die padsbank0-Register lässt sich die Drive-Strength direkt setzen:

    import machine

# Basisadresse für padsbank0
PADS_BASE = 0x4001c000
PADS_GPIO0 = PADS_BASE + 0x04  # GPIO0, weitere Pins jeweils +4

def set_drive(pin, strength=3, fast=True):
    """
    pin       : GPIO-Nummer
    strength  : 0=2mA, 1=4mA, 2=8mA, 3=12mA
    fast      : True = schnelle Slew-Rate
    """
    addr = PADS_GPIO0 + 4*pin
    reg = machine.mem32[addr]
    reg = (reg & ~0b11) | (strength & 0b11)
    if fast:
        reg |= (1 << 2)
    else:
        reg &= ~(1 << 2)
    machine.mem32[addr] = reg

# Beispiel: GPIO15 mit 12 mA und schneller Slew-Rate
set_drive(15, strength=3, fast=True)

    Auch wenn ein Pin auf PWM-Funktion gestellt wird, gilt diese Einstellung weiterhin.

    Innenwiderstand der Treiber

    Ein fester „Innenwiderstand“ der GPIO-Treiber ist nicht spezifiziert.

    • Die Angabe 2/4/8/12 mA beschreibt nur die Ziel-Treibefähigkeit.
    • Reale Messungen zeigen, dass kurzfristig deutlich höhere Ströme fließen können.
    • Der effektive Widerstand ergibt sich aus der Lastsituation (z. B. bei 12 mA-Einstellung etwa einige zehn Ohm).

    Für definierte Verhältnisse empfiehlt sich daher ein externer Serienwiderstand.

    Fractional Clock Divider

    Beim PWM-Modul wird der Taktteiler (Clock Divider) als 12.4 fixed-point Wert eingestellt:

    • 12 Bit Ganzzahl
    • 4 Bit Bruchteil (in 1/16-Schritten)

    Beispiel:

    • „8.4 fractional clock divider“ = 8 + 4/16 = 8.25

    Damit lassen sich PWM-Frequenzen sehr fein einstellen.

    Maximale PWM-Frequenz bei 16-Bit Auflösung

    Die PWM-Frequenz berechnet sich zu: fPWM=fsysclkdiv×(TOP+1)f_{PWM} = \frac{f_{sys}}{\text{clkdiv} \times (TOP+1)}

    • Systemtakt Pico2: 150 MHz
    • TOP = 65535 (16 Bit)
    • clkdiv = 1.0

    fPWM=150 000 00065 536≈2.3 kHzf_{PWM} = \frac{150\,000\,000}{65\,536} \approx 2.3 \,\text{kHz}

    👉 Bei voller 16-Bit-Auflösung sind also nur ca. 2,3 kHz PWM-Frequenz möglich.

    Frequenz vs. Auflösung (150 MHz, clkdiv=1.0)

    AuflösungZählerumfangMax. FrequenzPeriode
    8 Bit256585.9 kHz1.71 µs
    10 Bit1024146.5 kHz6.83 µs
    12 Bit409636.6 kHz27.3 µs
    14 Bit163849.16 kHz109 µs
    16 Bit655362.29 kHz437 µs

    Je höher die Auflösung, desto niedriger die maximale PWM-Frequenz – und umgekehrt.

    Fazit

    • GPIO-Treiber des RP2350 sind in 4 Stufen (2–12 mA) einstellbar, mit wählbarer Slew-Rate.
    • PWM kann mit feiner Frequenzabstufung über Fractional Divider betrieben werden.
    • Max. 16-Bit PWM: ca. 2,3 kHz bei 150 MHz Systemtakt.
    • Für höhere Frequenzen muss die Auflösung reduziert werden.

    Grundsätzliche Überlegungen.

    Die Erste Fragestellung entstand, weil ich bei früheren Versuchen mit einem niederohmigen RC-Glied festgestellt habe, das die minimale und maximale Spannung des Rechtecks aus dem Pin sich auf und ab bewegen. Um diesen Einfluß abschätzen zu können wäre es wichtig den Innenwiderstand der Ausgangsstufen des Pico2 zu kennen.

    Die maximale Auflösung der PWM und damit der erzeugten Spannung beträgt 16-Bit. Da das Timing sehr exakt sein dürfte, könnte diese Spannung auch sehr exakt sein. Allerdings hat z.B. das oben geschilderte Phänomen sicher einen erheblichen Einfluß auf die Genauigkeit und bedarf deshalb näherer Betrachtung.

    Ein weiterer Punkt ist die Konstanz der Betriebsspannung die im Pico2 erzeugt wird.

    Für die Filterung des PWM-Signals zu einer Gleichspannung habe ich mich ebenfalls mit Chatgpt.com beraten. Das Ergebnis ist unter https://www.peters-bastelkiste.de/pwm-filter_001/ zu finden.

    PWM-Filter_001

    19. August 2025 · Kommentieren · Kategorien: Allgemein

    Konzept

    Hier geht es um einen Filter um aus einem PWM-Signal eine präzise Gleichspannung zu machen.

    Es besteht aus drei Teilen:

    • RC-Glied
    • Puffer
    • Sellen-Key-Filter

    Entwicklung

    Es wurde zusammen mit Chatgpt.com entwickelt.

    Berechneter Rippel (p-p) ≈ 8.0 µV.

    Damit ist von der Filterseite her alles getan was erforderlich ist.

    Ich habe die Schaltung mit LTSpice simmuliert:

    Hier das Ergebnis der Simmulation für 5kHz und 5µS Impulsdauer. Die Zoomdarstellung zeigt, dass ab ca. 120mS die Spannung sich nicht mehr verändert.

    Der von Chatgpt.com angegebene Ripple vom 8µV wird durch die Simmulation bestätigt.

    Praktische Erprobung

    ESP32-C3 mit 0.42″ Display

    01. August 2025 · Kommentieren · Kategorien: Allgemein, ESP32, ESP32-C3, Micropython

    Meine Erfahrungen mit dem ESP32-C3-Board mit 0.42″ Display.

    Der erste Schritt – Inbetriebnahme mit Micropython

    Ein Micropythonimage zu finden war kein Problem. Unter https://micropython.org/download/ESP32_C3 kann man das herunterladen. Es ist auf die nur 4MB Flash des C3 ausgelegt. Ich habe das Image für den C3-Mini von Wemos genommen. Das hat funktioniert.

    Am spannensden war die Inbetriebnahme des Displays. Die Datenlage hierzu ist sehr begrenzt. Offiziell sind nur die Pins des I2C-Busses bekannt: SCL = GPIO6, SDA = GPIO5. Zum Controller ist bei den Verkäufern in China nichts zu finden. ChatGPT.com tippte auf SSD1306.

    Ich habe dann in Thonny den ssd1306-Treiber geladen und das von chatgpt vorgeschlagene Testprogrammvorschlag ausprobiert. Und … es funktionierte. Hier das von mir etwas erweiterete Testprogramm:

    # Erster Displaytest -> OK

from machine import Pin, I2C
import ssd1306
import gc

# Display I2C
Disp_SCL = const(6)
Disp_SDA = const(5)

# Allgemeiner I2C
SCL = const(9)
SDA = const(8)

# Display Test
i2c = I2C(0, scl=Pin(Disp_SCL), sda=Pin(Disp_SDA))
oled = ssd1306.SSD1306_I2C(72, 40, i2c)
oled.fill(0)
oled.text("Hallo C3", 0, 0)
oled.text("OK", 0, 10)
oled.text(str(gc.mem_free()) + ' kB', 0, 30)
oled.show()

    Weitere Fonts verwenden

    Den ADC des C3 untersuchen

    Gemäß dem Datenblatt des ESP32-C3 beträgt:

    • DNL -7 … 7 LSB – bei 3,3V -> 0.0056 V oder 0.17 %
    • INL -12 … 12 LSB – bei 3,3 V -> 0.0097 V oder 0.29 %

    Soweit erstmal meine Ersten Erfahrungen. Sobald ich neue Erkenntnisse habe werde ich sie hier veröffentlichen.

    Messungen am ADC des Pico2

    12. Februar 2025 · Kommentieren · Kategorien: Allgemein · Tags: , ,

    Ich habe den ADC im Pico2 einmal näher untersucht. Als Board habe ich den WeAct V20 verwendet, weil bei diesem Board der Referenzspannungsanschluß heraus geführt ist.

    Ich habe mit einem TL431 eine Referenzspannung von 3,1514 Volt (+- 30µV) erzeugt. Ausserdem habe ich den Spannungswandler auf PWM-Betrieb gestellt:

    from machine import ADC, Pin
adc = ADC(Pin(28))
power_mode = Pin(23, Pin.OUT)
power_mode.value(1)   # PWM einschalten

    Als Testspannung habe ich die Referenzspannung eines weiteren TL431 (2,5063 +-100µV) verwendet.

    Die Referenzspannungen wurden aus einem externen linearen Netzteil mit 5 Volt versorgt.

    Dabei konnte ich feststellen, dass es bei Einzelmessungen zu nicht unerheblichen Abweichungen kommt. Ich habe dann ein Sample aus 50.000.000 Messwerten auf ihre Abweichungen untersucht:

    Hier zeigt sich, das die meisten Messungen innerhalb von 1% Abweichungen lagen, aber auch 5,2% Abweichungen bis zu 5% aufwiesen. Erfreulich ist, das keine Abweichungen > 5% aufgetreten sind.

    Diese Daten beziehen sich nur auf ein Pico2 Exemplar und eine Messspannung. Weitere Tests werden folgen.

    « Ältere Beiträge
    Neuere Beiträge »