Integration von ChatGPT mit Arduino GIGA R1 – Leitfaden

Entdecke mit uns die faszinierende Welt der künstlichen Intelligenz durch unser neuestes Projekt, das den Arduino GIGA R1 Display Shield einsetzt, um eine optimale Mensch-Maschine-Interaktion zu gewährleisten.

In diesem Blog wird erläutert, wie das Arduino GIGA R1 WiFi und das Display Shield DIY-Elektronikprojekte durch Integration modernster KI-Fähigkeiten für die Echtzeitkommunikation revolutionieren können. Wir werden wesentliche Komponenten, Einrichtungsverfahren und die innovative Nutzung der ChatGPT API für dynamische Interaktionen behandeln. Ideal für Enthusiasten und Entwickler, zielt dieser Beitrag darauf ab, einen umfassenden Leitfaden für den Aufbau und das Verständnis der Integration von Arduino mit KI-Technologien bereitzustellen.

Essenzielle Bauteile für das Arduino GIGA R1-Projekt

Interaktive Echtzeit-Kommunikation mit ArduinoGPT und ChatGPT

Das Projekt „ArduinoGPT“ revolutioniert die Art und Weise, wie wir mit Maschinen interagieren, indem es die leistungsstarke Kombination aus Arduino GIGA R1 WiFi und einer Tastatur zur Eingabe von Benutzeranfragen nutzt. Die Anfragen werden direkt an ChatGPT übermittelt, und die Antworten werden nahtlos auf dem GIGA Display Shield angezeigt.

curl -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer OPENAI_APIKEY" \
  --data-raw '{
    "model": "gpt-3.5-turbo",
    "messages": [
      {"role": "system", "content": "Du bist ein hilfreicher Assistent."},
      {"role": "user", "content": "Was ist Arduino"}
    ],
    "max_tokens": 50,
    "temperature": 0.7,
    "stream": true
  }' https://api.openai.com/v1/chat/completions

In diesem Befehl wird ein HTTP POST-Request an die OpenAI ChatGPT API gesendet. Dabei wird JSON als Content-Type festgelegt und ein API-Key für die Autorisierung verwendet. Die Anfrage enthält Nachrichten, die in einem Dialog zwischen System und Nutzer ausgetauscht werden, sowie Parameter zur Steuerung der Antwortlänge und Kreativität. Der “stream”-Parameter ist aktiviert, was bedeutet, dass Antworten als kontinuierlicher Datenstrom zurückgegeben werden.

Hier ist ein Beispiel dafür, wie die Antwort aussehen könnte, wenn du einen solchen Request ausführst:

