Ich finde, das ist sie nach wie vor, auch wenn KI massive Fortschritte in der Erzeugung (Imitation?) von Musik gemacht hat. Wie auch immer man dazu stehen möchte – spannend ist das Thema ohne Frage. In diesem Artikel stelle ich einige Möglichkeiten und interessante Projekte vor.

Musik mit Udio komponieren

Am Anfang vieler KI-Anwendungen steht ein Prompt – so auch beim Tool Udio. Die Webseite dieses Anbieters erinnert auf den ersten Blick etwas an Spotify. Du findest dort zahlreiche, nach Genres sortierte Songs von anderen Nutzern, die du dir vorab schon mal anhören kannst, um herauszufinden, was Udio so leistet, um Musik mit künstlicher Intelligenz zu produzieren.

Wenn du selbst eine Song erstellen (lassen) möchtest, musst du dich zunächst registrieren. Aktuell ist das nur mit einem Google-, Discord- oder X-Konto möglich. Anschließend kannst du im Feld ganz oben deinen Prompt eintragen und mit Klick auf Create die Musikproduktion starten.

Ich habe mit folgendem Prompt versucht, einen “autofahrttauglichen” Softrock-Song zu erstellen:

A softrock song that you would have heard in the 90s while taking a long drive on the highway. Male voice, 70s Walker Brothers influence.

Das Ergebnis kannst du dir hier anhören. Bevor du allerdings einen Song wie diesen mit gut 2 Minuten Länge erstellt hast, gibt es noch etwas mehr zu tun. Udio erstellt zunächst eine Art Preview von etwas mehr als 30 Sekunden. Diesen Schnipsel kannst du dann anschließend erweitern, indem du ein weitere Teile wie ein passendes Intro oder Outro erstellen und “drankleben” lässt. Klicke hierfür neben dem Song auf den Button Extend und wähle die gewünschte Erweiterung.

Das klappt erstaunlich gut, denn einen unnatürlichen Übergang hörst du zwischen den Teilen nicht. Allerdings habe ich es nicht geschafft, dem Song eine richtige Struktur aus Intro, Strophe und Refrain zu geben. Vielmehr führen die Erweiterungen (Sections) das Lied immer weiter in eine Richtung, die kein wirkliches Ziel zu haben scheint. Ein menschlicher Künstler würde hier sicherlich anders vorgehen. Du kannst allerdings auch den sogenannten Manual Mode aktivieren, der dir mehr Möglichkeiten gibt, mit dem zugrundeliegenden Sprachmodell zu interagieren.

In den Songs wird natürlich auch gesungen – auf Stimme und Text kannst du hierbei Einfluss nehmen. Erstere kannst du direkt im Prompt versuchen, näher zu bestimmen. Den gewünschten Gesangstext kannst du (auch hinter dem Button Extend) hinterlegen. Deinem Shoegaze-Track mit vertonten Angeboten von Hornbach steht also nichts mehr im Wege.

Wenn du mit deinem Ergebnis zufrieden bist, kannst du deinen Song auch auf Udio veröffentlichen oder einen Link zum Anhören erstellen und teilen.

Musik mit künstlicher INtelligenz – und einem Plattenspieler

Ein spannendes Projekt zum Thema stammt von Arvind Sanjeev: Hier werden über Druckknöpfe gewünschte Attribute wie Lo-Fi oder Happy und Musikstile wie Dance oder Metal eingestellt. Außerdem kann die Geschwindigkeit und die Länge des Musikstücks vorgegeben werden. Anschließend erstellt das Gerät mit Hilfe von Metas MusicGen einen passenden Track, der dann direkt abgespielt wird. Der Plattenspieler auf der linken Seite kann dann genutzt werden, um den Song vor- oder zurückzuspulen, die Geschwindigkeit zu verändern – oder um darauf zu scratchen.

In der Kiste stecken neben dem Plattenspieler ein Arduino Mega, ein Raspberry Pi – und jede Menge Arbeit. Das Ergebnis ist ein Gerät, das die abstrakte künstliche Intelligenz mit einem haptischen Interface verbindet und sie so nachvollziehbar macht. Ob es praxistauglich für die Musikproduktion ist? Vermutlich nicht. Es ist vielmehr der künstlerische Versuch, neue Technologie in unsere erlernte Lebenswelt “hineinzuholen” und erfahrbar zu machen. Einen ähnlichen Ansatz hat das Wählscheiben-Telefon mit integriertem ChatGPT, das du hier auf Pollux Labs findest.

Weitere Informationen zur Plattenspielerkiste mit MusicGen und seiner Entstehung findest du bei CreativeApplications.Net

Hieraus lässt sich ein kleines Projekt bauen: Mit einem Python-Script ermittelst du den Passanten, der heute am knappsten an uns vorbeisaust und gibst seinen Namen sowie die Entfernung in der Konsole aus – oder lässt dich z.B. per E-Mail informieren.

Am 21. Februar 2024 sah es folgendermaßen aus:

Heute fliegt der Asteroid (2024 CL5) mit 1826990 Kilometern Entfernung am knappsten an der Erde vorbei.

Gute 1,8 Millionen Kilometer – klingt viel, ist es aber nach kosmischen Maßstäben eigentlich nicht. Aber immerhin war der Asteroid bei seinem Vorbeiflug immer noch ungefährt 5 Mal so weit von uns entfernt wie unser eigener Mond.

Das Python-Script

Du benötigst nicht viel Code für dieses Projekt. Zentral sind die API, bei der du die aktuellen Daten beziehst sowie das aktuelle Datum, das du in dieser API-Abfrage verwendest.

___STEADY_PAYWALL___

Die NASA betreibt eine Übersicht über ihre APIs – dort findest du unter Asteroids – NeoWs alle Informationen, die du benötigst. Wenn du dieses Projekt regelmäßig einsetzen möchtest, registriere deinen eigenen API-Key bei der NASA. Das kannst du auf der eben verlinkten Webseite machen. Falls du die API nur einmal ausprobieren möchtest, reicht auch der DEMO_KEY.

Hier zunächst das vollständige Python-Script:

import requests
from datetime import datetime

def find_asteroids(json_data):
    nearest_asteroid = None
    nearest_miss_distance = float('inf')
    
    for date in json_data["near_earth_objects"]:
        for asteroid in json_data["near_earth_objects"][date]:
            miss_distance = float(asteroid["close_approach_data"][0]["miss_distance"]["kilometers"])
            if miss_distance < nearest_miss_distance:
                nearest_asteroid = asteroid
                nearest_miss_distance = miss_distance
    
    return nearest_asteroid

# Aktuelles Datum erhalten und im passenden Format formatieren
current_date = datetime.now().strftime('%Y-%m-%d')

# API-URL für die NASA NEO-Daten
api_url = f"https://api.nasa.gov/neo/rest/v1/feed?start_date={current_date}&end_date={current_date}&detailed=false&api_key=DEMO_KEY"


# Anfrage an die API senden und JSON-Daten abrufen
response = requests.get(api_url)
json_data = response.json()

# Finde den Asteroiden mit dem knappsten Vorbeiflug
nearest_asteroid = find_asteroids(json_data)

print("Heute fliegt der Asteroid", nearest_asteroid["name"], "mit", int(float(nearest_asteroid["close_approach_data"][0]["miss_distance"]["kilometers"])), "Kilometern Entfernung am knappsten an der Erde vorbei.")

Hier findest du die URL der API, an die du deine Abfrage sendest:

api_url = f"https://api.nasa.gov/neo/rest/v1/feed?start_date={current_date}&end_date={current_date}&detailed=false&api_key=DEMO_KEY"

Dort eingebaut siehst du das aktuelle Datum als {current_date} – dieses Datum ermittelst und formatierst du wie folgt:

current_date = datetime.now().strftime('%Y-%m-%d')

Mit Hilfe der Bibliothek datetime ermittelst du das heutige Datum und bringst es mit dem Befehl strftime in das Format, das die API der NASA erwartet.

