#picomite

In diesem kurzen Beitrag möchte ich dir zeigen, wie du deinen BASIC Code im Autostart sofort auf dem Raspberry Pi Pico ausführen kannst, sobald dieser Strom erhält.

Wie du in BASIC auf dem Raspberry Pi Pico mit PicoMite programmierst, habe ich dir bereits in den nachfolgenden Beiträgen gezeigt. - BASIC Programmierung am Raspberry Pi Pico W, - Raspberry Pi Pico BASIC #1 - Überblick, - Raspberry Pi Pico BASIC #2 - Speicherverwaltung

Ein kleines Beispiel

Erstellen wir zuerst eine kleine Schaltung am Raspberry Pi Pico mit zwei LEDs, welche lediglich im Wechsel blinken sollen. Benötigte Ressourcen für das Beispiel Wenn du das kleine Beispiel nachbauen möchtest, dann benötigst du: - einen Raspberry Pi Pico* oder Pico W*, - ein Micro-USB Datenkabel*, - eine Powerbank*, - zwei 5 mm, LEDs*, - zwei 220 Ohm Vorwiderstände*, - ein 400 Pin Breadboard* oder - ein GPIO Expander Board*, - diverse Breadboardkabel* Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Schaltung - Raspberry Pi Pico mit zwei LEDs Aufbau der Schaltung Der Aufbau der Schaltung ist sehr einfach und wenn du meinen Blog schon länger verfolgst, dann kennst du diese bestimmt bereits.

Schaltung - Wechselblinker am Raspberry Pi Pico Die beiden LEDs sind wie folgt am Raspberry Pi Pico angeschlossen LEDRaspberry Pi PicoLED - grünKathode (-)220 Ohm Widerstand > GNDAnode (+)GP16LED - blauKathode (-)220 Ohm Widerstand > GNDAnode (+)GP17 Aufbau und Programmieren in BASIC mit PicoMite Im nachfolgenden YouTube-Video erläutere ich dir, wie du die Schaltung aufbaust und in BASIC auf dem Raspberry Pi Pico programmierst. https://youtu.be/kOlrDn8a19M Programmieren von einem Wechselblinker mit zwei LEDs in BASIC Wie man eine LED in BASIC programmiert, hatte ich bereits in meinem ersten Beitrag gezeigt. Hier nun der Code um die beiden LEDs abwechselnd im Intervall von 250 ms. Blinken lässt. SetPin GP16, DOUT SetPin GP17, DOUT For index = 0 To 20 Step 1 Pin(GP16) = 1 Pin(GP17) = 0 Pause 250 Pin(GP16) = 0 Pin(GP17) = 1 Pause 250 Next index Pin(GP16) = 0 Pin(GP17) = 0 Der Quellcode sieht im Fullscreen-Editor folgendermaßen aus:

Autostart per Befehl aktivieren

In diesem Beitrag zeige ich dir, wie du am Raspberry Pi Pico mit BASIC (Picomite) Sensordaten auf eine SD-Karte loggen kannst.

Wie du eine SD-Karte an den Raspberry Pi Pico anschließen kannst und auf dem Dateisystem navigierst, habe ich dir bereits im Beitrag Raspberry Pi Pico BASIC #4 – SD-Karte anschließen gezeigt.

Benötigte Ressourcen für dieses Projekt

Wenn du das kleine Beispiel nachbauen möchtest, dann benötigst du: - einen Raspberry Pi Pico / Pico W, - ein Micro USB-Datenkabel, - ein SD-Karten Modul, - ein DS18B20 Temperatursensor, - diverse Breadboardkabel, männlich-weiblich, 10 cm

Bauteile für die Schaltung In meinem Fall nutze ich für den Temperatursensor DS18B20 ein kleines Board, auf welchem die korrekte Schaltung bereits verdrahtet ist, somit ist der Anschluss an den Mikrocontroller deutlich einfacher.

Temperatursensor DS18B20 auf Adapterplatine

Aufbau der Schaltung

Für den Aufbau der Schaltung verwende ich zusätzlich ein Dual GPIO Expander für den Raspberry Pi Pico / Pico W. Alternativ kannst du den Pi Pico auch auf ein 400 Pin Breadboard stecken und von dort die Pins abgreifen.

