Spis treści:
- 1 Vor dem Start sollte das Team zusammengestellt werden
- 2 Was sind Unterbrechungen und wie funktionieren sie?
- 3 Unterbrechungen im RP2040
- 4 Änderung des Zustands einer Diode in einer Unterbrechung
- 5 Kontaktvibrationen und nicht festgelegte Zustände
- 6 Einmaliger Code, also ein Alarm
- 7 Ein paar Worte zum Schluss...
Vor uns liegt ein weiterer Teil des Materials über das kleine Entwicklungskit Raspberry Pi Pico W. Beim letzten Mal haben wir uns die Code-Optimierung etwas genauer angesehen und einige eigene Funktionen geschrieben. Außerdem haben wir den im PR2040-Kern eingebauten Temperatursensor verwendet. Dieses Mal werden wir die erstaunliche Welt der Mikrocontroller-Unterbrechungen erkunden.
Kaufen Sie ein Set, um das Programmieren mit dem Raspberry Pi Pico W zu erlernen, und nutzen Sie die Vorteile des Kurses, der im Botland Blog verfügbar ist!
Im Set enthalten: Raspberry Pi Pico W-Modul, Kontaktplatte, Leitungen, LEDs, Widerstände, Tasten, Fotowiderstände, digitale Licht-, Temperatur-, Feuchtigkeits- und Drucksensoren, OLED-Display und ein USB-microUSB-Kabel.
Inhaltsverzeichnis:
- Raspberry Pi Pico – #1 – Einstieg
- Raspberry Pi Pico – #2 – ein paar Worte zur Programmierung
- Raspberry Pi Pico – #3 – erstes Programm
- Raspberry Pi Pico – #4 – wir beginnen mit der Programmierung
- Raspberry Pi Pico – #5 – Schleifen, Variablen und bedingte Anweisungen
- Raspberry Pi Pico – #6 – PWM, ADC und Kommunikation mit dem Computer
- Raspberry Pi Pico – #7 – Codekorrekturen und eigene Funktionen
- Raspberry Pi Pico – #8 – Unterbrechungen und Alarme
Vor dem Start sollte das Team zusammengestellt werden
Wer das Programmieren anhand von realen Projekten erlernen möchte, braucht natürlich die richtige Ausrüstung, aber keine Sorge – Sie müssen jetzt nicht von einem Artikel zum nächsten springen und eine Liste der benötigten elektronischen Komponenten erstellen. Im Botland-Shop ist ein fertiger Bausatz erhältlich, der alle notwendigen Komponenten enthält, um die in der Tutorial-Reihe beschriebenen Projekte mit dem Raspberry Pi Pico durchzuführen.
In dem fertigen Set von Elementen finden Sie:
- Raspberry Pi Pico W,
- MicroUSB-Kabel,
- Kontaktplatte,
- Ein Set von Anschlusskabeln in drei Ausführungen,
- Ein Set von LEDs in drei Farben,
- Ein Set der in der Elektronik am häufigsten verwendeten Widerstände,
- Tact Switch-Tasten,
- Fotowiderstände,
- Digitaler Lichtsensor,
- Digitaler Feuchtigkeits-, Temperatur- und Drucksensor,
- OLED-Display.
Was sind Unterbrechungen und wie funktionieren sie?
Während Sie diesen Text lesen, ruhen Ihre Hände wahrscheinlich auf einer Computermaus. Wenn Sie diese bewegen, ändert der Cursor, den Sie auf dem Monitor sehen, seine Position. Das ist nicht weiter verwunderlich, denn das ist die Aufgabe des Mauszeigers. Haben Sie sich jedoch schon einmal gefragt, wie dieser Vorgang gehandhabt wird, mit anderen Worten, wie es möglich ist, dass der Computer weiß, dass Sie das Zeigegerät genau in diesem Moment bewegt haben. Die Antwort ist einfach: Der Laser in der Maus erkennt die Bewegung, die Daten werden an den Computer gesendet, der sie verwendet, um die Position des Cursors auf dem Bildschirm zu ändern. Die Antwort ist absolut richtig, aber woher weiß der Prozessor im Computer, dass dies der Moment ist, in dem die Maus bewegt wurde und nicht in einer, zwei oder zehn Sekunden. Man könnte meinen, dass es ab und zu überprüft, ob sich die Position des Zeigegeräts geändert hat, aber diese Theorie ist etwas weit hergeholt. Schon ohne sie hat der Computer etwas zu tun: einen Browser bedienen, ein minimiertes Spotify-Fenster mit Ihrer Lieblingsmusik oder unzählige Systemprozesse, von deren Existenz wir nicht einmal wissen. Jede Millisekunde rauscht eine Flut von Bits durch den Prozessor, und ständig zu prüfen, ob sich die Maus versehentlich bewegt hat, wäre eine außerordentliche Verschwendung von Ressourcen. Und genau hier kommen die Unterbrechungen ins Spiel.
Wenn wir die Maus bewegen, werden die vom USB- oder Bluetooth-Controller empfangenen Daten zusammen mit einer Meldung über eine Unterbrechung an den Prozessor gesendet. Mit anderen Worten: Der Kommunikations-Chip informiert die CPU, dass eines der externen Geräte sofort gewartet werden muss. An diesem Punkt setzt die zentrale Recheneinheit alle ihre Ressourcen ein und unterbricht laufende Prozesse, um die Maus so schnell wie möglich zu bedienen und den Cursor an die richtige Stelle zu lenken. Sobald diese Aufgabe abgeschlossen ist, kehrt der Prozessor zu seinem normalen Betrieb zurück. Natürlich ist diese ganze Beschreibung etwas vereinfacht und die Handhabung von USB-Geräten sieht etwas anders aus, aber die Idee ist da. Das Ganze basiert auf Unterbrechungen, so dass der Prozessor weiß, dass er die gerade laufende Aufgabe sofort unterbrechen und etwas ‘Wichtigeres’ in der Systemhierarchie tun muss.
Unterbrechungen im RP2040
Der RP2040-Mikrocontroller zeichnet sich, wie andere ARM-Core-Prozessoren auch, durch einen bestimmten universellen Satz von Unterbrechungen aus, die wir in mehrere Kategorien einteilen können.
- GPIO Unterbrechungen – der Raspberry Pi Pico unterstützt Unterbrechungen, die als Reaktion auf Zustandsänderungen an GPIO-Pins erzeugt werden. Diese Unterbrechungen sind konfigurierbar und können bei einer steigenden Flanke, einer fallenden Flanke oder einem bestimmten Logikpegel aktiviert werden. Mit dieser Art von Funktionalität kann der Mikrocontroller auf Ereignisse wie das Drücken einer Taste, eine Zustandsänderung auf dem Bus oder die Erkennung von Ereignissen durch einfache Sensoren reagieren.
- Timer Unterbrechungen – Der RP2040 verfügt über zwei Multifunktions-Timer, die auch Unterbrechungen erzeugen können. Diese Art der Verwendung von Timern ermöglicht die Ausführung bestimmter Aufgaben in genau festgelegten Zeitabständen.
- UART/SPI/I2C/USB Unterbrechungen – Die vom RPI unterstützten Kommunikationsschnittstellen verfügen über einen eigenen Satz von Unterbrechungen. Sie unterstützen die Übertragung von Daten zwischen dem Mikrocontroller und anderen Peripheriegeräten. Unterbrechungen können sowohl den Empfang als auch die Übertragung von Daten übernehmen, was die Programme, die diese Schnittstellen verwenden, erheblich vereinfacht.
- PWM Unterbrechungen – Wir haben bereits in einem früheren Tutorial ein Modul verwendet, das PWM-Modulation unterstützt. Es ist jedoch wissenswert, dass diese Prozessorkomponente auch Unterbrechungen erzeugen kann, wenn ein PWM-Zyklus abgeschlossen ist oder wenn ein bestimmter Impulsfüllwert erreicht wird. Dies ist eine nützliche Funktion, insbesondere bei Anwendungen, die eine präzise Signalsteuerung erfordern.
- ADC Unterbrechungen – Eine weitere Komponente, die wir verwendet haben und die ebenfalls Unterbrechungen erzeugen kann, ist der eingebaute ADC. In diesem Fall wird das Signal, das die Unterbrechung aktiviert, nach Abschluss der Analog-Digital-Wandlung auftreten.
- RTC Unterbrechungen – Die Entwickler des RP2040 haben sich dafür entschieden, eine RTC-Echtzeituhr in den Prozessor einzubauen, die Unterbrechungen in bestimmten Zeitintervallen oder in Bezug auf bestimmte Uhrereignisse, wie das Verstreichen einer Stunde, einer Minute usw., erzeugen kann. Mit diesen Arten von Unterbrechungen ist ein präzises Zeitmanagement möglich.
- DMA Unterbrechungen – Die meisten modernen CPUs unterstützen die Übertragung von Daten zwischen Speicher und Peripheriegeräten ohne Beteiligung der CPU. Dieser Vorgang wird von DMA-Einheiten durchgeführt, die auch eine Unterbrechung erzeugen können, wenn der Informationsaustausch abgeschlossen ist.
Zusätzlich zu diesen ziemlich universellen Unterbrechungen bietet der RP2040 auch so etwas wie XIP_IRQ. Diese Abkürzung ist nicht so eindeutig wie die anderen in der obigen Tabelle. Dies ist eine mit dem SSI-Modul verbundene Unterbrechung, die u.a. verwendet wird, wenn das vom Mikrocontroller ausgeführte Programm in seinem internen, flüchtigen SRAM gespeichert wird.
Interessant ist auch die Struktur des IRQ-Registers, in dem die Unterbrechungen gespeichert werden. Wie Sie leicht erkennen können, gibt es 26 Unterbrechungen, während das Register selbst 32 Bits hat. Die verbleibenden sechs Bits sind ungenutzt und physisch nicht mit dem NVIC verbunden, der Komponente, die für die Bearbeitung von Unterbrechungen zuständig ist. Obwohl der Prozessor die überflüssigen Bits nicht verwendet, können sie aus dem Programm heraus gespeichert werden, obwohl dies keine physikalischen Auswirkungen hat.
Änderung des Zustands einer Diode in einer Unterbrechung
Um zu testen, wie Unterbrechungen funktionieren, werden wir ein einfaches Programm erstellen, das den Zustand einer LED in den entgegengesetzten Zustand ändert, wenn eine Taste einmal gedrückt wird. Ich habe dieses Projekt interrupt_led genannt und wir werden die zuvor vorbereitete Schaltung darin verwenden. Sobald das neue Projekt vorbereitet ist, können wir direkt mit dem Code beginnen.
#include
#include "pico/stdlib.h"
#define YELLOW_LED 1
#define BUTTON 16
bool led_status = false;
//interrupt handler function
void gpio_irq_handler(uint gpio, uint32_t events)
{
led_status = !led_status;
gpio_put(YELLOW_LED, led_status);
}
int main() {
stdio_init_all();
// LED and button initialization
gpio_init(YELLOW_LED);
gpio_set_dir(YELLOW_LED, GPIO_OUT);
gpio_put(YELLOW_LED, led_status);
gpio_pull_up(BUTTON);
//interrupt initialization
gpio_set_irq_enabled_with_callback(BUTTON, GPIO_IRQ_EDGE_FALL, true, gpio_irq_handler);
while(true) {
tight_loop_contents(); // "do nothing" function
}
}
Das Programm, das wir dieses Mal durchführen werden, ist recht einfach und kurz. Zunächst binden wir wie üblich die erforderlichen Bibliotheken ein und definieren den Port, an den die LED und die Taste angeschlossen sind. Zusätzlich dazu habe ich hier eine globale Variable led_status platziert, die den aktuellen Zustand der LED speichert. Das nächste Element des Codes ist die mit einer Unterbrechung assoziierte Funktion, aber darauf kommen wir gleich zurück, wenden wir uns nun der Hauptfunktion main zu. Darin wurde eine LED initialisiert, der sofort der in der Variablen status gespeicherte Zustand zugewiesen wurde. Der Standardwert ist false. Deshalb leuchtet die LED nicht auf, wenn das Programm gestartet wird. Dann wird dank der Funktion gpio_pull_up die Leitung Nummer 16, an die die Taste angeschlossen ist, zur Stromversorgung hochgezogen.
Eine andere der Funktionen löst eine GPIO-Unterbrechung aus. Ihre Argumente sind: der Ausgang, von dem die Unterbrechung ausgeht, event_mask – das Ereignis, das zu einem Unterbrechungs-Signal führen soll, true – das Argument, das die Unterbrechung auslöst und der sogenannte handler, d.h. die Funktion, in der die Unterbrechungs-Bedienung beschrieben wird. In unserem Code wird die Funktion, die die Unterbrechung auslöst, durch die Definition BUTTON beschrieben, d.h. die Unterbrechung sollte von dem Pin mit der Nummer 16 kommen. Das Argument event_mask ist GPIO_IRQ_EDGE_FALL, d.h. die Unterbrechung wird ausgelöst, wenn eine fallende Flanke am Ausgang vorliegt. Mit anderen Worten, wenn die Taste gedrückt wird, denn dadurch wird der RP2040-Pin gegen Masse kurzgeschlossen. Auch andere Argumente können hier angeführt werden:
- GPIO_IRQ_EDGE_RISE – steigende Flanke,
- GPIO_IRQ_LEVEL_HIGH – hoher Status am Pin,
- GPIO_IRQ_LEVEL_LOW – niedriger Zustand am Pin.
Als Nächstes lösen wir dank true die Unterbrechung aus und geben den Namen der Funktion an, die ausgeführt werden soll, wenn die Unterbrechung erkannt wird, d.h. gpio_irq_handler.
Nach der Initialisierung führt der Prozessor eine unendliche while-Schleife aus, die nichts tut. Darin habe ich einen speziellen Befehl platziert, der genau folgendes bedeutet: nichts zu tun, und der mit dem aus dem Assembler bekannten NULL-Code verglichen werden kann.
Wenn wir das Programm starten, beginnt der RP2040 fast sofort mit der Ausführung einer leeren while-Schleife. Allerdings ändert sich alles, wenn die Taste gedrückt wird. An diesem Punkt wird ein Unterbrechungs-Signal ausgelöst und das entsprechende Bit wird in das IRQ-Register geschrieben. An diesem Punkt wird der Prozessor auch die Unterbrechung bearbeiten. Dank der Funktion, die die Unterbrechung ausführt, weiß sie, dass der Code, den sie ausführen soll, in der Funktion gpio_irq_handler steht. Beachten Sie, dass sie in diesem Beispiel am Anfang des Programms steht, im Gegensatz zu den Funktionen, die wir im vorherigen Artikel vorbereitet haben. Diese Lösung ist sehr gut und sorgt dafür, dass wir keine Funktionsprototypen an den Anfang des Codes stellen müssen. Aus ästhetischen Gründen ziehe ich es jedoch vor, meine eigenen Funktionen am Ende des Codes zu platzieren.
Der vorbereitete handler vom Typ void, d.h. der keine Informationen zurückgibt, erwartet von uns zwei Argumente – gpio vom Typ uint und events vom Typ uint32_t. Wir brauchen uns jedoch nicht übermäßig um diese Argumente zu kümmern; der Prozessor wird sie automatisch verarbeiten. Allerdings werden hier, wie unschwer zu erraten ist, die GPIO-Pin-Nummer und das Ereignis, auf das die Unterbrechung reagieren soll, übergeben.
Innerhalb der Funktion, die die Unterbrechung verarbeitet, habe ich zwei Befehle platziert, die die LED veranlassen, ihren Zustand zu ändern. Zunächst wird der Variable led_status ihr umgekehrter Zustand zugewiesen. Dies wird durch den Negationsoperator ‘!’ ermöglicht. Mit anderen Worten: Wenn false in led_status gespeichert ist, wird der Variable truth, der entgegengesetzte Zustand, zugewiesen. Eine weitere Funktion ist das bereits bekannte gpio_put zur Steuerung der LED.
Nachdem wir das Programm ausgeführt haben, sehen wir, dass nichts passiert. Wie bereits erwähnt, führt der Prozessor dann eine leere while-Schleife aus. Es ist wahrscheinlich, dass, wie im Video, die grüne LED ausgelöst wird, aber das ist für unseren Code nicht relevant. Die Frage, warum das so ist, wird später im Artikel beantwortet. Wenn die Taste gedrückt wird, registriert der Prozessor die Unterbrechung und die Funktion, die sie behandelt, wird ausgeführt und die gelbe LED ändert ihren Zustand. Wie Sie im Video und im wirklichen Leben sehen können, ändert nicht jeder Tastendruck den Zustand der LED. Dies geschieht durch die Vibration der Kontakte in der Taste und ist ein ganz gewöhnliches Phänomen, auf das wir gleich eingehen werden. Zu diesem Zeitpunkt kann jedoch gesagt werden, dass das Programm korrekt funktioniert und die von der Taste erzeugte Unterbrechung verarbeitet wird.
Kontaktvibrationen und nicht festgelegte Zustände
Es ist an der Zeit zu beantworten, warum die grüne LED aufleuchtet, wenn das oben beschriebene Beispiel ausgeführt wird. Das liegt daran, dass die RPI-Leitung, mit der dieses Element verbunden ist, in keiner Weise definiert ist. Mit anderen Worten, das Programm verwendet diesen GPIO-Pin nicht, so dass seine Funktion undefiniert ist. In diesem Fall kann der Ausgang des Mikrocontrollers jeden beliebigen Zustand annehmen, und wir können weder vorhersagen, ob er hoch oder niedrig sein wird, noch ob er als Eingang oder Ausgang fungiert.
Ebenfalls kurz zu erläutern ist das Phänomen der sogenannten Kontaktvibration, die durch Drücken einer an den Raspberry Pi Pico W angeschlossenen Taste beobachtet werden kann. Es kam vor, dass die LED ihren Zustand nicht änderte, oder sie tat es, kehrte aber fast sofort in ihre vorherige Konfiguration zurück.
Wenn wir den Knopf drücken, schließen wir seine Kontakte mit der Masse kurz, es scheint ein Null-Eins-Prozess zu sein: eine logische Eins, wenn der Knopf nicht gedrückt wird, und eine Null, wenn er gedrückt wird. In Wirklichkeit sieht es jedoch etwas anders aus. Wenn wir ein Oszilloskop an die Tastenkontakte anschließen würden, würden wir ähnliche Wellenformen wie in der obigen Grafik sehen. Wenn die Taste gedrückt oder losgelassen wird, vibrieren die Kontakte. Während dieses kurzen Moments kann sich der vom RPI gelesene Zustand sogar mehrmals ändern, so dass die Unterbrechung auch mehrmals ausgelöst werden kann. Dadurch ist uns das nicht ganz intuitive Verhalten des Programms aufgefallen.
Das Problem der vibrierenden Tastenkontakte kann im Wesentlichen auf zwei Arten gelöst werden – Hardware oder Software. Im ersten Konzept müssen der Taste ein paar Elemente in Form von zwei Widerständen und einem Kondensator hinzugefügt werden (eine aufwändigere Version mit einem zusätzlichen Logikgatter ist ebenfalls zu finden). Zusammen bilden sie einen einfachen RC-Filter, dessen Aufgabe es ist, unkorrigierte Impulse so weit wie möglich zu entfernen, so dass der Mikrocontroller ein Signal erhält, das einem idealen Rechtecksignal so nahe wie möglich kommt.
Die Kontaktverlegenheit kann auch programmatisch gelöst werden, indem Sie eine einfache Funktion erstellen, die erkennt, dass eine Taste gedrückt wurde, ein paar Millisekunden wartet und den Status erneut überprüft. Befindet sich diese immer noch in dem Zustand, in dem sie erkannt wurde, bedeutet dies, dass der Benutzer die Taste gedrückt hat und Sie mit der Ausführung des Programms fortfahren können, das sie unterstützt. Wir werden diese Art von Code in Zukunft vorbereiten. Für diese Art der Unterbrechungs-Behandlung ist eine Softwarelösung jedoch nicht ganz geeignet. Denken Sie daran, dass Unterbrechungen ‘automatisch’ gemeldet werden, wir haben wenig Einfluss darauf, wie sie erkannt werden. Wenn der entsprechende Zustand oder die entsprechende Flanke des Signals auftritt, wird ein bestimmtes Bit im Register des Mikrocontrollers gesetzt, und der Code, der ausgeführt wird, wenn eine Unterbrechung erkannt wird, ist genau eine Reaktion auf dieses Bit und nicht auf einen physischen Tastendruck.
Einmaliger Code, also ein Alarm
Eine interessante Funktion, die der Raspberry Pi Pico unterstützt, sind die sogenannten Alarme. Dies sind Funktionen, die nach einer bestimmten Zeit einmalig aufgerufen werden, was wir als einmalige Systemunterbrechung bezeichnen können. Dies kann vor allem dann nützlich sein, wenn wir einen bestimmten Teil des Codes kurz nach dem Start des Mikrocontrollers, aber unabhängig von der Hauptprogrammschleife ausführen müssen.
Um die Alarmfunktion zu testen, habe ich ein weiteres Projekt mit dem Namen Alarm vorbereitet, wobei ich weiterhin dieselbe elektronische Schaltung verwende. In dem Programm werden wir die bereits gelernte Funktion verwenden, die den Fotowiderstand betätigt und Informationen über die Lichtintensität und den Spannungswert an den Computerbildschirm sendet. Gleichzeitig, unabhängig vom Hauptcode, werden 10 Sekunden nach der Aktivierung des RP2040 alle LEDs eingeschaltet. Lasst uns zum nächsten Beispiel übergehen.
#include
#include "pico/stdlib.h"
#include "hardware/adc.h"
//definitions and prototypes of functions
#define GREEN_LED 0
#define YELLOW_LED 1
#define RED_LED 2
const float conversion_factor = 3.3/4095;
int64_t alarm(alarm_id_t id, void *user_data);
void PhotoresRun();
int main() {
stdio_init_all();
gpio_init(YELLOW_LED);
gpio_set_dir(YELLOW_LED, GPIO_OUT);
gpio_put(YELLOW_LED, 0);
gpio_init(GREEN_LED);
gpio_set_dir(GREEN_LED, GPIO_OUT);
gpio_put(GREEN_LED, 0);
gpio_init(RED_LED);
gpio_set_dir(RED_LED, GPIO_OUT);
gpio_put(RED_LED, 0);
//alarm setup
add_alarm_in_ms(10000, alarm, NULL, false);
adc_init();
adc_gpio_init(26);
adc_select_input(0);
while(true) {
PhotoresRun();
sleep_ms(500);
}
}
//alarm handling function
Int64_t alarm(alarm_id_t id, void *user_data)
{
gpio_put(YELLOW_LED, 1);
gpio_put(GREEN_LED, 1);
gpio_put(RED_LED, 1);
return 0;
}
void PhotoresRun(){
uint16_t photores_read = adc_read();
const float voltage_photores = photores_read * conversion_factor;
printf("Photoresistor ADC: value = %d, voltage = %f V\n", photores_read, voltage_photores);
}
Das Programm besteht größtenteils aus bereits bekannten Funktionen. Neben der Initialisierung der LEDs und der Funktion PhotoresRun, die sich um den an den Mikrocontroller angeschlossenen Fotowiderstand kümmert, bemerken wir jedoch eine zusätzliche Funktion mit ihrem Prototyp und einem Befehl zur Aktivierung des Alarms. Und es sind diese Konstruktionen, die wir in erster Linie behandeln werden.
Vor der unendlichen while-Schleife sehen wir die Anweisung add_alarm_in_ms. Sie setzt den Alarm, dessen Merkmale in den Argumenten dieser Funktion gefunden wurden. 10000 ist die Anzahl der Millisekunden, nach denen der Alarm ausgelöst werden soll. Das nächste Argument ist der Name der Funktion, die ausgeführt werden soll, wenn der Alarm ausgelöst wird, in diesem Fall ist es einfach Alarm. NULL bedeutet, dass keine zusätzlichen Daten an unsere Funktion übergeben werden, während false angibt, dass der Countdown für den Funktionsaufruf nur aktiviert wird, wenn der Alarm ausgelöst wird. Im Falle eines Arguments true kann etwas wie ein Rückruf erscheinen, was bedeutet, dass der Alarm nach einer Zeit aufgerufen wurde, die größer ist als die in seinem Argument angegebene.
Sobald der Alarm eingestellt ist, geht der Code in eine Endlosschleife über, in der der Fotowiderstand aktiviert wird und alle halbe Sekunde Informationen über Lichtintensität und Spannung an den seriellen Monitor gesendet werden. Nach 10 Sekunden wird jedoch ein Alarm ausgelöst und der Mikrocontroller bedient diesen. Die Alarmfunktion wird ausgelöst, wodurch alle drei LEDs aktiviert werden. Diese Funktion gibt bei korrekter Ausführung Null zurück. Wie bei den Unterbrechungen brauchen Sie sich, um die Argumente dieser Funktion nicht zu kümmern. Sie stammen aus der RPI-Dokumentation und geben die ID des Alarms und so etwas wie einen Indikator auf Benutzerdaten an, aber wir werden uns an anderer Stelle mit Indikatoren beschäftigen.
Sobald der Code kompiliert ist und läuft, kann der serielle Monitor geöffnet werden und die vom Mikrocontroller fließenden Daten können beobachtet werden. Außerdem werden, wie im Video gezeigt, nach 10 Sekunden alle drei LEDs aktiviert. Dies geschieht eigenständig und hat keinen Einfluss auf die Hauptfunktion des Programms.
Ein paar Worte zum Schluss...
In diesem Material haben wir uns die Unterbrechungen des Mikrocontrollers genauer angesehen und auch die Alarmfunktion aktiviert. Darüber hinaus haben wir den Standardzustand der Anschlüsse des RP2040 und das Problem der vibrierenden Kontakte in den Tasten erwähnt. Im nächsten Tutorial werden wir uns mit Timern beschäftigen, und ich werde Ihnen auch mehr über die bereits erwähnten Indikatoren erzählen.
Quellen:
- https://datasheets.raspberrypi.com/rp2040/rp2040-datasheet.pdf
- https://datasheets.raspberrypi.com/picow/pico-w-datasheet.pdf
- https://www.raspberrypi.com/products/rp2040/
- https://www.raspberrypi.com/documentation/microcontrollers/raspberry-pi-pico.html
- https://hackaday.com/2015/12/09/embed-with-elliot-debounce-your-noisy-buttons-part-i/)s