Die Antwort erhältst du im JSON-Format. Für den 21.2.24 sieht diese z.B. so aus. In diesen Daten suchst du nun mit der Funktion find_asteroids(json_data) nach dem Asteroiden, der der Erde am nächsten kommt. Sobald dieser gefunden ist, gibst du seinen Namen und die Entfernung des Vorbeiflugs über einen Print-Befehl aus.

print("Heute fliegt der Asteroid", nearest_asteroid["name"], "mit", int(float(nearest_asteroid["close_approach_data"][0]["miss_distance"]["kilometers"])), "Kilometern Entfernung am knappsten an der Erde vorbei.")

Mehr Informationen über die Asteroiden

In den Daten stecken noch viel mehr Informationen, als jene, die du bisher verwendest hast. Z.B. der geschätzte Durchmesser im Key estimated_diameter sowie seine Geschwindigkeit. Oder auch, ob der besagte Asteroid als gefährlich eingestuft wird – im Key is_potentially_hazardous_asteroid. Was diese Einstufung bedeutet, erfährst du in dieser Erklärung.

Falls du dich also für dieses Thema interessierst, sind deinem Tatendrang wenige Grenzen gesetzt. So könntest du z.B. grafisch darstellen, wie nah ein Asteroid uns in Bezug zu anderen Himmelskörpern kommt. Viel Spaß beim Experimentieren!

Ein kurzer Hinweis: Dieses Tutorial behandelt eine frühe Version und ist auf dem Stand Ende November ’23. Wie du weißt, entwickelt sich die KI-Welt rasant – also möglicherweise hat sie sich schon weitergedreht, wenn du diese Zeilen hier liest.

Das kann Stable Video Diffusion

Gegenwärtig kannst du mit Stable Video Diffusion eine kurze Video-Sequenz erstellen, die entweder 14 oder 25 Frames lang ist. Als Ausgangspunkt dient ein einzelnes Bild, das zwingend im Format 576×1024 Pixel vorliegen muss. Künftig ist auch eine Version geplant, die auf Basis eines Textprompts Videos erstellen kann, für die du dich bereits in eine Warteliste eintragen kannst.

Testweise habe ich eine kleine Animation einer Gummiente auf einem Fluss erstellt. Hier das Ergebnis:

Das Ausgangsbild hierfür habe ich mit ChatGPT erstellt (Hier ein Tutorial, wie du per API Bilder mit ChatGPT erzeugen kannst).

So erstellst du ein KI-Video auf Basis eines Bilds

Du findest auf Github das Repository von Stable Video Diffusion. Wenn du Erfahrung mit dem Klonen und Einrichten von Repositorys hast, kannst du lokal auf deinem Computer installieren. In diesem Video auf Youtube erhältst du weitere Information zum Download des benötigten KI-Modells und zu ComfyUI – einer Oberfläche, mit der du Stable Diffusion verwenden kannst.

Für einen ersten Test gibt es jedoch eine einfachere Möglichkeit, die dir viel Zeit spart.

___STEADY_PAYWALL___

Auf der Webseite von Replicate findest du eine Online-Version von Stable Video Diffusion, mit der du ohne großen Aufwand experimentieren kannst. Du musst lediglich ein Ausgangsbild im erwähnten Format von 576×1024 Pixeln hochladen und für einen ersten Test auf Run klicken. Das Video wird dann direkt in deinem Browser erstellt:

Auf der rechten Seite erscheint dann das fertige Video (oder eher eine kurze Animation), die auf Basis des Bilds links erzeugt wurde. Hinweis: Ein von ChatGPT erzeugtes Bild hat im Landscape-Format nicht ganz die richtige Größe für die Video-Generierung. Passe die Auflösung deshalb vor dem Upload manuell an.

Wie du im Video oben siehst, versucht Stable Video Diffusion zu erkennen, was sich auf dem statischen Bild für eine Animation eignen könnte. In unserem Fall ist das natürlich das Wasser des Flusses und die Ente, die darauf schwimmt. Selbst kannst du noch keine Vorgaben machen, was im Video passieren soll – also ob z.B. ein Stück Treibholz ins Bild schwimmt.

Voreingestellt sind 14 Frames, die mit den voreingestellten Frames pro Sekunde ein KI-Video von circa 2 Sekunden Länge ergeben. Du kannst aber die Videolänge auch auf 25 Frames erhöhen. Außerdem kannst du noch die Frames per Second definieren und auch mit weiteren Werten, wie der “Menge” an Bewegung, die im fertigen Video zu sehen sein soll, experimentieren.

Hier das Ergebnis eines Baums im Sturm mit 25 Frames, 15 Frames pro Sekunde und einer motion_bucket_id von 255:

Wie du hier siehst, geht es zwar rund mit den Wolken – der Baum scheint vom Sturm allerdings eher unbeeindruckt zu sein, abgesehen von ein paar herumwehenden Blättern. Hier fehlt einfach noch die Möglichkeit, konkret etwas vorzugeben, das Stable Diffusion dann auch verstehen und umsetzen kann.

Wenn du dein Ergebnis speichern möchtest, kannst du das Video als MP4-Datei herunterladen.

Dass künstliche Intelligenz auch Videos auf Basis konkreter Vorgaben erstellen kann, war eine Frage der Zeit – und Stable Video Diffusion ist sicherlich auch nicht die erste Anwendung dieser Art. Und doch ist das Ergebnis bereits beeindruckend. Die (nahe) Zukunft dürfte noch einige Verbesserungen bereithalten: Längere Videos mit besserer Steuerung, was in ihnen geschehen soll.

Zum Einsatz kommen hierbei zwei Python-Scripts – das erste, um die ID deines Wunsch-Supermarkts herauszufinden und die zweite für die Abfrage der Angebote und die Erstellung der Rezepte. Wenn du möchtest, kannst du letzteres auch automatisieren: Auf deinem Raspberry Pi könnte ein Cronjob jeden Montag die aktuellen Angebote abrufen und ChatGPT dir daraus sieben Rezepte für die ganze Woche erstellen.

Noch ein Hinweis vorab: Bei diesem Projekt handelt es sich natürlich um eine Spielerei – ob die von ChatGPT vorgeschlagenen Gerichte wirklich schmecken, ist leider nicht so ganz sicher. Aber bei den ersten Tests kam schon ansprechende Speisen heraus, z.B. Süßkartoffel-Kürbis-Auflauf, Mediterrane Hähnchenschenkel mit frischen Kräutern und Zitronen-Butter oder Rouladen nach Landhaus-Art. Sowohl die Zutatenliste auch die Anweisungen zur Zubereitungen klangen nicht abwegig. Ein Versuch ist es allemal Wert – und dieser Versuch erweitert auf jeden Fall deine Fähigkeiten.

Finde die ID deines REWE-Markts heraus

Bevor du die Angebote des REWE-Markts deiner Wahl abrufen kannst, benötigst du den marketCode dieses Markts. Den kannst du ganz leicht mit einem kleinen Python-Script herausfinden:

import requests
import json

# Trage hier deinen Standort ein
search_term = 'Karlsruhe'
url = f'https://www.rewe.de/api/marketsearch?searchTerm={search_term}'

# Stelle die Anfrage an die API.
response = requests.get(url)

# Überprüfe, ob die Anfrage erfolgreich war (HTTP Status Code 200).
if response.status_code == 200:
    # Parse die Antwort als JSON.
    data = response.json()

    # Schön formatierte Ausgabe des JSON.
    print(json.dumps(data, indent=4))
else:
    print('Fehler bei der Anfrage:', response.status_code)

Um die Märkte an deinem Standort zu finden, trage diesen in die Variable search_term ein – in meinem Fall ist das Karlsruhe. Wenn du das Script nun ausführst, erhältst du die Antwort als JSON. Hier die ersten beiden Einträge einer möglichen Antwort der API:

{
        "wwIdent": "831008",
        "isReweDortmund": false,
        "companyName": "REWE Ponzer GmbH & Co. oHG",
        "contactStreet": "Hans - Sachs - Str. 8",
        "contactZipCode": "76133",
        "contactCity": "Karlsruhe",
        "marketHeadline": "REWE Markt",
        "openingInfo": {
            "willOpen": {
                "onDay": 5,
                "at": "07:00"
            }
        }
    },
    {
        "wwIdent": "840913",
        "isReweDortmund": false,
        "companyName": "REWE Christopher Lannert oHG",
        "contactStreet": "Josef-Schofer-Str. 14",
        "contactZipCode": "76187",
        "contactCity": "Karlsruhe",
        "marketHeadline": "REWE Markt",
        "openingInfo": {
            "willOpen": {
                "onDay": 5,
                "at": "07:00"
            }
        }
    },