Schaltung - Raspberry Pi Pico mit SD-Karten Modul & Temperatursensor DS18B20 Der Schaltung können wir folgenden Anschlussplan entnehmen: KomponenteRaspberry Pi PicoDS18B20GNDGNDDATAGP15VCC5V / VBUSSD-KartenleserGNDGND+5V5V / VBUSCSGP22MOSIGP19SCKGP18MISOGP16

Aufbau der Schaltung und programmieren auf dem Mikrocontroller

Im nachfolgenden YouTube-Video erläutere ich dir, wie du die Schaltung aufbaust und das kleine Programm zum Loggen der Sensordaten auf dem Mikrocontroller schreibst. https://youtu.be/umfOHjo7Az8

Programmieren im Full-Screeneditor in Picomite

Den Code erstellen wir in zwei Schritten, zum einen das Auslesen der Temperatur vom Sensor und danach das Schreiben in eine Datei auf der SD-Karte. Programmieren des Temperatursensors DS18B20 in Picomite Starten wir zunächst damit, den Temperatursensor DS18B20 zu programmieren. TEMPR START GP15 PRINT "Temperatur: " TEMPR(GP15) " C" Wenn wir den Code nun in eine kleine For-Schleife schreiben, dann können wir mehrere Werte nacheinander messen und auf der Konsole ausgeben.

Schreiben einer Datei auf der SD-Karte Nachdem wir soeben die Sensordaten ausgelesen haben, möchten wir diese auf die SD-Karte schreiben. Im ersten Schritt müssen wir eine Datei erzeugen und diese öffnen, dabei müssen wir darauf achten, dass wir den Modus zum Anfügen von Daten verwenden, denn sonst werden die alten immer überschrieben. Open "b:/sensordaten.txt" For output As #1 TEMPR START GP15 For i = 0 To 10 Step 1 Print #1, "Temperatur: " TEMPR(GP15) " C" Next i Close #1 Die Daten sind jetzt auf der SD-Karte und können vom Computer (ein entsprechendes Lesegerät vorausgesetzt) gelesen werden.

Schreiben einer CSV Datei und importieren in Excel

Wenn wir die Sensordaten weiterverarbeiten möchten, dann ist es sinnvoll diese in einem lesbaren Format zu speichern. Das einfachste Format ist hier das CSV Format. Bei diesem werden die Daten Zeilenweise und mit einem Zeichen separiert getrennt gespeichert. Normalerweise trennt man diese Daten mit einem Komma. In meinem Fall möchte ich jedoch das Semikolon nutzen ";", denn der Temperaturwert wird in Deutsch mit einem Komma dargestellt. Natürlich könnte man auch die Temperaturwerte mit doppelten Anführungszeichen umgeben und somit trotzdem das Komma nutzen. TEMPR START GP15 Dim value As Float Open "b:/sensordaten.csv" For output As #1 For i = 0 to 100 Step 1 value = TEMPR(GP15) Print #1, i ";" value Print i "-" value Next i Close #1 Als Ergebnis erhalten wir eine Datei mit den Werten des Temperatursensors. In dem Code gebe ich zusätzlich noch den Wert auf der Konsole aus, damit man den Fortschritt des Schreibens sieht.

Willst du lernen, wie du ein I2C-Display mit dem Raspberry Pi Pico und PicoMite / BASIC zum Laufen bringst? In diesem Artikel zeige ich dir einfache Schritte, um beeindruckende Ergebnisse zu erzielen. Egal, ob du ein Anfänger oder bereits erfahrener Raspberry Pi-Nutzer bist, meine detaillierte Anleitung hilft dir dabei, das Display anzuschließen und zu programmieren. Tauchen wir gleich ein und entdecke mit mir die faszinierende Welt der I2C-Displays mit Raspberry Pi Pico und PicoMite!

In vergangenen Beiträgen hatte ich dir bereits gezeigt, wie du eine RealTimeClock an den Pi Pico anschließt und programmierst, hier möchte ich an den Beitrag nun anknüpfen und die Werte für Datum & Uhrzeit auf dem Display anzeigen.

I2C Schnittstellen am Raspberry Pi Pico

Der Raspberry Pi Pico & Pico W haben mehrere I2C Schnittstellen, damit kannst du mehrere Displays betreiben (vorausgesetzt die Adressen sind verschieden).