data: {"id":"chatcmpl-8S1KjF9N9yYQyXrNkFBb83WMhM9y7","object":"chat.completion.chunk","created":1701689001,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}
data: {"id":"chatcmpl-8S1KjF9N9yYQyXrNkFBb83WMhM9y7","object":"chat.completion.chunk","created":1701689001,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"Arduino"},"finish_reason":null}]}
data: {"id":"chatcmpl-8S1KjF9N9yYQyXrNkFBb83WMhM9y7","object":"chat.completion.chunk","created":1701689001,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":" ist"},"finish_reason":null}]}

Bei diesem Request gibt die API eine Liste von Antwortfragmenten zurück. Jedes Fragment enthält einen Teil der gesamten Antwort im content-Feld.

Der USB-A-Anschluss des GIGA R1 kann verwendet werden, um generische USB-Tastaturen anzuschließen. Dies ermöglicht es dir, Eingabeaufforderungen direkt an ChatGPT zu senden. Arduino hat eine Bibliothek namens USBHostGiga veröffentlicht, die von GitHub heruntergeladen werden kann. Diese Bibliothek ermöglicht die Integration einer Funktion, die es Nutzern erlaubt, über eine Tastatur Eingaben am Arduino GIGA R1 WiFi vorzunehmen.

Mein Setup ist wie folgt

So richtest du dein Projekt Schritt für Schritt ein

• Lade die USBHostGiga-Bibliothek von GitHub herunter. Diese Bibliothek ermöglicht es dir, den USB-A-Anschluss des GIGA R1 zu nutzen, um eine generische USB-Tastatur anzuschließen.
• Installiere die USBHostGiga-Bibliothek in deiner Arduino IDE.
• Schließe eine generische USB-Tastatur an den USB-A-Anschluss des GIGA R1 an.
• Öffne die Arduino IDE und erstelle ein neues Sketch.
• Kopiere den untenstehenden Code-Snippet.
• Ersetze SSID_NETWORK_NAME, WIFI_PASSWORD und OPENAI_APIKEY mit deinen Daten.

<pre style="background-color: #f4f4f4; padding: 10px; border-radius: 8px; border: 1px solid #ccc; font-family: 'Courier New', Courier, monospace;">
<code>
#include &lt;Wire.h&gt;
#include &lt;SPI.h&gt;
#include "Arduino_GigaDisplay_GFX.h"
#include &lt;WiFi.h&gt;
#include &lt;ArduinoJson.h&gt;
#include &lt;WiFiSSLClient.h&gt;
#include &lt;string&gt;
#include "USBHostGiga.h"

GigaDisplay_GFX display; // create the object
#define BLACK 0x0000
#define ARDUINOJSON_DECODE_UNICODE 1

Keyboard keyb;
HostSerial ser;

char server[] = "api.openai.com";     
const int serverPort = 443;

char ssid[] = "SSID_NETWORK_NAME";        
char pass[] = "WIFI_PASSWORD";        
std::string apikey = "OPENAI_APIKEY"; 
int status = WL_IDLE_STATUS;

String getUserInput() {
  display.fillScreen(BLACK);
  display.setCursor(10, 10);
  display.println("User Prompt");
  display.setCursor(40, 40);

  String userInput = "";
  while (true) {
    if (keyb.available()) {
      auto _key = keyb.read();
      char inputChar = keyb.getAscii(_key);
      display.print(inputChar);
      if (inputChar == '1') {
        break;
      } else {
        userInput += inputChar;
      }
    }
  }

  return userInput;
}

void setup() {
  Serial.begin(115200);
  while (!Serial);
  pinMode(PA_15, OUTPUT);
  keyb.begin();
  ser.begin();
  display.begin();
  display.fillScreen(BLACK);
  display.setCursor(0, 0);
  display.setTextSize(3);
  display.setRotation(3);
  delay(1000);
  if (WiFi.status() == WL_NO_SHIELD) {
    Serial.println("Communication with WiFi module failed!");
    while (true);
  }

  while (status != WL_CONNECTED) {
    delay(1000);
    display.fillScreen(BLACK);
    display.setCursor(10, 10);
    display.println("Accessing Wi-Fi...");
    Serial.println("Accessing Wi-Fi...");
    status = WiFi.begin(ssid, pass);
    delay(3000);
  }
  delay(1000);
  display.fillScreen(BLACK);
  display.setCursor(10, 10);
  display.println("Connected to Wi-Fi");
  display.setCursor(40, 40);
  display.println(ssid);
  Serial.println("Connected to Wi-Fi");
  Serial.println(ssid);
  delay(1000);
}

void loop() {
  String userPrompt = getUserInput();
  Serial.println(userPrompt);
  // Create the JSON payload using ArduinoJson library
  DynamicJsonDocument doc(1024);
  doc["model"] = "gpt-3.5-turbo";
  doc["temperature"] = 0.7;
  doc["stream"] = true;

  JsonArray messages = doc.createNestedArray("messages");

  JsonObject systemMessage = messages.createNestedObject();
  systemMessage["role"] = "system";
  systemMessage["content"] = "You are an assistant. You have a character limit of about 100 words ";

  JsonObject userMessage = messages.createNestedObject();
  userMessage["role"] = "user";
  userMessage["content"] = userPrompt;

  String requestBody;
  serializeJson(doc, requestBody);

  delay(3000);
  Serial.println("\nStarting connection to server...");

  WiFiSSLClient client;

  if (client.connect(server, serverPort)) {
    Serial.println(client.status());
    Serial.println("Connected to the Server: api.openai.com");
    delay(100);

    // Send HTTP POST request and change the prompt to your own
    String request = "POST /v1/chat/completions HTTP/1.1\r\n";
    request += "Host: api.openai.com\r\n";
    request += "Authorization: Bearer " + String(apikey.c_str()) + "\r\n";
    request += "Content-Type: application/json\r\n";
    request += "Content-Length: " + String(requestBody.length()) + "\r\n";
    request += "Connection: close\r\n\r\n";
    request += requestBody;

    Serial.println(request);
    client.print(request);
    String response;
    String accumulatedContent; // Variable to accumulate content words

    while (client.connected()) {
      String line = client.readStringUntil('\n');
      if (line.startsWith("data: ")) {
            // Remove the "data: " prefix
            line.remove(0, 6);
            Serial.println(line);
            DynamicJsonDocument doc(1024);
            DeserializationError error = deserializeJson(doc, line);  

            if (error) {
            Serial.print("Failed to parse JSON: ");
            Serial.println(error.c_str());
            display.fillScreen(BLACK);
            display.setCursor(10, 10);
            display.print("Failed to parse JSON: ");
            display.println(error.c_str());
        } 
        else if   (line.equals("[DONE]")) {
            break;
      }
        else {
            JsonArray choices = doc["choices"];
            for (JsonObject choice : choices) {
              String content = choice["delta"]["content"];
              Serial.println("ChatGPT Response: " + content);
              accumulatedContent += content + " ";
    
              display.fillScreen(BLACK);
              display.setCursor(10, 10);
              display.println("ChatGPT Response:");
              display.setCursor(40, 40);
              display.println(accumulatedContent);
            }
        }     
    }
    }

  } else {
    Serial.println("api.openai.com connection failed");
    display.fillScreen(BLACK);
    display.setCursor(10, 10);
    display.println("api.openai.com connection failed");
  }

    // Delay between iterations
  delay(10000);
}
</code>
</pre>

Um die Eingabeaufforderung zu akzeptieren, sollte der Benutzer die Taste „1“ auf seiner Tastatur finden und drücken.

Das folgende Video veranschaulicht die Echtzeit-Nutzung von ArduinoGPT.

Ich hoffe, du findest dieses Projekt nützlich und danke fürs Lesen. Hast du Fragen oder Feedback? Hinterlasse unten einen Kommentar.

Der gesamte im Artikel erwähnte Code ist in Shakhizats GitHub-Repo verfügbar.

Shakhizat Nurgaliyev

Wir freuen uns sehr, dir heute einen faszinierenden Artikel vorstellen zu dürfen, der uns von Shakhizat Nurgaliyev aus Kasachstan bereitgestellt wurde. Shakhizat ist ein engagierter Entwicklungsingenieur für eingebettete Systeme, der sich insbesondere auf die Bereiche Robotik und das Internet der Dinge (IoT) spezialisiert hat. Er möchte seine Begeisterung für technologische Innovationen und seine umfassenden Kenntnisse nun auch mit deutschen Technik-Enthusiasten teilen. Durch seine Arbeit an autonomen und intelligenten Systemen, die maschinelles Lernen zur Interaktion mit ihrer Umgebung nutzen, leistet Shakhizat einen wichtigen Beitrag zur Entwicklung der Robotik und des IoT. Seine Expertise umfasst den gesamten Prozess von der Idee bis zur Umsetzung, was ihn zu einem wertvollen Akteur in seinem Fachgebiet macht.