Gleich der jeweils erste Key wwIdent ist die ID bzw. marketCode, den du später benötigst. Suche dir also den gewünschten Markt aus der Liste heraus und notiere dir die ID.

Aktuelle Angebote finden

___STEADY_PAYWALL___

Bevor es mit dem nächsten Python-Script losgehen kann, musst du noch die Bibliothek cloudscraper installieren. Diese benötigst du, das die API von REWE eigentlich keine automatisierten Abfragen zulässt. Mit dieser Bibliothek kannst du diese Sperre allerdings umgehen. Achte deshalb bitte darauf, keinen “Unfug” anzustellen und z.B. zahllose Anfragen an die API zu stellen.

Um die Bibliothek zu installieren, gib im Terminal bzw. in der Konsole folgenden Befehl ein:

pip install cloudscraper

Außerdem benötigst du noch die Bibliothek openai, mit der du die API von ChatGPT ansteuern kannst. Diese installierst du wie folgt:

pip install openai

Nun kann es mit dem Script losgehen. Zunächst bindest du die beiden genannten Bibliotheken ein und hinterlegst deine gefundene ID sowie die URL für die Abfrage:

import cloudscraper
from openai import OpenAI

# Deine ID, hier ein Beispiel aus Karlsruhe
market_id = '831008'
# Die Basis-URL der API
url = f'https://mobile-api.rewe.de/api/v3/all-offers?marketCode={market_id}'

Anschließend bereitest du cloudscraper vor, erstellst einen leeren String, in den die gefundenen Sonderangebote geschrieben werden – und erstellst eine Liste der Angebotskategorien, die überhaupt für Rezepte in Frage kommen. Es gibt natürlich auch Angebote in den Kategorien Haushalt, Tierfutter, Spirituosen etc., mit denen wir aber hier nichts anfangen können.

# Erstellen ein Cloudscraper-Objekt
scraper = cloudscraper.create_scraper()

# Stelle die GET-Anfrage
response = scraper.get(url)

# Initialisiere einen leeren String für die Titel der Angebote
titles_string = ''

# Eine Liste der gewünschten Kategorietitel
desired_categories = {
    'Frische & Kühlung',
    'Süßes & Salziges',
    'Obst & Gemüse',
    'Nahrungsmittel',
    'Tiefkühl'
}

Nun fehlt nur noch die eigentliche Abfrage. Hier stellst du sicher, dass in der Variablen titles (für die Namen der angebotenen Artikel) nur jene aus den vorgegebenen Kategorien gespeichert werden.

# Überprüfe  den Statuscode der Antwort
if response.status_code == 200:
    # Wenn der Statuscode 200 ist, war die Anfrage erfolgreich
    # Konvertiere die Antwort in JSON
    data = response.json()
    
    # Extrahiere die Angebote, die den gewünschten Kategorietiteln entsprechen
    titles = [
        offer['title']
        for category in data['categories']
        for offer in category['offers']
        if 'rawValues' in offer and 'categoryTitle' in offer['rawValues']
        and offer['rawValues']['categoryTitle'] in desired_categories
    ]
    
    # Erstelle einen String mit den gefilterten Titeln, getrennt durch Kommas
    titles_string = ', '.join(titles)
    
    # Ausgabe des Strings
    print("Gefilterte Titel:", titles_string)
else:
    # Wenn der Statuscode nicht 200 ist, gab es ein Problem mit der Anfrage
    print(f'Fehler: {response.status_code}')

Rezepte erstellen lassen mit ChatGPT

Nun folgt der zweite Teil des Scripts. Hier fragst du ChatGPT über die API nach Rezeptideen, die auf den gefundenen Sonderangeboten basieren. Hierfür benötigst du einen API-Key von OpenAI. In diesem Tutorial erfährst du, wie du dir den benötigten Key erstellst.

Du hinterlegst im Script also deinen Key und erstellst gleich danach die Abfrage:

client = OpenAI(
  api_key="DEIN API-KEY",
)

print("Ich erstelle Gerichte...")
completion = client.chat.completions.create(
#model="gpt-3.5-turbo", 
model="gpt-4",
messages=[
{"role": "system", "content": "Du bist ein KI-Koch, der aus vorgegebenen Zutaten Rezepte für Gerichte entwirft."},
{"role": "user", "content": "Es folgt eine Liste von Zutaten. Kreiere hieraus 3 Rezepte für leckere Gerichte. Gehe davon aus, dass die Küchen-Basics wie Salz, Pfeffer, Öl, Butter etc. bereits vorhanden sind. Hier die Liste: {}".format(titles_string)}]
)

print(completion.choices[0].message.content)

Du findest im obigen Code zwei Zeilen, mit denen du auswählen kannst, ob du das Modell 3.5 oder die neuere Version 4 verwenden möchtest. Kommentiere einfach die nicht gewünschte Version aus.

Als Anweisung (system) an ChatGPT legst du fest, dass die KI als Ideengeber für Rezepte fungieren soll. Mit dem eigentlichen Prompt (user) legst du dann fest, was du möchtest. Im obigen Beispiel sind es drei Rezepte, für die übliche Zutaten wie Salz und Pfeffer enthalten sein dürfen, auch wenn sie nicht in den Angeboten zu finden sind. An diesen Prompt hängst du dann einfach die Liste der Angebote an.

Hier hast du natürlich einiges an Spielraum. So könntest du z.B. nur vegetarische Gerichte entwerfen lassen und ChatGPT Unverträglichkeiten mitteilen.

Die Antwort der künstlichen Intelligenz sieht dann beispielsweise folgendermaßen aus:

Rezept 1: Rinderrouladen mit Apfel-Rotkohl und Maronen

Zutaten:
- Rinder-Rouladen
- Petersilie
- Rote Tafeläpfel
- REWE Beste Wahl Apfelrotkohl
- REWE Bio Gekochte Maronen

1. Die Rinderrouladen flach ausbreiten, mit Salz und Pfeffer würzen und mit gehackter Petersilie bestreuen. Die Rouladen aufrollen und mit Küchengarn befestigen.
2. Die Rouladen in einem großen Topf mit Öl scharf anbraten und anschließend beiseite stellen.
3. Die Äpfel schälen, vierteln, entkernen und klein schneiden. Zusammen mit dem Apfelrotkohl in den Topf geben und ca. 5 Minuten dünsten.
4. Die Rinderrouladen zurück in den Topf geben und bei niedriger Hitze 60 Minuten köcheln lassen.
5. 10 Minuten vor Ende der Kochzeit die gekochten Maronen hinzufügen.
6. Abschmecken und servieren.

Klingt doch halbwegs plausibel, oder? Eine Beilage wäre vielleicht noch gut und dass der Rotkohl in den gleichen Topf wie die Rouladen soll, ist auch nicht ganz einleuchtend. Auch wenn du die Rezepte nicht 1:1 übernehmen solltest, erhältst du mit diesem Projekt recht brauchbare Ideen für Gerichte, die deinen Geldbeutel schonen. Ich wünsche dir jedenfalls schon einmal guten Appetit!

Hier nun das vollständige Python-Script:

import cloudscraper
from openai import OpenAI

# # Deine ID, hier ein Beispiel aus Karlsruhe
market_id = '831008'
# Die Basis-URL der API
url = f'https://mobile-api.rewe.de/api/v3/all-offers?marketCode={market_id}'

# Erstellen ein Cloudscraper-Objekt
scraper = cloudscraper.create_scraper()

# Stelle die GET-Anfrage
response = scraper.get(url)

# Initialisiere einen leeren String für die Titel der Angebote
titles_string = ''

# Eine Liste der gewünschten Kategorietitel
desired_categories = {
    'Frische & Kühlung',
    'Süßes & Salziges',
    'Obst & Gemüse',
    'Nahrungsmittel',
    'Tiefkühl'
}