Pinout des Raspberry PI Pico Das Bild enthält das Pinout des Raspberry Pi Pico dieser Mikrocontroller ist das Vorgängermodell des Pico W. Jedoch ist die Pinbelegung gleich, daher ist das Bild noch aktuell (Stand 29.05.2023).

Einrichten der I2C Schnittstelle in PicoMite

Bevor wir die I2C Schnittstelle an den gewünschten Pins verwenden können, müssen wir diese konfigurieren. In meinem Fall verwende ich ein I2C-Display mit dem Treiberchip SSD1306, dieser wird auch vom System unterstützt und kann mit dem nachfolgenden Befehl eingerichtet werden. OPTION LCDPANEL SSD1306I2C, , Für den Platzhalter "" setzt du den Wert für Hochform- oder Querformat. - Hochformat = L, - Querformat = P Mit dem optionalen Parameter offset kannst du dein I2C-Display ausrichten. Wenn du ein 0,96" OLED Display verwendest, dann ist dieser Parameter 0 (default, kann also entfallen). Solltest du jedoch ein 1,3" OLED Display verwenden, so musst du als Parameter 2 wählen. In meinem Fall nutze ich ein 1,3" OLED Display im Querformat und muss dann nachfolgenden Befehl eingeben: OPTION LCDPANEL SSD1306I2C, L, 2

Ausgeben von "Hello World!" auf dem I2C-Display

Starten wir zunächst recht einfach und geben die Textzeile "Hello World!" auf dem Display aus.

Der Basic Befehl für die Ausgabe von Text lautet "Text" und hat die Parameter: - Position , - Ausrichtung, - Schriftgröße, - Schriftfarbe, - Hintergrundfarbe Wenn wir nun den Befehl Text mit dem nachfolgenden Parameter eingeben, dann wird ein Text "Hello World!" an der Position X=10, Y=0 im Querformat angezeigt (siehe Grafik oben). Text 10, 0, "Hello World!", "L", 1, 1, RGB(WHITE), RGB(BLACK) Mein OLED Display kann nur Schwarz & Weiß anzeigen, daher setzte ich in meinem Fall mit RGB lediglich White & Black. Solltest du ein Farbiges OLED Display verwenden, so kannst du hier auch andere Werte setzen.

Anzeigen von Datum & Uhrzeit auf dem I2C-Display mit BASIC am Raspberry Pi Pico

Wie du eine RTC an den Raspberry Pi Pico anschließt und mit PicoMite ausliest, habe ich dir bereits im Beitrag Raspberry Pi Pico BASIC #6 – RealTimeClock programmieren erläutert. In diesem Abschnitt möchte ich dir jetzt gerne zeigen, wie du diese Werte auf einem OLED Display anzeigen lassen kannst. Im nachfolgenden YouTube-Video erläutere ich dir Schritt-für-Schritt, wie du die Schaltung aufbaust und das kleine Programm in Basic mit PicoMite programmierst. https://youtu.be/Nb_moX3GCbM

Ausblick

In diesem Beitrag möchte ich dir gerne zeigen, wie du eine RealTimeClock (kurz RTC) am Raspberry Pi Pico mit Picomite in BASIC programmierst.

Den Raspberry Pi Pico mit Picomite habe ich dir bereits in diversen Beiträgen vorgestellt. - BASIC Programmierung am Raspberry Pi Pico W, - Raspberry Pi Pico BASIC #1 – Überblick - Raspberry Pi Pico BASIC #2 – Quellcode organisieren - Raspberry Pi Pico BASIC #3 – Autostart - Raspberry Pi Pico BASIC #4 – SD-Karte anschließen In meinem letzten Beitrag habe ich dir auch gezeigt, wie man Sensordaten von einem Temperatursensor auf eine SD-Karte schreiben kann. In diesem Beitrag möchte ich gerne an diesen Beitrag anknüpfen und die Sensordaten mit einem Zeitstempel speichern. Im Handel erhältst du die RTCs bereits ab 3 € welche meist für den Arduino angepriesen werden.

Auf der RTC ist eine Batterie verbaut, welche die interne Uhr weiterlaufen lässt und so auch ein Zeitstempel ausgelesen werden kann, wenn der Mikrocontroller mal eine Zeit X ohne Strom war.

