Über den Beitrag
Arduino ist eine großartige Plattform für Maker, um eigene Elektronikprojekte umzusetzen. Doch manchmal kann das Programmieren der Arduino-Boards schwierig sein – insbesondere für Anfänger. Hier kann ChatGPT helfen: Als intelligenter Chatbot kann er Fragen zur Arduino-Programmierung beantworten, Tipps und Ratschläge geben sowie auf Probleme bei der Projektentwicklung reagieren. In diesem Beitrag werden wir untersuchen, wie ChatGPT und Arduino zusammenarbeiten können, um das Maker-Erlebnis zu verbessern und die Entwicklungszeit zu verkürzen.
ChatGPT
Der obige Absatz wurde von ChatGPT geschrieben. Ich habe lediglich vorgegeben, dass ich einen Beitrag darüber schreiben möchte, inwiefern ChatGPT Arduino Nutzer unterstützen kann und um eine kurze Einleitung gebeten. Für solche Aufgaben ist die künstliche Intelligenz schon sehr ausgereift.
Egal, was ihr von KI haltet, sie wird kommen und unser Leben nachhaltig verändern, so wie es das Internet getan hat. Dieser Beitrag wird aber keine ethisch-moralische Diskussion, sondern wir gehen schlicht der Frage nach: Was kann ChatGPT in Bezug auf die Arduino-Welt heute schon leisten – und was nicht?
„Das neue“ Bing (der Chatbot von Microsoft) und ChatGPT basieren auf GPT. Ich habe beide ausprobiert, aber den Schwerpunkt auf ChatGPT gelegt. Bard, die Konkurrenz von Google, war zum Zeitpunkt der Erstellung dieses Beitrages in Deutschland noch nicht verfügbar – man darf gespannt sein.
Übrigens stammt auch das Beitragsbild von einer künstlichen Intelligenz, nämlich Dall⋅E 2. Lediglich den Schriftzug „Microcontroller“ habe ich noch manuell hineingepixelt. Im Gegensatz zu ChatGPT gibt es Dall•E 2 nur kostenpflichtig (ca. 10 Eurocent pro Bild bzw. Versuch).
Was ist ChatGPT?
Fragen wir ChatGPT: Was ist ChatGPT und wie funktioniert es?
ChatGPT ist ein künstlicher Intelligenz-Chatbot, der auf der GPT (Generative Pre-trained Transformer) Architektur von OpenAI basiert. ChatGPT ist darauf trainiert, menschenähnliche Unterhaltungen auf Englisch und anderen Sprachen zu führen.
Die Funktionsweise von ChatGPT basiert auf maschinellem Lernen und insbesondere auf Deep Learning-Methoden. Es wurde auf großen Textkorpora vortrainiert und verwendet dabei Transformer-Netzwerke, um das Sprachverständnis und die Fähigkeit zu erlernen, menschenähnliche Antworten zu generieren.
Wenn Sie mit ChatGPT sprechen, analysiert es Ihre Eingabe und nutzt sein Verständnis von Sprache und Kontext, um eine Antwort zu generieren. Diese Antworten basieren auf den Mustern und Zusammenhängen, die im Trainingsdatensatz des Modells entdeckt wurden.
Da ChatGPT auf großen Mengen an Daten trainiert wurde, kann es eine Vielzahl von Themen behandeln und sogar spezifische Informationen bereitstellen, wenn es über ausreichendes Wissen auf diesem Gebiet verfügt.
ChatGPT über ChatGPT
Wie kann ich ChatGPT ausprobieren?
Wenn ihr ChatGPT nutzen wollt, dann meldet euch hier an. Ihr müsst eure E-Mail-Adresse und (warum auch immer) eine Telefonnummer angeben. Dann denkt ihr euch noch ein Passwort aus, bestätigt die E-Mail-Adresse und könnt loslegen.
Bei Verwendung der kostenlosen Version kann es laut OpenAI zu Wartezeiten kommen. Ich habe diese Erfahrung allerdings nicht gemacht.
Hinweis: ChatGPT ist u. a. wegen Verstößen gegen Daten- und Jugendschutzgesetze in Italien jüngst gesperrt worden. Sollte man sich also Sorgen machen? Das muss jeder für sich selbst beantworten. ChatGPT weist selbst darauf hin, dass ihr keine sensiblen Daten eingeben sollt. Mein Rat: Überlegt euch bei allen Fragen, ob sie Rückschlüsse auf euch zulassen könnten, von denen ihr nicht wollt, dass sie gezogen werden.
Wie unterscheidet sich Bing?
Aktuell arbeitet ChatGPT mit der GPT-Version 3.5. Bing hingegen verwendet eine angepasste Version von GPT-4. Ich habe hauptsächlich ChatGPT getestet, aber einige Fragen zum Vergleich auch Bing gestellt. Tendenziell waren die Antworten von Bing etwas kürzer, jedoch enthielten sie dafür öfter Links zu weiterführenden Informationen. Ansonsten waren die Ergebnisse im Positiven wie im Negativen ähnlich.
Bing ist bequem über den Edge Browser nutzbar. Klickt einfach auf das runde, blaue Bing-Logo ganz rechts in der Symbolleiste. Alternativ gibt es eine Bing App auf Google Play.
Ein erster Sketch von ChatGPT
Genug der einführenden Worte. Jetzt schauen wir mal, was ChatGPT im Hinblick auf Arduino-Programmierung so drauf hat:
ChatGPT liefert schön formatierten Code mit Kommentaren und zusätzlichen Erklärungen. Mit dem Button „Copy Code“ könnt ihr den Sketch bequem kopieren. Ein vielversprechender Anfang, auch wenn die Erstellung eines Blink-Sketches natürlich nicht wirklich eine KI benötigt.
Das nächste Level: Blink ohne millis()
Um den Schwierigkeitsgrad etwas zu steigern, habe ich ChatGPT gefragt, ob es mir eine Version des Sketches ohne delay()
liefern kann. Hier das Ergebnis:
const int ledPin = 13; // Definiert die LED-Pin-Nummer unsigned long previousMillis = 0; // Variable zur Speicherung der letzten Millisekunden const long interval = 1000; // Blink-Intervall in Millisekunden void setup() { pinMode(ledPin, OUTPUT); // Setzt den LED-Pin als Ausgang } void loop() { unsigned long currentMillis = millis(); // Speichert die aktuellen Millisekunden if (currentMillis - previousMillis >= interval) { // Prüft, ob das Blink-Intervall vergangen ist previousMillis = currentMillis; // Speichert die neuen Millisekunden digitalWrite(ledPin, !digitalRead(ledPin)); // Wechselt den Zustand der LED (an/aus) } }
Weitere Anmerkungen von ChatGPT:
In diesem Programm wird die millis()
-Funktion verwendet, um das Blink-Intervall zu messen. Die Variable previousMillis
speichert den Zeitpunkt des letzten Blinkens, und die Variable interval
gibt das gewünschte Blink-Intervall an. Im loop
-Teil wird überprüft, ob das Blink-Intervall vergangen ist, indem die Differenz zwischen den aktuellen und den vorherigen Millisekunden mit dem interval
verglichen wird. Wenn das Blink-Intervall erreicht wurde, wird der Zustand der LED umgekehrt. Dadurch wird die LED ein- und ausgeschaltet.
Cool! Abgesehen davon, dass ChatGPT die Frequenz halbiert hat, ist alles korrekt. An dieser Stelle kam bei mir schon eine gewisse Euphorie auf.
Top-Level: Timer und PWM
Jetzt legen wir noch einmal eine ordentliche Schippe drauf und fühlen ChatGPT bezüglich Timer und PWM auf den Zahn. Bei Interesse an diesem nicht ganz einfachen Thema könntet ihr meine Beiträge über den Timer0/Timer2 und den Timer1 anschauen.
Nun meine Frage dazu: Kannst du mir ein Arduino Programm schreiben, das ein PWM Signal mit einer Frequenz von 1 Kilohertz und einem Duty Cycle von 20 Prozent erzeugt?
Antwort: Ja, hier ist ein Beispielprogramm, das ein PWM-Signal an Pin 9 mit einer Frequenz von 1 kHz und einem Duty Cycle von 20 % erzeugt:
void setup() { pinMode(9, OUTPUT); // Setzt Pin 9 als Ausgang TCCR1A = _BV(COM1A1) | _BV(WGM11); // Setzt PWM-Modus und invertierten Ausgang TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // Setzt Fast-PWM-Modus und keine Vorteilung OCR1A = 156; // Setzt Duty Cycle auf 20% (156 von 255) } void loop() { // Kein Code hier benötigt, da die PWM-Signalgenerierung im Setup erfolgt }
Weitere Anmerkungen von ChatGPT:
In diesem Programm wird die pinMode-Funktion verwendet, um den digitalen Pin 9 als Ausgang festzulegen. Die Register TCCR1A und TCCR1B werden konfiguriert, um den Timer1 in den Fast-PWM-Modus zu setzen und den Ausgang zu invertieren, damit das PWM-Signal mit einem Duty Cycle von 20% erzeugt wird. Die OCR1A-Register werden auf 156 gesetzt, was einem Duty Cycle von 20% (156 von 255) entspricht. Da die PWM-Signalgenerierung im Setup erfolgt, wird im loop-Teil kein Code benötigt.
Dieser Sketch funktioniert nicht! Richtig ist daran:
- Einstellung des Fast PWM Modus (14).
- Kein Prescaler.
- Ausgabe an Pin 9 (wenn eine käme!).
Falsch ist daran:
- Die Berechnung der Frequenz und des Duty Cycle.
Und dass 156 von 255 dabei einen Duty Cycle von 20 % ergäbe, ist schon ziemlich grober Blödsinn.
Hier erkennen wir ein Problem von ChatGPT. Es „haut“ seine Aussagen wie unumstößliche Tatsachen heraus, frei nach dem Motto: Frisch behauptet, ist halb bewiesen. Vertraut der KI also nicht blind!
Richtig wäre übrigens:
void setup() { pinMode(9, OUTPUT); TCCR1A = _BV(COM1A1) | _BV(WGM11); TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); ICR1 = 15999; OCR1A = 3199; } void loop() { // Kein Code hier benötigt, da die PWM-Signalgenerierung im Setup erfolgt }
Es fehlt also nur ein kleiner Teil, aber ein sehr entscheidender.
Timer und PWM – etwas einfacher
Na gut, dann erleichtern wir es ChatGPT etwas und schauen, ob es uns vielleicht doch noch bei den Timern und PWM helfen kann. Dazu habe ich die folgende Frage gestellt:
Der folgende Code produziert ein PWM Signal mit einem Duty Cycle von 20 % und einer Frequenz von 1 kHz. Weißt du, wie ich ihn ändern muss, um den Duty Cycle auf 30 % zu erhöhen und die Frequenz auf 8 kHz zu erhöhen? <hier habe ich den Code von correct_timer_pwm.ino einkopiert>.
Antwort ChatGPT: Ja, ich kann Ihnen helfen, den Code entsprechend zu ändern. Hier ist der korrigierte Code mit einem DutyCycle von 30 % und einer Frequenz von 8 kHz:
void setup(){ // Clear OC1A on Compare Match / Set OC1A at Bottom; Wave Form Generator: Fast PWM 14, Top = ICR1 TCCR1A = (1<<COM1A1) + (1<<WGM11); TCCR1B = (1<<WGM13) + (1<<WGM12) + (1<<CS10); // prescaler = none; ICR1 = 1999; // 8 kHz = 16 MHz / (2 * 1 * 2000) OCR1A = 599; // 30% von 1999 DDRB |= (1<<PB1); } void loop() { // do something else }
Dazu gab ChatGPT noch die folgende Erklärung:
Die Änderungen, die vorgenommen wurden, sind:
- Der Wert von ICR1 wurde auf 1999 gesetzt, um eine Frequenz von 8 kHz zu erzeugen. Dieser Wert wurde berechnet, indem die gewünschte Frequenz (8 kHz) durch die Taktfrequenz des Arduinos (16 MHz) dividiert wurde und anschließend von diesem Wert subtrahiert wurde. Das Ergebnis (1999) wurde dann auf ICR1 gesetzt.
- Der Wert von OCR1A wurde auf 599 gesetzt, um einen Duty Cycle von 30 % zu erzeugen. Dieser Wert wurde berechnet, indem der maximale Zählerwert (1999) mit dem gewünschten Duty Cycle (0,3) multipliziert wurde. Das Ergebnis (599,7) wurde dann auf den nächsten ganzzahligen Wert gerundet und auf OCR1A gesetzt.
Mit diesen Änderungen sollte der Sketch das gewünschte PWM-Signal generieren.
Der Sketch ist korrekt, die zusätzlichen Erklärungen hingegen nicht ganz:
- Nicht die gewünschte Frequenz wird durch die Taktfrequenz geteilt, sondern umgekehrt. Und subtrahiert wird lediglich die 1.
- 599 nicht der nächste ganzzahlige Wert von 599.7. Ein „Schönheitsfehler“.
Dieses Beispiel zeigt, dass es sich lohnen kann, Fragen noch einmal zu präzisieren oder umzuformulieren.
Timer und PWM – ChatGPT lernt!
Ein paar Tage später habe ich noch einmal die originale Frage (PWM-Signal, 1 kHz, 20 % Duty Cycle) in einen neuen Chat eingegeben. Diesmal bekam ich:
int outputPin = 9; // PWM-Ausgangspin int dutyCycle = 20; // Duty Cycle in Prozent void setup() { pinMode(outputPin, OUTPUT); // Setze den Ausgangspin auf "Output" TCCR1A = _BV(COM1A1) | _BV(WGM11); // Setze PWM-Modus TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // Setze Prescaler auf 1 und Phase-correct PWM ICR1 = 1999; // Setze den Top-Wert auf 1999 (1kHz) } void loop() { int duty = map(dutyCycle, 0, 100, 0, ICR1); // Berechne den Duty-Cycle-Wert OCR1A = duty; // Setze den Duty-Cycle-Wert }
Die PWM-Frequenz stimmt nicht (8 kHz bei 16 MHz Systemfrequenz), aber der Duty Cycle ist korrekt. Den Wert von OCR1A in loop()
zuzuweisen macht nur Sinn, wenn man ihn während der Laufzeit ändern möchte. Aber immerhin, die Antwort ist schon erheblich besser als die, die ich ursprünglich bekommen hatte.
Fehler finden
ChatGPT ist auch in der Lage, Fehler in Programmcode zu finden. Zumindest funktioniert das bei Syntaxfehlern, also bei falscher Schreibweise, relativ gut. Bei semantischen Fehlern (Code compiliert, aber es kommt nicht heraus, was ihr wolltet) wird es schwieriger, denn ChatGPT kann natürlich nur raten, was ihr eigentlich im Sinne hattet.
Um ChatGPTzu testen, habe ich einen Sketch aus den Arduino Beispielen genommen und vier Fehler eingebaut:
const int sensorMin = 0; const int sensorMax = 600; void setup() { // initialize serial communication: Serial.begin(9700); // 1 } void loop() { int sensoReading = analogRead(A0); // 2 imt range = map(sensorReading, sensorMin, sensorMax, 0, 3); // 3 switch (range) { case 0: Serial.println("dark"); break; case 1: Serial.println("dim"); break; case 2: Serial.println("medium"); break; case 4: // 4 Serial.println("bright"); break; } delay(1000); }
Dann habe ich ChatGPT gefragt, ob es mir bei der Fehlersuche helfen kann. Die Antwort lautete:
Ja, ich kann versuchen, Ihnen bei den Fehlern in Ihrem Arduino-Code zu helfen.
Hier sind einige Probleme, die ich in Ihrem Code gefunden habe:
- Der Serial.begin-Befehl sollte 9600 statt 9700 sein, da dies die Standard-Baudrate für Arduino ist.
- „sensoReading“ wird falsch geschrieben. Es sollte „sensorReading“ sein.
- Das „int“ in „int range“ wird falsch geschrieben. Es sollte „int“ statt „imt“ sein.
- Der Fall „4“ sollte „3“ sein, um mit der Anzahl der Fälle im switch-Statement übereinzustimmen.
Nicht schlecht! Auf Fehler 2 und 3 würde man durch Abbruch der Kompilierung stoßen. Fehler 1 und 4 würden jedoch nicht „angemeckert“ werden, sodass ChatGPT hier eine echte Hilfe gewesen wäre.
Noch ein Fehler: Teilen durch null
Im folgenden Sketch teilen wir durch null:
void setup() { Serial.begin(9600); const int a = 2; const int b = 4; int c = 42/(2*a-b); Serial.print("c = "); Serial.println(c); } void loop() {}
Ich habe ChatGPT gebeten, den Fehler zu finden. Antwort ChatGPT:
Das Programm hat keinen offensichtlichen Fehler, aber es kann zu einem Problem führen, wenn der Wert von 2*a-b Null ist, da es dann zu einer Division durch null kommt und das Programm abstürzt. Da a und b jedoch als Konstanten deklariert sind und feste Werte haben, sollte dies kein Problem sein.
Wir sehen: Grundsätzlich wurde das Problem „Division durch null“ identifiziert, allerdings hat ChatGPT nicht erkannt, dass „2*a – b“ auf jeden Fall Null ist. Der Compiler der Arduino IDE ist schlauer und gibt eine entsprechende Warnung aus.
Verwendung von Modulen
Jetzt prüfen wir an zwei Beispielen, ob uns ChatGPT auch bei der Programmierung komplexerer, externer Bauteile helfen kann. Dafür habe ich zwei recht gängige Sensormodule ausgewählt, nämlich den Ultraschall-Abstandssensor HC-SR04 und das 9-Achsensensor-Modul MPU9250 (Beschleunigung, Gyroskop, Magnetometer).
Beispiel 1: HC-SR04
Meine Frage: Kannst du mir ein Arduino Programm schreiben, dass den Abstand mit einem HC-SR04 einmal pro Sekunde misst? Wenn ein Abstand von 1,5 Metern unterschritten wird, soll eine LED an Pin 7 eine halbe Sekunde leuchten.
Und hier der Sketch von ChatGPT:
const int trigPin = 2; // Definiert die Trig-Pin-Nummer const int echoPin = 3; // Definiert die Echo-Pin-Nummer const int ledPin = 7; // Definiert die LED-Pin-Nummer void setup() { pinMode(trigPin, OUTPUT); // Setzt den Trig-Pin als Ausgang pinMode(echoPin, INPUT); // Setzt den Echo-Pin als Eingang pinMode(ledPin, OUTPUT); // Setzt den LED-Pin als Ausgang Serial.begin(9600); // Startet die serielle Kommunikation mit 9600 Baud } void loop() { // Sendet den Ultraschallimpuls digitalWrite(trigPin, LOW); delayMicroseconds(2); digitalWrite(trigPin, HIGH); delayMicroseconds(10); digitalWrite(trigPin, LOW); // Liest die Zeit des Echo-Signals long duration = pulseIn(echoPin, HIGH); // Berechnet die Entfernung basierend auf der Zeit des Echo-Signals float distance = duration * 0.034 / 2; // Überprüft, ob der Abstand unter 1,5 Metern liegt if (distance < 1.5) { digitalWrite(ledPin, HIGH); // Schaltet die LED an delay(500); // Wartet eine halbe Sekunde digitalWrite(ledPin, LOW); // Schaltet die LED aus } // Gibt den Abstand über die serielle Schnittstelle aus Serial.print("Abstand: "); Serial.print(distance); Serial.println(" m"); // Wartet eine Sekunde delay(1000); }
Nicht schlecht! Der einzige Fehler ist, dass „distance“ nach dieser Berechnung der Abstand in Zentimetern ist und nicht, wie angegeben, in Metern. Nachdem ich ChatGPT auf den Fehler hingewiesen und um eine korrigierte Version gebeten habe, bekam ich einen korrekten Sketch.
Bing sagte mir, es sein nicht in der Lage, einen Sketch für den HC-SR04 zu erstellen. Wenigstens war das eine ehrliche Antwort!
Dann habe ich ChatGPT noch gefragt, ob es mir eine Schaltung zum Sketch liefern könnte. Wie gewohnt kam einleitend ein selbstbewusstes “Ja, natürlich”. Hier das Ergebnis:
+5V | | R1 | | Trig --------------/\/\/\/\------------------- Arduino Pin 9 | | Echo --------------/\/\/\/\------------------- Arduino Pin 10 | | | R2 | | | | | LED | | | | --------------------- Arduino Pin 7 | | GND R1, R2 = ~200 Ohm
Hmmm, na ja, sagen wir, ich weiß ungefähr, was gemeint ist. Schaltungen sind also kein ausgereiftes Feature.
Beispiel 2: MPU9250
Nächster Versuch, nächste Frage: Kannst du mir ein Programm schreiben, dass die Beschleunigung mithilfe eines MPU9250 ermittelt?
Hier die Antwort von ChatGPT:
#include <Wire.h> #include <MPU9250.h> MPU9250 IMU; // Erstellt eine Instanz der MPU9250-Klasse void setup() { Serial.begin(9600); // Startet die serielle Kommunikation mit 9600 Baud Wire.begin(); // Startet die I2C-Kommunikation IMU.setup(); // Initialisiert den MPU9250-Sensor } void loop() { // Liest die Beschleunigungswerte aus dem MPU9250-Sensor IMU.updateAccel(); float ax = IMU.ax; float ay = IMU.ay; float az = IMU.az; // Gibt die Beschleunigungswerte über die serielle Schnittstelle aus Serial.print("Beschleunigung: "); Serial.print(ax); Serial.print(" m/s^2, "); Serial.print(ay); Serial.print(" m/s^2, "); Serial.print(az); Serial.println(" m/s^2"); // Wartet eine kurze Zeit delay(100); }
Das ist nicht wirklich nützlich. Der Sketch ist eher eine Art generischer Code. Ich habe dann noch ein paar Nachfragen gestellt, z. B. welche MPU9250 Bibliothek gemeint ist. Dazu bekam ich zwar eine konkrete Antwort, aber die Bibliothek passte nicht zum Code. Auch alle weiteren Versuche, ChatGPT durch Hilfestellungen ein funktionierendes Programm zu entlocken, scheiterten.
SPI Schnittstellen ESP32
Themenwechsel. Frage: Kannst du mir erklären, wie ich beide SPI Schnittstellen eines ESP32 nutze?
Neben einigen allgemeinen Erklärungen antwortete ChatGPT mit einem Beispielsketch:
#include <SPI.h> // define SPI pins for first interface #define SCK1 14 #define MISO1 12 #define MOSI1 13 #define SS1 15 // define SPI pins for second interface #define SCK2 18 #define MISO2 19 #define MOSI2 23 #define SS2 5 void setup() { Serial.begin(9600); // initialize the first SPI interface SPI.begin(SCK1, MISO1, MOSI1, SS1); SPI.setClockDivider(SPI_CLOCK_DIV2); // initialize the second SPI interface SPI.begin(SCK2, MISO2, MOSI2, SS2); SPI.setClockDivider(SPI_CLOCK_DIV2); } void loop() { // use the first SPI interface digitalWrite(SS1, LOW); SPI.transfer(0x55); digitalWrite(SS1, HIGH); // use the second SPI interface digitalWrite(SS2, LOW); SPI.transfer(0xAA); digitalWrite(SS2, HIGH); delay(1000); }
Es ist zwar das eine oder andere Wahre dran, aber auch viel Falsches. So funktioniert es zumindest nicht. Auf die Fehler einzugehen, würde hier zu weit führen. Wenn ihr euch für das Thema interessiert, dann schaut in meinen Beitrag über den ESP32 oder in diesen Beispielsketch auf GitHub.
Allgemeinere Fragen
Bei der Realisierung von Projekten können auch Fragen auftreten, bei denen es nicht um Programmierung geht.
MOSFET-Empfehlung
Frage: Kannst du mir MOSFETs empfehlen, die ich direkt mit einem Mikrocontroller schalten kann?
Antwort:
Ja, es gibt viele MOSFETs, die mit einem Mikrocontroller gesteuert werden können. Hier sind einige MOSFETs, die du in Betracht ziehen kannst:
- IRFZ44N – Dies ist ein beliebter N-Kanal-MOSFET mit einer Durchlassspannung von 55V und einem maximalen Drain-Source-Strom von 49A. Es eignet sich für eine Vielzahl von Anwendungen, einschließlich Motorsteuerung und Leistungsregelung.
- IRLZ44N – Dies ist ein ähnlicher MOSFET wie der IRFZ44N, jedoch mit einem niedrigeren Widerstand und einer geringeren Gate-Spannung. Es hat eine Durchlassspannung von 55V und einen maximalen Drain-Source-Strom von 47A.
- BSS138 – Dies ist ein kleiner N-Kanal-MOSFET, der für Anwendungen mit niedriger Leistung und Spannung geeignet ist. Es hat eine Durchlassspannung von 50V und einen maximalen Drain-Source-Strom von 220mA.
- FQP30N06L – Dies ist ein N-Kanal-MOSFET mit einer Durchlassspannung von 60V und einem maximalen Drain-Source-Strom von 32A. Es hat auch einen niedrigen Einschaltwiderstand und ist für Anwendungen wie Schaltregler und Motorsteuerung geeignet.
- IRF3205 – Dies ist ein N-Kanal-MOSFET mit einer Durchlassspannung von 55V und einem maximalen Drain-Source-Strom von 110A. Es hat auch einen niedrigen Einschaltwiderstand und ist für Anwendungen mit hoher Leistung wie Schaltregler und Leistungswandler geeignet.
Bevor du einen MOSFET auswählst, solltest du sicherstellen, dass er die erforderlichen Spezifikationen für deine Anwendung erfüllt und dass er auch mit der Gate-Spannung deines Mikrocontrollers kompatibel ist.
Die Antwort ist nicht schlecht, könnte aber noch besser sein. Die Empfehlungen 2, 3 und 4 sind einwandfrei. Hingegen sind die Empfehlungen 1 (IRFZ44N) und 5 (IRF3205) sind nur bedingt geeignet, da bei beiden das Limit für die Gate-Spannung mit 2-4 Volt recht hoch ist. Für einen 5 Volt Mikrocontroller geht das, mit einem 3.3 Volt Modell nur vielleicht. Da sind die Empfehlungen IRLZ44N (1-2 Volt), BSS138 (0.8 Volt) und IRF3205 (1-2.5 V) besser. Zugegeben: Zum Schluss weist ChatGPT auf die Gate-Spannungsproblematik hin. Aber genau deswegen hatte ich ChatGPT gefragt, welche MOSFETs direkt mit einem Mikrocontroller ansteuerbar sind.
Auf Nachfrage, was ich bei einem Mikrocontroller mit 3.3 V Spannung nehmen sollte, bekam ich die Empfehlungen IRLZ44N, BSS138 und IRF3708 – alle gut! Man muss seine Frage also möglichst exakt und detailliert stellen. Auf unscharfe Fragen gibt es unscharfe Antworten.
Verschiedenes
Ich habe mir noch weitere Fragen ausgedacht:
- Wie funktioniert die Datenübertragung per SPI?
- Wie Strom liefert ein Arduino?
- Was unterscheidet einen LGT8F328P vom ATmega328P?
- Wie installiere ich eine Arduino Bibliothek?
- Wo finde ich die API Dokumentation für den ESP32?
- Wie kann ich ein elektronisches Signal (High/Low) invertieren?
Es wäre etwas ermüdend durch alle Antworten im Einzelnen gehen. Zusammenfassung: Die Antworten waren alle korrekt! Manchmal waren sie vielleicht etwas oberflächlich, aber in diesen Fällen halfen Nachfragen. Viele Pluspunkte für ChatGPT in diesem Teil.
Fazit
Mein Urteil über die Fähigkeiten von ChatGPT (und Bing) im Arduino Bereich fällt gemischt aus:
- ChatGPT kann eine Hilfe beim Programmieren sein, aber die Ergebnisse sind kritisch zu hinterfragen. Ein komplett funktionsfähiges und korrektes Programm zu erhalten, ist Glückssache. Zumindest erhaltet ihr aber etwas, auf dem ihr mit recht hoher Wahrscheinlichkeit aufbauen könnt.
- Zu allgemeinen Fragen rund um Arduino bekommt ihr von ChatGPT kompakte Antworten. Im Vergleich dazu müsst ihr bei Google-Suchen die Informationen aus verschiedenen Treffern zusammentragen. In dieser Hinsicht ist ChatGPT äußerst komfortabel. Allerdings geht Vielfalt verloren, da ChatGPT für euch eine Auswahl trifft bzw. eine Art „Durchschnittsantwort“ gibt.
- Insbesondere Einsteiger können von ChatGPT profitieren. Das ist allerdings ein zweischneidiges Schwert, denn gerade diese Gruppe wird fehlerhafte Antworten schwerer erkennen. Außerdem ist der Lerneffekt geringer.
- ChatGPT behauptet, es könne alles. Ein bisschen weniger Selbstbewusstsein bzw. Selbstüberschätzung wäre angemessener.
- Im Gegensatz zu echter Intelligenz stellt ChatGPT keine Rückfragen. Es versucht, das Beste aus einer Frage zu machen, auch wenn sie ungenau ist. Dabei vermittelt es das Gefühl, die Antwort sei allgemeingültig. Ein Mensch würde nachfragen oder seine Antwort mit „Es kommt darauf an, ob …“ beginnen.
Aber mal abgesehen von allen Fehlern, Einschränkungen und Lücken: Ich bin durchaus beeindruckt, was ChatGPT und Bing schon jetzt zu leisten vermögen. Und ich bin davon überzeugt, dass wir schon binnen kurzem erhebliche Fortschritte sehen werden. Es wird sehr spannend, die weitere Entwicklung zu verfolgen.
Anhang: zurück zu den Kernkompetenzen von ChatGPT
Zum Schluss noch ein bisschen Spaß und zu Dingen, in denen ChatGPT so richtig gut ist. Ich habe ChatGPT darum gebeten, ein lustiges Gedicht über den Arduino in englischer Sprache zu schreiben. Hier das Ergebnis:
Nicht ganz perfekt, aber fast. Ich könnte das nicht – und schon gar nicht in wenigen Sekunden!
Moin Wolfgang,
ich versuche eine Stoppuhr über Arduino zu programmieren. Ich kenne mich nicht allzu gut mit dem Programmieren aus, weswegen ich Chatgpt gefragt habe. Nur hilft mir das nicht wirklich weiter, da ich durch seine Antworten nicht wirklich daraus schlau werde wie ich das miteinander Verbinde.
Zur Info: Ich will bis zu maximal einer Stunde messen. Zum Anzeigen benutze ich 7Segment-Anzeigen, diese sollen dann zwei Stellen für Minuten, zwei für Sekunden und zwei für Zehntelsekunden anzeigen. Zum bedienen hab ich mich für einen einzelnen Taster entschieden: START-> STOP-> AUF NULL STELLEN.
Jetzt habe ich zuhause noch ein 4-Digit Display und dachte mir, dass es mit dem einfacher ist als mit sechs einzelnen 7Segmentanzeigen. Dann habe ich Chatgpt gefragt, der hat mir auch einen Code gegeben und der funktioniert, aber nur nur für die 4-Digit Display. Also fehlen noch 2 Stellen, welche ich dann mit zwei einzelnen 7Segment-Anzeigen (gleiche Kathode) hinzufügen würde. Nur da scheitert das Ganze. Ich werde nicht schlau daraus was die KI mir ausspuckt und bräuchte Hilfe.
Im Voraus schonmal vielen Dank.
Hallo Julian,
es gibt verschiedene 7-Segmentanzeigen, die ohne und die mit Controller. Bei denen ohne Controller kann man sich die Mühe machen, jedes einzelne Segment anzusteuern, das ist aber keine spaßige Aufgabe. Deswegen nimmt man normalerweise Controller wie den MAX7219 bzw. MAX7221. Damit lassen sich bis zu acht 7-Segmentanzeigen ansteuern. Aber das ist auch ziemlich viel Verkabelung. Ich würde dir deshalb sehr empfehlen, lieber 7-Segmentdisplays mit integriertem Controller zu verwenden. Modelle mit dem MAX7219/MAX7221 oder TM1637 sind gängige Modelle. Schaue z.B. mal bei Amazon nach „6 Ziffern 7-Segment“.
Und hier eine passende Bibliothek für TM1637 basierte Modelle:
https://github.com/jasonacox/TM1637TinyDisplay
VG, Wolfgang
Hallo Wolfgang,
vielen dank schonmal für den Tipp. Ich habe mir jetzt ein 6-Digit LED Display-TM1637 bestellt. Leider sind in meinem Code mehrere Fehler, aber ich weiß nicht wie ich sie verbessere. Zum Beispiel ist die Reihenfolge der Zehntelsekunden, Sekunden und Minuten nicht richtig, die Zehntelsekunden erkennt man nicht und mein Taster um die Stoppuhr zu starten, stoppen und zurücksetzen stimmt auch nicht.
Wenn sie mal Zeit hätten drüber zu schauen und mir helfen könnten, wäre ich Ihnen sehr dankbar.
Der Code:
#include
#define CLK_PIN 2
#define DIO_PIN 3
#define START_STOP_BUTTON_PIN 4
TM1637Display display(CLK_PIN, DIO_PIN);
unsigned long startTime = 0;
unsigned long elapsedTime = 0;
bool isRunning = false;
int buttonState = HIGH;
int lastButtonState = HIGH;
unsigned long lastDebounceTime = 0;
unsigned long debounceDelay = 50;
void setup() {
display.setBrightness(0x0f); // Helligkeit auf Maximum einstellen
pinMode(START_STOP_BUTTON_PIN, INPUT_PULLUP); // Taster-Pin als Eingang mit Pull-up-Widerstand konfigurieren
display.showNumberDecEx(0, 0b01000000, true, 2, 0); // 00:00:00 auf dem Display anzeigen
}
void loop() {
int reading = digitalRead(START_STOP_BUTTON_PIN);
// Entprellen des Tasters
if (reading != lastButtonState) {
lastDebounceTime = millis();
}
if ((millis() – lastDebounceTime) > debounceDelay) {
if (reading != buttonState) {
buttonState = reading;
// Taster gedrückt
if (buttonState == LOW) {
if (!isRunning) {
// Startzeit setzen und Stoppuhr starten
startTime = millis() – elapsedTime;
isRunning = true;
} else {
// Stoppzeit setzen und Stoppuhr stoppen
elapsedTime = millis() – startTime;
isRunning = false;
}
}
}
}
lastButtonState = reading;
// Zeit anzeigen (laufende Zeit oder Zeit beim Stopp)
if (isRunning) {
displayElapsedTime(millis() – startTime);
} else {
displayElapsedTime(elapsedTime);
}
}
void displayElapsedTime(unsigned long time) {
// Minuten, Sekunden und Zehntelsekunden berechnen
unsigned int minutes = (time / 60000) % 60;
unsigned int seconds = (time / 1000) % 60;
unsigned int tenths = (time / 10) % 100;
// Anzeige aktualisieren
display.showNumberDecEx(tenths, 0b01000000, true, 2, 0); // Zehntelsekunden anzeigen
display.showNumberDecEx(seconds, 0b01000000, true, 2, 2); // Sekunden anzeigen
display.showNumberDecEx(minutes, 0b01000000, true, 2, 4); // Minuten anzeigen
}
Hi Julian,
im Prinzip funktioniert dein Sketch. Das Problem ist die ungebremste Ausgabe auf dem Display. Das kommt da nicht mit. Ich sende dir eine E-Mail mit weiteren Erklärungen, weil das Kommentarfeld dafür nicht so gut geeignet ist.
VG, Wolfgang
Hallo Julian,
ich verfolge das hier und verstehe genau warum Du deine Frage hier stellst wo ein Fragesteller mit würde behandelt wird, was in manchen Foren nicht der Fall ist.
Ich benutze ChatGPT und auch GihubCopilot extrem viel für fleissaufgaben beim Programmieren. Dabei ist es so, dass die KI weil sie ja ein Sprachmodell ist eigentlich nur pseudocode auswirft, der aufgrund der hohen Wahrscheinlichkeit mit echtem Code übereinstimmen quasi „versehentlich“ lauffähig ist. Es ist aber leider nicht so, dass die KI wirklich einen Debugger darstellt oder eine Testumgebung die den Code tatsächlich prüft. Es sind wirklich nur „schöne Worte“. Es ist daher am Anfang wichtig, sich mit jedem einzelnen Teil Deines Programms so lange zu beschäftigen, bis Du es besser verstehst als die KI. Dann stellst Du über der KI und kannst ihr Aufgaben geben. Die KI produziert den Code viel schneller als Du. Du musst aber drüberschauen und Fehler erkennen. Dann kannst Du es entweder korrigieren oder die KI auf den Fehler hinweisen. Wenn die KI aber „besser informiert“ ist als Du, dann wird sie Dich immer wieder enttäuschen weil Sie gemäß Murphys Law für jeden korrigierten Fehler einen neuen einbaut. Das ganze wird schlimmer, je umfangreicher der Code ist. Ab einer bestimmten Komplexität fängt die KI dann sogar an Variablennamen zu vergessen oder bereits korrigierte Fehler neu einzubauen. Ich würde Dir empfehlen Deinen Code in möglichst kleine Funktionen zu stückeln. Die KI nur an einer Funktion arbeiten zu lassen. Und dann sofort die KI zu bitten Dir Zeile für Zeile erklären zu lassen was passiert. So lernst Du mehr, erkennst logikfehler besser und die KI stößt nicht so oft an ihre Ressourcengrenze was zu Amnesie und Fehlern führt. KI kann eine riesige Hilfe sein, aber nur dann wenn Du es theoretisch auch selber kannst. Dann macht sie Dich schneller, aber nicht unbedingt schlauer.
Nichts für ungut, viel Erfolg!!!
Moin,
Was mich interessiert, ist, ob chatGPT, durch eigene Rückkopplung von seinen eigenen Antworten, die übers Netz wahrscheinlich wieder zu ihn zurückfinden werden, mit der Zeit graduell immer unzuverlässiger oder gar in gewisser Hinsicht schizophren werden könnte. Ich kann mir nicht helfen, aber die Möglichkeit von unkontrollierten KI-Rückkopplungen und deren wundersame Auswirkungen, fasziniert mich irgendwie. Ich habe bis jetzt der Versuchung widerstanden, selber mitzumachen. Es ist aber interessant die Erfahrungen anderer zu verfolgen. Ein Kumpel von mir lässt sich nun viel Arduino Code von ihm schreiben. Ich mache es doch lieber selber durch eigene Handarbeit. Das stärkt die Muskulatur des Gehirns:-) es heisst doch so schön: „wer rastet, der rostet.“
VG,
Gerhard
Hi Gerhard, interessanter Aspekt: ChatGPT setzt etwas Falsches in die Welt, alle glauben es, verbreiten es und ChatGPT wird sich immer sicherer, dass die Falschaussage stimmt. Andererseits wird es auch viele Leute geben, denen der Fehler auffällt und die ChatGPT entsprechend darauf hinweisen. Dafür gibt es den Daumen hoch / Daumen runter zur Bewertung der Antwort und ein Kommentarfeld. Ich denke, insgesamt wird ChatGPT eher immer zuverlässiger werden. Aber bei Abfragen von Fakten sollte man generell vorsichtig sein. Da ist mir das neue Bing etwas lieber. Es gibt eine Zusammenfassung, aber dann auch Links dazu. Da kann man dann einfacher überprüfen, ob die Aussage zuverlässig ist. Und ich gebe dir recht, man sollte sich möglichst viel selbst erarbeiten, dann lernt man viel mehr. Aber sich ein bisschen Schreibarbeit abnehmen lassen, ist denke ich OK. VG, Wolfgang
Super Beitrag, danke !
Da ich „noch“ ESP32 / Python Anfänger bin – nicht aber im Bereich Prozessoren – habe meinen ersten Z80
im Jahre 1979 programmiert (Assembler)…
kam dein Artikel gerade richtig. 🙂
Ich suchte nämlich nach einer Lösung um die RTC Zeit des ESP32 auf zwei 8 Bit ports (Stunden/Minuten)
im BCD Format zu übertragen um diese dann mittels BCD Decodern an Nixie-Röhren anzuzeigen.
Habe lange rumgegoogled und keine schlauen Infos gefunden.
ChatGPT hat mir sofort brauchbare Antworten und super Code Beispiele geliefert. ! 🙂
Werde dieses Tool natürlich weiterhin nutzen.
Beste Grüsse,
Thomas
Danke für dein Feedback!
Vielen Dank für den tieferen Einstieg und die Beispiele!
Habe ChatGTP dafür auch schon vor einiger Zeit damit genutzt, bin aber nicht so tief eingestiegen. Wie schon gesagt wurde, muß man im Grunde das selbe selbst programmieren können, um das Ergebnis beurteilen zu können. Bei der Vorgabe der Bedingungen versteht ChatGPT nicht immer alles so, wie man es meint, aber mit ein paar Durchgängen kommt dann schon ein brauchbares Ergebnis raus.
Das ganze kann man zumindest nutzen, um sich Code-Schnipsel ohne lästige Tipperei erstellen zu lassen und es dann zu einem Ganzen zusammenzufügen.
Probeweise habe ich habe ich dann auch mal den Arduino-Code nach C++ und dann nach Python übersetzen lassen und auch das geht prima.
Grüße
Hartmut
Vielen Dank für den Kommentar- das mit dem Übersetzen in Python werde ich auch mal ausprobieren.
jep, wobei interessant ist, dass ChatGTP sich zunächst geweigert hat, den direkten Weg von Arduino-Code zu Python zu machen. Sagt sinngemäß, dass das zu aufwendig sei und viel weiteres blabla. Vielleicht hatte ich auch meine Frage falsch formuliert.
Daher der Umweg über die Übersetung nach C++ und dann nach Übersetzung in Python angefragt. Das hat er dann brav gemacht, wobei ich den Code für beide Übersetzungen nicht geprüft habe.
Hallo Wolfgang,
bei Arduino kommt, wie viele hier schon berichtet, was brauchbares raus. (es sollten aber schon Kenntnisse da sein um das nicht so hinzunehmen…..:-)….) Bei Free RTOS und ESP32 funktioniert aber fast nichts!! Trotzdem ein feines Spielzeug! Ich nutze es hauptsächlich wenn ich Compilerfehler bekomme. Die werden gut erklärt!
Gruß Andre
bisher habe ich das noch nicht ausprobiert. Das Thema ist sicher top. Allerdings habe ich das Gefühl das derzeit viel Hype um das Thema aufgebauscht wird. Gerade auf der derzeitigen Hannovermesse scheint es kein anderes Thema zu geben. Diese Messe war früher, in meinen Arbeitsjahren, Pflichtprogramm hat aber in den letzten Jahren ziemlich an Aktualität eingebüßt.
Wir sollten uns aber fragen: wenn das alles so kommt wie vorausgesehen? Wo sollen die ganzen Menschen hin oder was sollen alle diese Menschen machen wenn sie wegrationalisiert werden! Ohne Arbeit gibts kein Geld und ohne Geld gibts nichts zu Essen, Trinken etc.
Die andere Frage ist: was bringt uns das? Verbessert das unsere Umweltbilanz? oder haben wir vielleicht mehr Frieden? oder …. ?
Ich bin kein Umweltaktivist, falls diese Frage jetzt im Raum steht. Das ist meine persönliche Meinung.
Ja, im Moment kann man dem Thema kaum entgehen. Im Beitrag habe ich das Für und Wider bewusst nicht diskutiert. Aber eins ist sicher: Die Entwicklung lässt sich vielleicht in gewissem Maße beeinflussen, aber sicherlich nicht aufhalten. Aber ich bin nicht ganz so pessimistisch bzgl. der Arbeitsplätze: Auch bei der fortschreitenden Automatisierung von Produktionsabläufen wurde Massenarbeitslosigkeit vorausgesagt. Und nun haben wir in Deutschland fast Vollbeschäftigung. Ich denke, auch hier wird es dazu führen, dass einige Berufe oder Tätigkeiten verschwinden werden, aber andere dafür hinzukommen. Tragisch nur immer für diejenigen, die nicht die Möglichkeit haben, sich schnell genug anzupassen und die benötigten Fähigkeiten zu erlernen. Mehr Bedenken habe ich im Bereich Fehlinformationen (Trolle, Deep Fakes, usw.). Für die Umweltbilanz ist das Ganze sicherlich auch alles andere als gut. Wäre das Internet ein Land, stünde es mit 2.8 % des CO2-Ausstoßes an Platz 6 der unrühmlichen Weltrangliste. Das wird mit der KI sicherlich nicht weniger. Aber auch hier sollte man die Dinge im Verhältnis sehen. Filme zu streamen ist sicherlich immer noch schädlicher als gelegentlich ChatGPT zu befragen.
In der Tat kann ChatGPT bei der Entwicklung helfen, ist aber mit Vorsicht zu genießen. Man kann den Eindruck gewinnen, dass hier sämtliche Stackflow o.ä. Communities „durchgegraben“ werden, um eine passende Antwort zu finden. Sehr oft macht der Code keinen Sinn, ist schlicht falsch oder am Thema der Problemstellung vorbei.
Danke für’s Feedback. Ich teile die Meinung voll, und hoffe, dass die Vorbehalte auch im Artikel klar genug herausgekommen sind.
ich nutze ChatGPT viel um mir lässtige Coding Fleißarbeit abnehmen zu lassen. Programgrumdgerüste wie switch case,… werden wunderbar erstellt. Denken muss man aber immer noch selber.
Denken muss man aber immer noch selber. Das ist wohl wahr!
Das macht Lust aufs Ausprobieren. Gerade bei manchmal recht unübersichtlichen Registermanipulationen bei denen sonst zig mal zwischen Datasheet und Sketch hin und her schaue ist das oben gezeigte echt hilfreich.
Da meine Bastelei häufig die Komponenten Schaltung, Programmierung und Gehäusedesign beinhalten werde ich gleich mal beim letzten Thema einhaken und schauen wie gut ChatGTP mit openSCAD umgehen kann.