# Überprüfe  den Statuscode der Antwort
if response.status_code == 200:
    # Wenn der Statuscode 200 ist, war die Anfrage erfolgreich
    # Konvertiere die Antwort in JSON
    data = response.json()
    
    # Extrahiere die Angebote, die den gewünschten Kategorietiteln entsprechen
    titles = [
        offer['title']
        for category in data['categories']
        for offer in category['offers']
        if 'rawValues' in offer and 'categoryTitle' in offer['rawValues']
        and offer['rawValues']['categoryTitle'] in desired_categories
    ]
    
    # Erstelle einen String mit den gefilterten Titeln, getrennt durch Kommas
    titles_string = ', '.join(titles)
    
    # Ausgabe des Strings
    print("Gefilterte Titel:", titles_string)
else:
    # Wenn der Statuscode nicht 200 ist, gab es ein Problem mit der Anfrage
    print(f'Fehler: {response.status_code}')


# Mit ChatGPT Rezepte erstellen
client = OpenAI(
  api_key="DEIN API-KEY",
)

print("Ich erstelle Gerichte...")
completion = client.chat.completions.create(
#model="gpt-3.5-turbo", 
model="gpt-4",
messages=[
{"role": "system", "content": "Du bist ein KI-Koch, der aus vorgegebenen Zutaten Rezepte für Gerichte entwirft."},
{"role": "user", "content": "Es folgt eine Liste von Zutaten. Kreiere hieraus 3 Rezepte für leckere Gerichte. Gehe davon aus, dass die Küchen-Basics wie Salz, Pfeffer, Öl, Butter etc. bereits vorhanden sind. Hier die Liste: {}".format(titles_string)}]
)

print(completion.choices[0].message.content)
  

Bevor es losgeht

Um die ChatGPT API nutzen zu können, benötigst du ein Konto bei OpenAI. Ebenso musst du die benötigte Python-Bibliothek installieren. In diesem Tutorial erfährst du, wie beides funktioniert. Sobald du mit den Vorbereitungen fertig bist, kann es losgehen.

Ein Bild erzeugen

Über die API kannst du mit nur wenigen Zeilen Code ein Bild erzeugen:

from openai import OpenAI

client = OpenAI(
  api_key="DEIN OPENAI API-KEY",
)

response = client.images.generate(
  model="dall-e-3",
  prompt="Eine weiße Siamkatze",
  n=1,
  size="1024x1024",
  quality="standard"
)

image_url = response.data[0]['url']
print(image_url)

Nachdem du die Bibltiothek eingebunden hast, erstellst du mit der Funktion openai.Image.create() ein Bild. Hierbei sind folgende Parameter im Einsatz:

• model: Das Modell, das du verwenden möchtest (dall-e-2 oder dall-e-3)
• prompt: Deine Anweisung, was auf dem Bild zu sehen sein soll (und optional welcher Stil verwendet werden soll)
• n: Die Anzahl der Bilder
• size: Die Größe des generierten Bildes (1024×1024, 1024×1792 oder 1792×1024 Pixel)
• quality: Die Qualität des Bilds (standard oder hd)

In der Variablen image_url wird eine URL gespeichert, hinter der du das fertige Bild findest. Kopiere die URL und öffne sie in einem Browser deiner Wahl – dort siehst du dann das Bild und kannst es herunterladen. Hier das Bild, das mit dem Prompt oben (“Eine weiße Siamkatze”) erstellt wurde:

Tipps zur Verfeinerung deiner Bilder

Manchmal erhältst du möglicherweise nicht sofort das gewünschte Bild. Hier sind einige Tipps, wie du die Qualität der generierten Bilder verbessern kannst:

1. Präzise Beschreibungen: Je genauer und detaillierter deine Beschreibung ist, desto besser wird das Ergebnis sein. Gib der künstlichen Intelligenz ganz klare Anweisungen.
2. Experimentieren mit Parametern: Ändere die Bildgröße, den Stil oder die Anzahl der generierten Bilder, um unterschiedliche Ergebnisse zu erzielen.
3. Mehrere Versuche: Wenn du mit dem ersten Ergebnis nicht zufrieden bist, probiere es erneut. Die API kann in verschiedenen Anfragen unterschiedliche Bilder erzeugen.

Das kostet ein Bild

Die Nutzung der ChatGPT API ist nicht kostenlos. Auf der Webseite von OpenAI findest du die aktuelle Preisliste. Die Preise für die Erstellung von Bilder findest du unter Image models.

In diesem Tutorial lernst du, wie du

• dir einen OpenAI Account und den benötigten API Key erstellst
• mit Python Prompts erstellst und die Antwort von ChatGPT erhältst
• zwischen den Modellen 3.5 und 4 wechselst
• ChatGPT präzise Anweisungen gibst, die du nicht in jedem Prompt wiederholen musst

Einen OpenAI Account erstellen

Um die ChatGPT API nutzen zu können, benötigst du einen Account bei OpenAI. Wenn du allerdings bereits den Chatbot nutzt, musst du natürlich kein Extra-Konto erstellen. Besuche diese Webseite, um einen Account zu erstellen oder dich einzuloggen.

Anschließend landest du auf der Startseite. Dort warten eine Vielzahl von Tutorials auf dich, die du aber zunächst links liegen lässt.

Einen API Key erstellen

Klicke stattdessen oben rechts auf Personal und wähle den Menüpunkt View API keys. Auf der folgenden Seite findest du den Button Create new secret key. Nach einem Klick hierauf kannst du deinem neuen Key einen (am besten sprechenden) Namen geben:

Ein weiterer Klick auf Create secret key erstellt deinen neuen Key, den du dir direkt herauskopieren und ablegen solltest. Später kannst du den Key nicht mehr aufrufen – allerdings kannst du in diesem Fall einfach einen neuen erstellen.

Zahlungdaten hinterlegen

Die ChatGPT API ist nicht kostenlos – deshalb musst du dein Konto mit einem Betrag deiner Wahl (mindestens jedoch 5 $) aufladen musst. Hierfür stehen dir verschiedene Zahlungsmethoden wie PayPal oder Kreditkarte zur Verfügung.

Bei OpenAI findest du die aktuellen Preise für die Nutzung der API. Sobald dein Konto mit ein paar Dollar aufgeladen ist, kann es direkt mit dem Python Script weitergehen.

Stelle eine Frage mit Python

Wie du bestimmt schon weißt, funktioniert ChatGPT wie eine Art Chatbot – du stellst eine Frage oder gibst eine Anweisung und erhältst darauf eine Antwort. Diese Frage wird auch Prompt genannt. Das folgende Python Script stellt die Verbindung zur ChatGPT API her, übermittelt deinen Prompt und gibt die Antwort aus.

from openai import OpenAI
client = OpenAI(
  api_key="DEIN API KEY",
)

completion = client.chat.completions.create(
  model="gpt-3.5-turbo",
  messages=[
    {"role": "user", "content": "Wie lautet die Antwort auf alle Fragen?"}
  ]
)

print(completion.choices[0].message.content)

In der ersten Zeile bindest du die Bibliothek openai ein. Diese musst du natürlich vorher noch installieren. Führe hierfür zum Beispiel im Terminal folgende Zeile aus:

pip install openai

Ein kleiner Hinweis: Der Code oben funktioniert nur mit Versionen der Bibliothek ab dem 8.11.23 – sollte deine Version älter sein, führe zunächst ein Update mit pip install –upgrade openai durch. Zurück zum Script: Nachdem du die Bibliothek eingebunden hast, hinterlegst du in der Variablen api_key deinen API Key, den du vorhin erstellst hast.

Und noch ein Hinweis: In der offiziellen Dokumentation von openAI werden zwei andere Verfahren vorgeschlagen, um den API-KEY zu hinterlegen. Diese haben bei mir allerdings nicht zuverlässig funktioniert. Falls du sie ausprobieren möchtest, kannst du hier mehr erfahren.