Benötigte Ressourcen für dieses Projekt

Wenn du die Schaltung nachbauen möchtest, dann benötigst du: - einen Raspberry Pi Pico / Pico W, - ein Micro-USB-Datenkabel, - eine RTC DS3231 mit I2C Schnittstelle, - vier Breadboardkabel, weiblich-weiblich, 10 cm, - optional ein GPIO Dual Expanderboard

Aufbau der Schaltung

Mit den vier Breadboardkabeln schließen wir die RealTimeClock an den Raspberry Pi Pico wie folgt an.

Raspberry Pi Pico mit RealTimeClock (RTC) An den Raspberry Pi Pico kannst du an mehreren Pins ein I2C Device anschließen. Nachfolgend findest du das Pinout.

Pinout des Raspberry PI Pico

Einrichten der RTC in Picomite auf dem Raspberry Pi Pico

Bevor wir den Zeitstempel (Datum & Uhrzeit) von der RTC lesen können, müssen wir diese einrichten. Zunächst müssen wir die I2C Pins aktivieren. OPTION SYSTEM I2C 1, 0 oder OPTION SYSTEM I2C GP0, GP1 Nachdem die ENTER Taste betätigt wurde, startet der Pi Pico neu und danach setzen wir den initialen Zeitstempel mit dem nachfolgenden Befehl. RTC SETTIME Jahr, Monat, Tag, Stunde, Minute, Sekunde zbsp. RTC SETTIME 2023, 4, 29, 18, 0, 0 Mit dem Befehl nachfolgenden Befehl kannst du die RTC beim Starten und jede Stunde

Auslesen von Datum & Uhrzeit von der RealTimeClock

Nachdem wir nun den Zeitstempel gesetzt haben, können wir die beiden Werte Datum & Uhrzeit von dieser lesen. RTC GETTIME Print DATE$ Print TIME$

Ausgabe von Datum & Uhrzeit auf dem Pi Pico mit einer RTC Damit wir aus den Feldern DATE$ und TIME$ die Werte lesen können, müssen die mit dem Befehl "RTC GETTIME" befüllt werden. Wir können dieses jedoch etwas automatisieren, indem wir die nachfolgende Option für die RTC setzen. OPTION RTC AUTO ENABLE

Beispiel - Sensordaten mit Zeitstempel auf SD-Karte schreiben

Im letzten Beitrag hatte ich dir gezeigt, wie du die Sensordaten von einem einfachen digitalen Temperatursensor DS18B20 auf eine SD-Karte schreiben kannst. Jetzt möchte ich statt des Index einen Zeitstempel zu jedem Wert speichern. Aufbau der Schaltung - RTC, DS28B20 & SD-Kartenleser Die RTC lässt sich wie nachfolgend gezeigt in die ggf. bereits bestehende Schaltung integrieren.

Schaltung - Pi Pico mit DS18B20, RTC & SD-Kartenleser Für den Temperatursensor DS18B20 habe ich ein kleines Board auf welchem bereits die Schaltung mit dem 4,7 kOhm Widerstand verbaut ist.

Aufbau der Schaltung - Raspberry Pi Pico mit Realtimeclock, Temperatursensor DS18B20 und SD-Kartenleser

Programmieren im Fullscreen-Editor in Picomite

Erweitern wir jetzt das Programm um den Zeitstempel. TEMPR START GP15 Dim value As Float Open "b:/sensordaten.csv" For output As #1 RTC GETTIME For i = 0 to 100 Step 1 value = TEMPR(GP15) Print #1, DATE$ " " TIME$ ";" value Print i DATE$ " " TIME$ "-" value Next i Close #1 Die CSV Datei auf der SD-Karte enthält nun den Zeitstempel sowie die Sensordaten getrennt durch ein Semikolon.

In diesem Beitrag zeige ich dir, wie du eine SD-Karte anschließen kannst, um dort per BASIC Daten vom Raspberry Pi Pico zu speichern.

Im letzten Beitrag Raspberry Pi Pico BASIC #2 - Quellcode organisieren habe ich dir bereits gezeigt, wie du deine Daten auf dem Raspberry Pi Pico in Slots und Dateien speichern kannst. Hier geht es nun ein Stückchen weiter und ich zeige dir wie du ein SD-Karten Modul anschließt und auf einer SD-Karte deine Daten speicherst.

Benötigte Ressourcen für den Anschluss einer SD-Karte an den Raspberry Pi Pico

Wenn du eine SD-Karte an den Raspberry Pi Pico anschließen möchtest, dann benötigst du: - einen Raspberry Pi Pico oder Pico W, - ein Micro-USB-Datenkabel, - ein SD-Karten Modul, - eine SD-Karte, - ein paar Breadboardkabel, weiblich-weiblich, 10 cm, - ein GPIO Expander Board In meinem Fall verwende ich ein GPIO Expander Board, das ist natürlich keine Pflicht und du kannst die Breadboardkabel auch so an den Pi Pico anschließen. Jedoch finde ich dieses etwas aufgeräumter.

Bauteile für den Anschluss eines SD-Karten Moduls an den Raspberry Pi Pico Im Beitrag DIY Expansion Board für Raspberry PI Pico mit Grove Adapter habe ich dir bereits mein kleines Board vorgestellt welches ebenso gut funktioniert, der Vorteil vom GPIO Expander Board von Waveshare ist jedoch, dass dieser noch einen Adapter für die Pi Hats hat.

Anschluss eines SD-Karten Moduls an den Raspberry Pi Pico

Das mir vorliegende Modul wird per SPI an den Pi Pico angeschlossen. Du hast am Mikrocontroller zwei SPI Schnittstellen.

Pinout des Raspberry PI Pico Die Grafik ist vom Hersteller und darf ich mit freundlicher Genehmigung auf meinem Blog verwenden. In meinem Fall nutze ich die SPI0 Pins für den Anschluss.

Schaltung - Raspberry Pi Pico mit SD-Karten Modul per SPI SD-Karten ModulRaspberry Pi Pico / Pico WGNDGND+55V / VBUSCSGP22MOSIGP19SCKGP18MISOGP16

Einrichten in PicoMite

Wenn das SD-Karten Modul angeschlossen ist, dann muss dieses noch eingerichtet werden. Dazu nutzen wir den nachfolgenden Befehl: OPTION SYSTEM SPI GP18, GP19, G16 Danach definieren wir noch den CS Pin des SD-Karten-Moduls mit: OPTION SDCARD GP22 Auswählen des Laufwerkes

Auswählen des Laufwerkes für die SD-Karte

Die SD-Karte wird per Default auf dem Laufwerk "B" eingebunden. Mit dem Befehl DRIVE $buchstabe können wir nun auf dieses wechseln. DRIVE "B:"

Laufwerk "B" in PicoMite für die SD-Karte

Unterstützte SD-Karten

Es werden nicht alle SD-Karten unterstützt. Ggf. erhältst du den Fehler "There is no valid FAT volume".

PicoMite - Fehler beim laden der SD-Karte Ich habe noch viele alte SD-Karten rumfliegen und konnte nachfolgende SD-Karten wiederverwenden: - MEDION - 256 MB, - Intenso - 1 GB, - CnMemory - 4 GB (First class), - SanDisk - 4 GB (SDHC class 4), - HAMA - 8 GB (SDHC class 6)

Quellcode verwalten

In diesem Beitrag möchte ich dir einen Überblick über den BASIC Interpreter für den Raspberry Pi Pico geben.

Im ersten Beitrag BASIC Programmierung am Raspberry Pi Pico W habe ich dir bereits gezeigt, wie du die Firmware installierst und erste Schritte mit diesem machst. Hier soll es nun darum gehen, dir einen Überblick über den Funktionsumfang und den Befehlen geben.

Aufbau einer Verbindung zum Raspberry Pi Pico mit Putty

Damit du auf dem Raspberry Pi Pico programmieren kannst, musst du eine Verbindung mit einem Terminalprogramm zu diesem aufbauen. Ich nutze hier das Tool Putty, welches du kostenfrei herunterladen kannst.