Anschließend folgt die Abfrage mit der Funktion client.chat.ompletions.create(). Hier legst du zunächst das Modell fest, im obigen Beispiel ist das GPT-3.5-turbo. Du kannst seit Juli 2023 auch das bessere Modell GPT-4 verwenden. Aber Achtung: ChatGPT 4 ist aktuell (September 2023) 20 Mal teuerer als ChatGPT 3.5 – du kannst die Preise über den Link oben vergleichen. Die dort aufgelisteten Preise beziehen sich jeweils auf 1.000 Tokens. Laut OpenAI entspricht das ungefähr 750 Wörtern (im Englischen).

Letztlich musst du selbst entscheiden, wie gut die Antworten von ChatGPT innerhalb deines Projekts ausfallen sollen. Wenn du dich für das Modell 4 entscheidest ersetze die entsprechende Zeile im Python Script durch:

model="gpt-4",

Update (Feb. 2024): Mittlerweile gibt es auch ein GPT-4 Turbo, das auf Trainingsdaten bis Dezember 2023 basiert. Dieses Modell kannst du mit “gpt-4-0125-preview” einbinden und verwenden. Weitere Informationen (auch zu kommenden Modellen) findest du hier.

Falls du in deinem Script immer das neueste GPT-4-Modell verwenden möchtest, bietet die ChatGPT API nun hierfür eine Möglichkeit: Verwende einfach das Modell gpt-4-turbo-preview, das stets auf die aktuellste Version verweist. Weitere Informationen hierüber findest du hier.

Der Prompt

Kommen wir zur Frage, die du stellst und dafür an die ChatGPT API sendest. Diese findest du im Script hier:

messages=[
    {"role": "user", "content": "Wie lautet die Antwort auf alle Fragen?"}]
)

Hier definierst du zunächst die Rolle (role), hier also user. Diese Rolle hat die Person, die eine Frage stellt – also genauso wie du es vielleicht vom Browser oder der App gewohnt bist. Dahinter folgt der content, also die eigentliche Frage oder Anweisung.

Nun muss nur noch die Antwort ausgegeben werden:

print(completion.choices[0].message.content)

In deinem Terminal oder Konsole sollte nun die Antwort erscheinen, die du sicherlich auch schon vorher wusstest.

Weitere Rollen für DIE ChatGPT API

Oben hast du die Rolle user verwendet. Du kannst ChatGPT aber auch vor deiner eigentlichen Frage genauere Anweisungen mitgeben und damit versuchen, das System etwas zu “lenken”. Hierfür fügst du vorab etwas mit der Rolle system ein:

messages=[
    {"role": "system", "content": "Du beantwortest Fragen kurz und präzise."},
    {"role": "user", "content": "Wie lautet die Antwort auf alle Fragen?"}]
)

Das ist besonders nützlich, wenn ChatGPT zum Beispiel Antworten in einem bestimmten Format geben soll. Du musst diese Anweisungen also nicht in deinem eigentlichen Prompt unterbringen, sondern kannst sie separat erstellen und verwenden.

Und das war es schon. Du hast nun das grundlegende Python Script, um per API mit ChatGPT zu kommunizieren. Wirf einen Blick in die Raspberry Pi Projekte, um Anwendungsmöglichkeiten zu entdecken. Wenn du dich besonders für den Bereich künstlicher Intelligenz interessierst, wirf doch mal einen Blick in unsere KI-Projekte.

Du lädst dir hierfür die aktuelle Schlagzeile der BBC-Nachrichten von einer API und schickst diese an die künstliche Intelligenz von deepai.org – von dort erhältst du eine Illustration der Schlagzeile zurück auf deinen Computer, gemalt in einem Stil deiner Wahl.

Diese APIs benötigst du

In diesem Projekt kommen zwei Services zum Einsatz, die du über deren APIs ansteuerst: NewsAPI und DeepAI. Von ersterer fragst die aktuelle Schlagzeile der BBC ab. Hierfür benötigst du einen API Key, den du nach deiner kostenlosen Registrierung erhältst. Wie das geht, und wo du deinen API Key findest, haben wir in diesem Projekt beschrieben.

Mit DeepAI erzeugst du dann KI Bilder, indem du die Schlagzeile an deren API weiterleitest und als sogenannten Prompt verwendest. Das ist so etwas wie die “Malanweisung”, die du der künstlichen Intelligenz gibst. Hierfür kommt ein Diffusionsmodell zum Einsatz, das der Deutschlandfunk Kultur in diesem Beitrag anschaulich erklärt. Erstaunlich hierbei ist, dass die KI eigentlich kein Bild auf Basis deiner Anweisung erzeugt, sondern vielmehr aus einem großen Rauschen “freilegt”.

Aber zurück zur API von DeepAI. Auch um diese nutzen zu können, benötigst du einen kostenlosen Account dort. Du erhältst anschließend einige Gratis-Credits, die du bei Bedarf auch günstig aufstocken kannst. Nachdem du dein kostenloses Kontingent verbraucht hast, kostet dich ein Bild 5 Cent – ein Betrag, der den Spaß Wert ist, wie wir finden.

Deinen API Key von DeepAI findest du übrigens oben in deinem Profil. Auch diesen wirst du demnächst in deinem Python Script benötigen.

Bibliotheken installieren

Für dein Script benötigst du einige Bibliotheken, die du vielleicht noch nicht installiert hast: requests, newsapi und PIL. Du kannst sie mit diesen Befehlen installieren:

pip install requests
pip install newsapi-python
pip install Pillow

Du benötigst diese drei Bibliotheken für die API-Abfrage bei DeepAI und NewsAPI und um das Bild, das du zurück erhältst zu bearbeiten. Insgesamt importierst du zu Beginn des Scripts folgende Bibliotheken:

import requests
import webbrowser
import json
from newsapi import NewsApiClient
from PIL import Image
import os
import sys
import shutil
import random

Schlagzeilen von newsapi abrufen

Als nächstes besorgst du dir die neuesten Nachrichten von der BBC. Hier kommt die NewsAPI-Bibliothek zum Einsatz, die du gerade importiert hast. (Natürlich kannst du den Request auch anders gestalten.)

# NewsAPI
newsapi = NewsApiClient(api_key='DEIN API-Key von NewsAPI')

# Top-Schlagzeilen der BBC abrufen
headlines = newsapi.get_everything(sources='bbc-news',
                                   language='en',
                                   sort_by='publishedAt')

x = headlines.get('articles')
y = x[0]

# Die längere 'description' der Schlagzeile der Variable prompt zuweisen
print('Ich empfange die neueste BBC-Schlagzeile...')
prompt = y.get('description')

KI Bilder erzeugen

Danach kommt die künstliche Intelligenz ins Spiel. Um etwas Abwechslung ins Spiel zu bringen, bindest du vier verschiedene Stilrichtungen ein (galleries): “Old Style”, Pop Art, Renaissance, Abstrakt. Welcher Stil bei deiner Anfrage zum Einsatz kommt, bestimmst du mit einer Zufallszahl.

Je nachdem, welche Zahl gewürfelt wurde, steuerst du eine andere URL der API an:

# Zufällig eine von vier Stilrichtungen festlegen
randomGallery = random.randint(0,3)

if randomGallery == 0:
    galleryURL = 'https://api.deepai.org/api/old-style-generator'
elif randomGallery == 1:
    galleryURL = 'https://api.deepai.org/api/pop-art-generator'
elif randomGallery == 2:
    galleryURL = 'https://api.deepai.org/api/renaissance-painting-generator'
else:
    galleryURL = 'https://api.deepai.org/api/abstract-painting-generator'

print('Ich verwende den Stil von: ' + galleryURL)

r = requests.post(
    galleryURL,
    data={
        'text': prompt,
    },
    headers={'api-key': 'DEIN API-Key von DeepAI'}
)

url = r.json()
print(url['output_url'])

Wie du im Code oben siehst, dient die Description der BBC-Schlagzeile als prompt, den du in deinem Request an die API übermittelst. Ein mögliches Ergebnis im sogenannten “Old Style” sieht dann so aus:

DeepAI liefert dir über die API immer eine Collage aus vier quadratischen Bildern zurück. In diesem Python Script schneiden wir das Bild oben links aus und speichern es ab – mit dem Prompt als Dateinamen. Natürlich kannst du es auch unverändert ausschneiden, oder jedes einzelne Quadrat ausschneiden und separat speichern.