Einstellungen für Putty zum Aufbau einer Verbindung zu PicoMite Wenn die Verbindung erfolgreich aufgebaut wurde, dann erhältst du zunächst einen einfachen Prompt, wo du gleich mit der Programmierung starten kannst. Ein Vorteil von Putty ist, dass sich das Terminalfenster sehr leicht konfigurieren lässt. Unter den Einstellungen kannst du zum Beispiel die Schriftgröße und Schriftart anpassen. Dazu navigierst du über Appearance (1) unter Window über Change... (2) zum Dialog "Schriftart". Dort kannst du nun die Schriftart (3) und die Schriftgröße (4) auswählen, zum Schluss musst du deine eventuelle Auswahl noch mit der schaltfläche OK (5) bestätigen.

Navigieren

Der Prompt (der kleine, grüne, rechteckige Cursor) lässt sich mit den Pfeiltasten bewegen. Den geschriebenen Text kannst du mit der Entfernen-Taste löschen. Die Backspace-Taste zu Deutsch Rückschritt-Taste funktioniert nicht wie gewohnt, denn diese löscht nicht vom Cursor nach links, sondern nach rechts. Mit den Pfeiltasten hoch und runter kannst du durch die Historie der bereits eingegebenen Befehle navigieren.

Fullscreen-Editor

Der Fullscreen-Editor startet nicht per Default, diesen musst du mit der Taste F4 manuell starten.

Fullscreen-Editor von PicoMite Aktivieren / Deaktivieren des Syntax Highlighting Ebenso ist das Syntax Highlighting nicht aktiviert, dieses muss auf der Konsole durch die Eingabe des nachfolgenden Befehls aktiviert werden. OPTION COLOURCODE ON Dieses kannst du natürlich auch wieder deaktivieren: OPTION COLOURCODE OFF Die gewählte Option bleibt auch nach dem neu Starten bzw. dem Trennen vom Strom erhalten.

Code ohne Syntax Highlighting

Code mit Syntax Highlighting Der Vorteil am Hervorheben des Quellcodes ist, dass eventuelle Schreibfehler bei Befehlen, fehlende Klammern und Anführungszeichen leichter gefunden werden. Funktionen des Fullscreen-Editors Der Fullscreen-Editor hat am unteren Bildschirmrand eine Funktionsleiste mit den Shortcuts für: - F1: Save -Speichern, - F2: Run - Ausführen, - F3: Find - Suchen, - F4: Mark - Markieren, - F5: Paste - Einfügen Speichern des Codes Wenn du die Taste F1 betätigst, dann wird der Code gespeichert, es erfolgt keine Abfrage nach einem Dateinamen, denn der Code wird im Speicher abgelegt. Du erhältst nach dem Speichern die Ausgabe, wie viel Speicherplatz dein Code bereits belegt.

Mit der Taste F4 kehrst du wieder zum Fullscreen-Editor zurück. Code ausführen Den führst du mit der Taste F2 aus. Solange der Code läuft, kannst du keine andere Operation starten und du musst somit warten bis dieser fertig durchlaufen ist. Im Code Suchen Wenn du einen sehr langen Quellcode mit sehr vielen Zeilen vor dir hast und einen bestimmten Abschnitt suchst, dann hilft dir die Funktion suchen über die Taste F3 weiter. Die Suche startet immer ab dem aktuellen Cursor, wenn du einen weiteren Treffer finden möchtest, dann musst du die Suche immer erneut von der neuen Cursorposition starten. Code markieren, kopieren, ausschneiden & einfügen Mit der Taste F4 startest du den Modus zum Markieren von Code. Dabei kannst du dann mit den Pfeiltasten den Code wählen und per F5 den Code kopieren und mit F6 den Code ausschneiden. Wenn du den Code kopiert oder ausgeschnitten hast, kannst du den Modus mit der Escape-Taste verlassen und mit der Taste F5 an einer neuen Stelle einfügen.

Ausblick

In diesem Beitrag möchte ich dir zeigen, wie du am Raspberry Pi Pico W mit der Programmiersprache BASIC einsteigen kannst.

Den Raspberry Pi Pico & Pico W habe ich dir bereits in diversen Beiträgen auf diesem Blog vorgestellt. Hier geht es nun um eine weitere Möglichkeit der Programmierung.

Rückblick - Programmieren mit BASIC

Die Programmiersprache Basic ist sehr alt (erste Veröffentlichung im Jahr 1964) und steht für "Beginner’s All-purpose Symbolic Instruction Code". Der Code wird hier Zeilenweise aufgebaut und ausgeführt, dieses nennt man auch Prozedurale Programmierung. Man kann hier zu anderen Codezeilen mit dem Befehl GOTO springen (was heute sehr verpönt ist). Der Funktionsumfang ist für damalige Verhältnisse sehr umfangreich und der Code ist auch sehr gut lesbar. Wenn du mehr über diese Programmiersprache lesen möchtest, dann empfehle ich dir die Seite: Seite „BASIC“. In: Wikipedia – Die freie Enzyklopädie. Bearbeitungsstand: 2. März 2023, 12:32 UTC. URL: https://de.wikipedia.org/w/index.php?title=BASIC&oldid=231413014 (Abgerufen: 27. März 2023, 08:17 UTC)

Erfahrungen mit QBasic

Meine ersten Erfahrungen in der Programmierung konnte ich mit QBasic an einem Amstrad 1512 sammeln. Dieser PC hatte eine 10 MB Festplatte und zwei 5¼ Zoll Diskettenlaufwerke. Als Betriebssystem wurde zunächst MS-DOS 6.22 eingesetzt und später konnte ich sogar Windows 3.0 mit einer Maus installieren. Auf diesem System mit einem Schwarz/Weiß Monitor habe ich angefangen zu programmieren und habe so kleine Programme in QBasic und auch Pascal entwickelt. Aus diesem Grund bin ich schon sehr gespannt, was alles so von den gesammelten Erfahrungen hängen geblieben ist.

Bezug des BASIC Interpreters PicoMite und erste Schritte

Die Programmierung auf dem Raspberry Pi Pico / Pico W erfolgt hier mit dem Interpreter PicoMite, die offizielle Dokumentation und den Download der Firmware findest du unter https://geoffg.net/picomite.html. Zunächst müssen wir den Pi Pico mit der Firmware flashen. Die Firmware laden wir als ZIP-Datei inkl. der Dokumentation als PDF-Datei herunter und kopieren wir auf den Mikrocontroller, jedoch muss dieser zuvor in den speziellen Modus zum Upload einer UF2-Datei versetzt werden. Achtung: Der Vorgang löscht alle Daten, Programme auf dem Mikrocontroller unwiderruflich! Im nachfolgenden YouTube-Video von meinem Kanal zeige ich dir, wie du deinen Mikrocontroller flasht und eine LED zum Blinken bringen kannst. https://youtu.be/JnnpK_TXBlA

Aufbau einer Verbindung mit Putty

Zur Programmierung in BASIC müssen wir eine Verbindung mit einem Terminalprogramm aufbauen. Hier nutze ich wieder Putty. Das Tool ist kostenfrei, klein und kommt auch ohne eine zusätzliche Installation daher. Du kannst dir dieses von der Seite https://www.putty.org/ herunterladen.

Einstellungen für Putty zum Aufbau einer Verbindung zu PicoMite Wenn man die Verbindung aufgebaut hat, dann wird zunächst ein kleiner Prompt oben links (Grafik 1) angezeigt. Hier könnte man sofort mit dem Schreiben loslegen, jedoch würde ich dir den Fullscreen-Editor (Grafik 2) empfehlen, welchen du mit der Taste F4 starten kannst.

Speichern des Programmes

Der erzeugte Code kann maximal 100 KB haben und wird zunächst im internen FLASH Speiche abgelegt. Der Code bleibt erhalten, auch wenn der Pi Pico keinen Strom mehr hat! Zusätzlich lässt sich der Code in bis zu 5 sogenannten Slots organisieren. Auf dieses Feature möchte ich jedoch in einem eigenen Beitrag speziell eingehen.

Ausgabe von Texten

Mit dem Befehl "PRINT" lassen sich Texte auf dem Terminal ausgeben.

Beispiel - Blinken einer LED am Raspberry Pi Pico mit BASIC

Abschließend möchte ich dir gerne ein kleines Beispiel zeigen, wie du mit PicoMite in BASIC am Raspberry Pi Pico / Pico W eine LED zum Blinken bringen kannst. Schaltung am Raspberry Pi Pico Für den Aufbau der Schaltung benötigst du: - einen Raspberry Pi Pico oder Pico W, - ein Micro-USB Datenkabel, - eine 5 mm, LED, - ein 220 Ohm Vorwiderstand, - ein 400 Pin Breadboard