# Bild herunterladen
def download_image(url, file_name, headers):
     response = requests.get(url, headers=headers)
     if response.status_code == 200:
        with open(file_name, "wb") as f:
            f.write(response.content)
     else:
        print(response.status_code)

headers = {
    "User-Agent": "Chrome/51.0.2704.103",
}

url = url['output_url']

# Dateinamen = Prompt festlegen
file_name = "{}.jpg".format(prompt)

download_image(url, file_name, headers)

# Bild zuschneiden
print('Ich schneide das Bild zu...')
img = Image.open('{}'.format(file_name))
box = (0, 0, 512, 512)
img = img.crop(box)
img.save('{}'.format(file_name))

Zuletzt bleibt nur noch eins: Das neue Bild zu öffnen und zu präsentieren:

img.show()

Das vollständige Python Script

Hier nun das vollständige Script. Vergiss nicht, deine API Keys von NewsAPI und DeepAi einzutragen, bevor du loslegst.

# Copyright 2023, Pollux Labs
# 
# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
# documentation files (the "Software"), to deal in the Software without restriction, including without
# limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
# Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
# 
# The above copyright notice and this permission notice shall be included in all copies or substantial portions
# of the Software.
# 
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
# TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
# CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
# 
# https://polluxlabs.net/python/so-erzeugst-du-ki-bilder-mit-python-und-deepai/

import requests
import webbrowser
import json
from newsapi import NewsApiClient
from PIL import Image
import os
import sys
import shutil
import random

# NewsAPI
newsapi = NewsApiClient(api_key='DEIN API-Key von NewsAPI')

# Top-Schlagzeilen der BBC abrufen
headlines = newsapi.get_everything(sources='bbc-news',
                                   language='en',
                                   sort_by='publishedAt')

x = headlines.get('articles')
y = x[0]

# Die längere 'description' der Schlagzeile der Variable prompt zuweisen
print('Ich empfange die neueste BBC-Schlagzeile...')
prompt = y.get('description')


# Bild von DeepAI empfangen

# Zufällig eine von vier Stilrichtungen festlegen
randomGallery = random.randint(0,3)

if randomGallery == 0:
    galleryURL = 'https://api.deepai.org/api/old-style-generator'
elif randomGallery == 1:
    galleryURL = 'https://api.deepai.org/api/pop-art-generator'
elif randomGallery == 2:
    galleryURL = 'https://api.deepai.org/api/renaissance-painting-generator'
else:
    galleryURL = 'https://api.deepai.org/api/abstract-painting-generator'

print('Ich verwende den Stil von: ' + galleryURL)

r = requests.post(
    galleryURL,
    data={
        'text': prompt,
    },
    headers={'api-key': 'DEIN API-Key von DeepAI'}
)

url = r.json()
print(url['output_url'])


print('Ich male dein Bild...')

# Bild herunterladen
def download_image(url, file_name, headers):
     response = requests.get(url, headers=headers)
     if response.status_code == 200:
        with open(file_name, "wb") as f:
            f.write(response.content)
     else:
        print(response.status_code)

headers = {
    "User-Agent": "Chrome/51.0.2704.103",
}

url = url['output_url']

# Dateinamen = Prompt festlegen
file_name = "{}.jpg".format(prompt)

download_image(url, file_name, headers)

# Bild zuschneiden
print('Ich schneide das Bild zu...')
img = Image.open('{}'.format(file_name))
box = (0, 0, 512, 512)
img = img.crop(box)
img.save('{}'.format(file_name))

# Bild anzeigen
img.show()

Bringe das Projekt in dein Wohnzimmer

Zum Schluss noch eine Idee für ein Raspberry Pi Projekt: Verbinde ein quadratisches Display, z.B. das HyperPixel 4.0 Square, mit deinem Raspberry Pi. Beides kannst du in einen Bilderrahmen stecken und das Python Script automatisch bei jedem Boot laufen lassen.

Damit jedoch nicht immer das gleiche Bild im Bilderrahmen steckt, könntest du noch dafür sorgen, dass es z.B. jede Stunde ausgetauscht wird.

Zusammengebaut könnte das Ganze dann so ausschauen:

Suchst du einen leichten Zugang in die Welt der Microcontroller und Elektronikprojekte? Oder bist du schon ein alter Hase und hast einfach Lust auf etwas Neues? Es gibt eine Menge Gründe, CirycuitPython auszuprobieren!

In diesem Artikel erfährst du, was CircuitPython ist und was du brauchst, um damit durchzustarten. Wir schreiben zusammen etwas Python-Code und lassen ein paar LEDs wilde Sachen machen.

Was ist CircuitPython?

Das New Yorker Unternehmen Adafruit hat im Sommer 2017 ihre “neue” Programmiersprache vorgestellt: CircuitPython. Hierbei handelt es sich um einen sogenannten Fork von MicroPython, einer anderen Sprache, die ebenso für die Programmierung von Microcontrollern entwickelt wurde. Beide Programmiersprachen basieren auf Python 3 – CircuitPython wurde jedoch mit dem Ziel entwickelt, besonders einsteigerfreundlich zu sein.

Python gilt als leicht zu erlernende Programmiersprache und wird mittlerweile auch bereits in der Schule unterrichtet. Dabei ist Python nicht nur etwas für Einsteiger – auch komplexe Projekte im Bereich der künstlichen Intelligenz werden z.B. mit Python realisiert.

Welche Vorteile hat CircuitPython?

Abgesehen davon, dass Python relativ leicht zu lernen ist, hat der Einsatz von CircuitPython noch weitere Vorteile.

Vermutlich hast du bereits in der Arduino IDE Sketches in C++ geschrieben und auf dein Board geladen. Dann weißt du, dass jede Änderung im Code mit einem längeren Update des Boards verbunden ist: Der Sketch wird kompiliert und dann vollständig auf den Microcontroller geladen – was ganz schön lange dauern kann.

Anders bei CircuitPython: Wenn du dein Board per USB an deinen Computer anschließt, wird es als Laufwerk erkannt. Hierauf befindet sich der Python-Code z.B. in der Datei code.py – diese Datei kannst du theoretisch mit jedem Text-Editor öffnen und verändern. Sobald du deine Änderungen gespeichert hast, resettet sich dein Board automatisch und läuft mit dem neuen Code – eine Sache von wenigen Sekunden.

Der große Unterschied hierbei ist, dass C++ kompiliert wird und Python (also auch CircuitPython) interpretiert. Wie bitte? Um nicht den Rahmen dieses Artikel zu sprengen, lies bitte hier mehr über Kompilieren und Interpretieren, wenn dich das Thema interessiert.

Die REPL

Das klingt schon ziemlich schnell, aber es geht noch schneller. Wenn auf deinem Board CircuitPython läuft, kannst du mit ihm über die REPL (engl. Read–eval–print loop) kommunizieren. Das heißt, du kannst Befehle direkt an deinen Microcontroller senden, die dieser dann sofort ausführt.

Das ist besonders praktisch zum Debuggen, also um schnell mal auszuprobieren, ob eine LED richtig angeschlossen ist oder eine Funktion so funktioniert, wie du es dir vorgestellt hast. Mit der Arduino IDE und C++ kann das mitunter frustrierend sein, da du auch für kleine Änderungen im Sketch alles wieder neu kompilieren und hochladen musst.

Später lernst du in diesem Artikel den Mu Editor kennen. Dann werden wir genauer auf die REPL eingehen.

Und die Nachteile?

Natürlich hat der Einsatz von CircuitPython auch Nachteile. Ein gewichtiger ist der Support mit Bibliotheken: Adafruit und die Community haben bereits für viele Sensoren und Bauteile passende Bibliotheken veröffentlicht und stellen diese selbstverständlich kostenfrei zur Verfügung. An die Menge, die dir in der Arduino IDE zur Verfügung steht, kommen sie aber noch nicht heran.

Da CircuitPython jedoch eine noch relativ junge Technologie ist, sind wir davon überzeugt, dass sich das im Laufe der Zeit ändern wird. Bereits jetzt veröffentlicht Adafruit regelmäßig neue Bundles mit Bibliotheken, die dir das Leben leichter machen.

Stichwort Geschwindigkeit: Die Geschwindigkeit beim Entwickeln ist bei CircuitPython zwar höher, dafür können Programme jedoch langsamer laufen als es beim kompilierten Code in C++ der Fall ist. Aber dieser Unterschied dürfte bei den meisten Hobby-Anwendungen kaum ins Gewicht fallen.

Der passende Microcontroller

Der einfachste Weg, mit CircuitPython und Microcontrollern zu experimentieren, ist, ein speziell dafür ausgelegtes Board zu kaufen. Adafruit hat hier eine fast schon überwältigende Menge an verschiedenen Boards in vielen Größen und für viele Anwendungsbereiche produziert.

Du kannst CircuitPython aber auch auf einigen Arduino-Boards wie dem Zero oder dem MKR Zero zum Laufen bringen. In der Dokumentation von Adafruit erfährst du mehr darüber.

In diesem Artikel verwenden wir das Board Metro M0 Express von Adafruit. Es hat dieselben Maße wie ein Arduino UNO und verfügt über ähnlich viele Analog- und Digitalpins. Außerdem hat es 4 LEDs und einen NeoPixel an Bord und verfügt über 2MB Speicher. Genug Platz für deinen Code, Dateien und Bibliotheken.

Adafruit METRO M0 Express - designed for CircuitPython - ATSAMD21G18

39,99 €

Alle Boards, die CircuitPython unterstützen, findest du in einer Übersicht von Adafruit.

Vorbereitungen

Du hast dich entschlossen, mit CircuitPython loszulegen? Großartig! Bevor du anfängst, musst du allerdings noch etwas Zeit in Vorbereitungen stecken.

Zunächst solltest du dir die passende Firmware für dein Board, die aktuellen Bibliotheken und einen passenden Editor herunterladen und installieren.

Die Firmware

Suche in der Übersicht von Adafruit nach deinem Board und klicke darauf. Anschließend siehst du die verfügbaren Versionen der Firmware. Achte darauf, die neueste stable Version herunterzuladen – in unserem Beispiel die Version 5.3.1

Schließe nachdem Download dein Board per USB an deinem Computer an. Als nächstes musst du es in den Boot-Modus versetzen: Das machst du, indem du zweimal kurz hintereinander den Reset-Button auf dem Board drückst.

Adafruit weist darauf hin, dass das in der “richtigen” Geschwindigkeit erfolgen soll – wie auch immer, wenn es geklappt hat, findest du im Explorer (oder Finder auf deinem Mac) ein neues Laufwerk. Der Name des Laufwerks setzt sich aus dem Boardnamen und “BOOT” zusammen. In unserem Fall heißt es also METROBOOT.

Ziehe nun die Datei, die du vorhin heruntergeladen hast, auf dieses Laufwerk. Damit installierst du die Firmware. Nach wenigen Sekunden sollte das Laufwerk automatisch ausgeworfen werden und dafür ein anderes mit dem Namen CIRCUITPY erscheinen.

Wenn das der Fall ist, hat alles funktioniert und dein Board ist bereit. Falls es nicht klappt, wirf einen Blick in die Dokumentation von Adafruit – hier werden einige weitere Hilfestellungen gegeben.

Die Bibliotheken

Jetzt wo dein Board bereit ist, fehlen noch die Bibliotheken. Wie eingangs erwähnt, gibt es bereits für viele Anwendungen eine Bibliothek, die dir Arbeit abnimmt.

Adafruit bietet hier ganze Bundles an, die du dir hier herunterladen kannst. Lade dir von dort das Bundle herunter, das deiner Firmware-Version entspricht. Wenn du also eine Firmware in der Version 5.x installiert hast benötigst du das Bibliotheken-Bundle mit derselben Versionsnummer.

Entpacke die heruntergeladene Datei und öffne den Ordner. Im Unterordner lib findest du nun alle verfügbaren Bibliotheken. Suche dir die aus, die du benötigst und kopiere sie in den gleichnamigen Ordner des Laufwerks CIRCUITPY. Wenn dein Board genug Speicher besitzt, kannst du auch einfach alle Bibliotheken dort rüberkopieren.

Wenn du auf Probleme stößt, konsultiere die Dokumentation von Adafruit zum Thema Bibliotheken. Hier werden recht viele Sonderfälle besprochen.

Examples

Aus der Arduino IDE kennst du sicherlich die Beispiele, die den meisten Bibliotheken beiliegen. Diese sind recht nützlich, um herauszufinden, welche Funktionen eine Bibliothek bietet und wie du diese verwendest.

Diese Beispiele gibt es auch für CircuitPython. Auf der Seite, von der du das Bibliotheken-Bundle heruntergeladen hast, kannst du unter Bundle Examples eine ZIP-Datei mit Beispielen herunterladen.

Wie du diese Beispiele auf deinem Board ausführst, sehen wir gleich. Zunächst fehlt jedoch noch der passende Editor.

Der Mu Editor

Um Code in CircuitPython schreiben zu können, benötigst du natürlich einen Editor. Hier reicht im Prinzip der einfachste Text Editor – wir möchten dir jedoch den Mu Editor ans Herz legen. Der ist gratis, einsteigerfreundlich und für CircuitPython ausgelegt. So findest du darin z.B. einen Seriellen Monitor und Plotter wie du es vermutlich schon von der Arduino IDE gewohnt bist. Außerdem kannst du hier auch die oben beschriebene REPL problemlos verwenden.

Lade dir die aktuelle Version hier von der offiziellen Seite für dein Betriebssystem herunter.

Erste Schritte

Öffne nun den Mu Editor. Als nächstes schauen wir uns die wichtigsten Funktionen an. Danach schreibst du auch schon deinen ersten Code in Python und bringst ihn auf deinem Board zum Laufen.

Im oberen Bereich findest du eine Leiste mit Funktionen:

Modus: Hier kannst du einstellen, für welchen Zweck du den Mu Editor verwenden möchtest. Unserer heißt Adafruit CircuitPython.

Neu: Erstellt eine neue leere Datei.

Laden & Speichern: Das ist sicherlich klar. Ein Hinweis vorab: Wenn dein Board deinen Code automatisch starten soll, musst du den Dateinamen cody.py verwenden.

Seriell & Plotter: Diese beiden kennst du sicherlich schon von der Arduino IDE. Hier kannst du wie gewohnt Daten einsehen und Statements ausgeben, die dir beim Debuggen helfen.

Prüfen: Hiermit kannst du deinen Code auf Fehler checken lassen.

Die REPL öffnen und verwenden

Um die REPL zu öffnen und direkt mit deinem Board interagieren zu können, öffne zunächst über den entsprechenden Button oben den Seriellen Monitor. Drücke anschließend gleichzeitig Strg + C und danach eine beliebige Taste. Nun öffnet sich die REPL:

Zeit für einen kurzen Test: Kopiere den folgenden Code, füge ihn in deiner REPL ein und drücke Enter:

import board
import digitalio
import time
 
led = digitalio.DigitalInOut(board.D13)
led.direction = digitalio.Direction.OUTPUT

Jetzt kannst du direkt die Onboard-LED anschalten, indem du folgendes eingibst und wieder Enter drückst:

led.value = True

Ist sie angegangen? Dann schalte sie versuchsweise wieder aus, indem du led.value auf False setzt. Hinweis: Auf den meisten kompatiblen Boards kannst du die interne LED über den Pin D13 ansteuern. Bei einigen ist es jedoch D17 und einige wenige haben keine interne LED.

So speicherst du dein Programm auf dem Board

Die REPL ist toll, um schnell etwas zu testen. In den meisten Fällen wirst du jedoch ein reguläres Programm in CircuitPython schreiben und direkt auf deinem Board abspeichern.

Dein Board sucht automatisch nach einer Datei mit dem Namen code.py. Wenn es keine findet, hält es Ausschau nach der Datei main.py und führt diese aus. Heißt konkret: Speichere das Programm, das ausgeführt werden soll unter dem Namen code.py direkt auf dem Laufwerk CIRCUITPY deines Boards ab.

Immer wenn dein Board hier eine Änderung feststellt – weil du den Code im Mu Editor aktualisiert und gespeichert hast – rebootet es und führt den neuen Code aus. Das ganze dauert in der Regel nur wenige Sekunden.

Dein erstes Programm in CircuitPython

Jetzt wird es Zeit, dein erstes Programm zu schreiben, auf deinem Board abzuspeichern und auszuführen. Auch für dieses Beispiel soll erst einmal eine blinkende LED reichen.

Schnapp dir ein Breadboard, eine LED und einen Vorwiderstand und baue folgendes auf:

Kopiere nun folgenden Code in eine leere Datei in deinem Mu Editor und speichere sie als code.py ab.

import board
import digitalio
import time
 
led = digitalio.DigitalInOut(board.D1)
led.direction = digitalio.Direction.OUTPUT
 
while True:
    led.value = True
    time.sleep(0.5)
    led.value = False
    time.sleep(0.5)

Deine LED sollte nun im Halbsekundentakt an- und wieder ausgehen. Werfen wir nun einen Blick auf die einzelnen Teile des Codes.

Zunächst bindest du drei Bibliotheken ein so wie du es aus der Arduino IDE kennst. Viele Bibliotheken sind in extra Dateien ausgelagert und müssen von dir in den Ordner lib auf deinem Board gespeichert werden, bevor du sie verwenden kannst.

Die drei Bibliotheken in diesem Beispiel sind jedoch Teil von CircuitPython. Das heißt, du musst nichts weiter tun, bevor du sie verwenden kannst, außer sie einzubinden:

import board
import digitalio
import time

Die Bibliothek board benötigst du für den Zugriff auf deine Hardware, digitalio kümmert sich um die Inputs und Outputs des Boards und mit time kannst du dein Programm “schlafen legen” – ähnlich wie du das mit delay() in C++ machst.

Anschließend legst du den Pin der LED (D1) und seine “Richtung” (OUPUT) fest. Auch das kennst du aus der Arduino IDE von der Funktion pinMode().

led = digitalio.DigitalInOut(board.D1)
led.direction = digitalio.Direction.OUTPUT

Zuletzt erstellst du einen While-Loop, der ununterbrochen läuft. Hier schaltest du die LED mit led.value = True ein, wartest eine halbe Sekunde und schaltest sie für eine weitere halbe Sekunde wieder aus.

while True:
    led.value = True
    time.sleep(0.5)
    led.value = False
    time.sleep(0.5)

Spiele an den Werten etwas herum, um zu sehen, wie sich die Intervalle der LED verändern. Wenn du dein Programm speicherst, sollten deine Änderungen nach wenigen Sekunden sichtbar werden.

Wie geht es weiter?

Du hast nun alles, was du brauchst, um mit CircuitPython loszulegen. Zeit für deine Experimente. Schaue als nächstes in den Bibliotheken nach, für welche deiner Bauteile und Sensoren du hier etwa passendes findest. Wirf anschließend einen Blick in die Beispiel-Codes, die jeder Bibliothek beiliegen und beginne deine Abenteuer mit CircuitPython!

Was ist MicroPython?

MicroPython ist angelehnt an und kompatibel zu Python 3 und speziell für die Programmierung von Microcontrollern ausgelegt. Die Sprache ist dem regulären Python sehr ähnlich – das heißt, wenn du bereits mit Python programmieren kannst, kannst du das auch mit MicroPython.

Da diese Sprache darauf ausgelegt ist, unter eingeschränkten Bedingungen – nämlich auf Microcontrollern mit wenig Speicherplatz – zu arbeiten, besitzt MicroPython nicht alle Bibliotheken von Python. Die für die Programmierung von ESP8266 und ESP32 sind natürlich an Bord – insbesondere jene, die du brauchst, um mit den Pins zu arbeiten und dich mit dem Internet zu verbinden.

Welche Vorteile bietet MicroPython?

Python ist eine Programmiersprache, die sowohl leicht zu lernen als auch leicht zu lesen ist. Das gilt auch für MicroPython – wenn du etwas Python beherrschst und schon auf “richtigen” Computern programmiert hast, fällt dir der Einstieg mit MicroPython leicht. Hier findest du einen Überblick über wichtige Funktion von MicroPython (Englisch).

Weitere Vorteile sind:

• Du kannst deinen Microcontroller “live” programmieren. D.h. über die Shell (bzw. REPL) kannst du deinen Code direkt testen, ohne erst einen ganzen Sketch hochladen zu müssen.
• Exception und Error-Handling: Du kannst den Umgang mit Ausnahmen und Fehler bereits in deinem Code definieren.

Aber MicroPython hat auch Nachteile im Vergleich zur Arduino IDE und C, denn hier gibt es für viele Bauteile bereits Bibliotheken, die du einfach installieren, einbinden und verwenden kannst. Mit MicroPython wirst du ab und an etwas länger nach einer geeigneten Lösung suchen müssen.

MicroPython installieren mit der Thonny IDE

Um mit MicroPython auf deinem ESP8266* oder ESP32* loslegen zu können, musst du deinen Microcontroller mit einer passenden Firmware flashen. Hierfür gibt es mehrere Möglichkeiten. Eine recht einfache ist der Editor Thonny IDE. Das Tolle: Thonny ist für Anfänger bestens geeignet und du kannst auch gleich deinen Microcontroller damit programmieren.

Lade dir zunächst die neueste Version von Thonny hier herunter und starte die Installation.

Die Firmware herunterladen

Als nächstes benötigst du die aktuelle Firmware. Diese findest du hier auf der offiziellen Seite von MicroPython. Wähle den entsprechenden Abschnitt für deinen Controller und lade dir die aktuelleste (latest) Version herunter, indem du auf den Dateinamen mit der Endung .bin klickst. Mit dieser Datei flashst du gleich deinen Microcontroller.

Schließe nun deinen Microcontroller wie gewohnt über USB an deinen Computer an. Nun öffne die Thonny IDE.

Klicke als Erstes Menü Run auf Configure interpreter. Dort findest du im Dropdown-Menü mehrere Optionen – auch jeweils eine für den ESP8266 und den ESP32. Wenn du die passende Option gewählt hast, kannst du unter Port or WebREPL den USB-Port wählen, an dem dein Microcontroller angeschlossen ist.

Klicke nun auf den Link unten rechts Install or update MicroPython.

Wähle unter Port noch einmal den richtigen USB-Port aus und wähle unter Firmware die Datei, die du gerade heruntergeladen hast.

Mit einem Klick auf Install geht es los! Auf deinem Microcontroller wird MicroPython installiert. Nach wenigen Sekunden sollte das erledigt sein und du kannst die drei Fenster wieder schließen, bis du wieder auf der Oberfläche der Thonny IDE bist.

So funktioniert MicroPython und die Thonny IDE

Die Oberfläche der Thonny IDE besteht (neben dem Menü) aus zwei Fenstern. Im oberen schreibst du dein Python-Programm, dass über den grünen “Play”-Button auf deinen ESP8266 oder ESP32 hochlädst.

Im unteren Fenster findest du die Shell, mit der quasi in Echtzeit mit deinem Microcontroller interagieren kannst.

Wenn du einen ESP8266 angeschlossen hast, trage hinter die drei >>> in der Shell probeweise – Zeile für Zeile – folgenden Code ein und drücke nach jeder Zeile Enter:

from machine import Pin
Pin(2, Pin.OUT).value(0)

Nun sollte die interne LED auf deinem Controller leuchten. Wenn du in die Klammern hinter value eine 1 einträgst, geht sie wieder aus. Seltsamerweise verhält sich dieser Code beim ESP8266 “falsch herum” – eine 1 schaltet den Pin auf HIGH, eine 0 auf LOW. Beim ESP32 ist das wiederum wie gewohnt.

Wie geht es weiter?

Jetzt hast du das grundlegende Setup, um deinen Microcontroller mit MicroPython zu programmieren. Erforsche als nächstes, was du hiermit alles anstellen kannst!

Hier findest du ESP8266 Projekte, die du nachbauen oder von denen du dich inspirieren lassen kannst.

Wenn MicroPython doch nicht das Richtige für dich ist, lerne hier CircuitPython kennen.