Der Fox:bit von Keyestudio erinnert auf den ersten Blick an den bekannten BBC micro:bit – ist aber deutlich größer und tritt mit einem ganz eigenen Stil auf.
Seinem Namen macht er dabei alle Ehre: Der Fox:bit besitzt zwei kleine „Ohren“, die ihm einen unverwechselbaren Look verleihen – ganz ohne Funktion, aber mit ordentlich Charme und Wiedererkennungswert.
Technisch spielt er allerdings in einer ganz anderen Liga.
Im Inneren arbeitet ein ESP32-Dual-Core-Prozessor, der nicht nur mehr Leistung bietet, sondern auch WLAN und Bluetooth direkt an Bord hat.
Damit eignet sich der Fox:bit nicht nur für Einsteigerprojekte, sondern auch für komplexe, drahtlose Anwendungen – von Sensorprojekten bis hin zu IoT-Lösungen.
Kurz gesagt: Der Fox:bit vereint Leistung, Lernfreundlichkeit und Design auf eine Art, die ihn zu einem spannenden Alternativboard für Schulen, Maker und kreative Köpfe macht.
Inhaltsverzeichnis
- Technische Daten des Fox:bit von Keyestudio
- Aufbau des Fox:bit – Anschlüsse, Sensoren & Aktoren im Überblick
- Für wen ist der Fox:bit Mikrocontroller gedacht?
- Erste Schritte mit MicroPython (Fox:bit / ESP32)
- Fazit & Ausblick
Technische Daten des Fox:bit von Keyestudio
Unter der auffälligen „Fuchs“-Optik steckt beim Fox:bit moderne Technik.
Das Board basiert auf dem bewährten ESP32-WROOM-32 Modul, das für seine hohe Rechenleistung und vielseitigen Kommunikationsmöglichkeiten bekannt ist.
Dadurch eignet sich der Fox:bit sowohl für klassische Arduino-Projekte als auch für MicroPython-Experimente.
Technische Spezifikationen
| Merkmal | Beschreibung |
|---|---|
| Mikrocontroller | ESP32-WROOM-32 (Dual-Core Xtensa® 32-bit LX6 @ 240 MHz) |
| Speicher | 520 KB SRAM, 4 MB Flash |
| Betriebsspannung | 3,3 V |
| Stromversorgung | USB-C (5 V) oder externer Pin |
| Kommunikation | WLAN 802.11 b/g/n, Bluetooth v4.2 (BLE) |
| GPIO-Pins | 19 digitale Pins (I2C, SPI, UART, PWM, ADC) |
| Schnittstellen | I2C, SPI, UART, PWM, ADC |
| Tasten | Taster A, Taster B, kapazitiver Touch Sensor Reset-Taster |
| Sensoren | Mikrofon, Lichtsensor, Temperatur & Luftfeuchtesensor, 3-Achsen Lagesensor |
| Aktoren | PiezoBuzzer, 7×5 RGB-LED Matrix |
| Sonstiges | SD-Kartenslot, PH2.0 Anschluss für LiPo Batterien |
| Programmierbar mit | Arduino IDE, MicroPython, MakeCode (ESP32-Erweiterung) |
| Abmessungen | ca. 60 × 40 mm |
| Anschluss | USB-C |
| Gewicht | ca. 14 g |
| Kompatibilität | Windows, macOS, Linux |
Was sofort auffällt
- Der Fox:bit setzt komplett auf USB-C, statt wie viele Lernboards auf micro-USB.
- WLAN und Bluetooth sind direkt integriert, was drahtlose Projekte ohne Zusatzmodule ermöglicht.
- Die kompakte Bauform und das sympathische Design mit den „Ohren“ machen ihn nicht nur technisch, sondern auch optisch zu einem Hingucker.
Aufbau des Fox:bit – Anschlüsse, Sensoren & Aktoren im Überblick
Der Fox:bit von Keyestudio ist nicht nur leistungsstark, sondern auch clever aufgebaut.
Alle wichtigen Schnittstellen, Sensoren und Aktoren sind direkt auf der Platine integriert und gut zugänglich – ideal, um ohne zusätzliche Module sofort mit spannenden Projekten zu starten.
Um dir einen besseren Überblick zu geben, habe ich eine Grafik der Vorder- und Rückseite erstellt.
Darin sind alle wichtigen Komponenten, Pins und Funktionen markiert 👇
In der folgenden Tabelle findest du alle Onboard-Ressourcen inklusive der zugehörigen GPIO-Pins im Überblick 👇
Fox:bit – On-board-Ressourcen & GPIO-Zuordnung
| Modul | Beschreibung | Interface | GPIO |
|---|---|---|---|
| Button A | Digitaler Taster A | Digital | GPIO0 |
| Button B | Digitaler Taster B | Digital | GPIO4 |
| Touch | Kapazitive Taste | Touch | GPIO27 |
| IMU (QMI8658C) | 6-Achs-Sensor | I²C | SDA=GPIO21, SCL=GPIO22 |
| Lichtsensor | Umgebungshelligkeit | Analog | GPIO39 |
| Mikrofon | Schalldetektion | Analog | GPIO35 |
| Buzzer | Piezo-Ausgabe | Digital/PWM | GPIO33 |
| 5×7 RGB-Matrix | 35× WS2812 | 1-Draht (NeoPixel) | GPIO13 |
| Temp/Feuchte (AHT20) | Messung T/RH | I²C | SDA=GPIO21, SCL=GPIO22 |
| SD-Kartenerweiterung | Speicher | SPI | CS=GPIO5, MOSI=GPIO23, MISO=GPIO19, SCK=GPIO18 |
| Stromerfassung | Current Sense | Analog | GPIO36 |
Für wen ist der Fox:bit Mikrocontroller gedacht?
Bevor es an die Programmierung geht, lohnt sich ein Blick auf die Zielgruppe des Fox:bit von Keyestudio.
In erster Linie ist er ein kompakter Lern-Mikrocontroller, der sich ideal für den Einstieg in die Welt der Elektronik und Programmierung eignet.
Er spricht Schüler, Studierende und Maker gleichermaßen an – also alle, die ohne viel Aufwand eigene Projekte umsetzen möchten.
Was ich persönlich am Fox:bit besonders reizvoll finde:
Man muss keine aufwendige Schaltung mehr aufbauen, wenn man nur schnell etwas testen will.
Braucht man zum Beispiel einen Sensor oder möchte eine Idee mit einem Mikrocontroller ausprobieren, greift man einfach zum Fox:bit – steckt ihn an, öffnet die Arduino IDE oder MicroPython-Umgebung und kann direkt loslegen.
So wird aus dem kleinen Board ein praktisches Werkzeug für Prototyping, Bildung und Experimente.
Ganz gleich, ob im Klassenzimmer, im Makerspace oder auf dem heimischen Schreibtisch – der Fox:bit ist immer bereit für das nächste Projekt.
Alles klar — ab in die Praxis! Hier ist ein kompakter Abschnitt „Erste Schritte mit MicroPython auf dem Fox:bit“ inkl. Setup und direkt lauffähiger Beispielcodes für die wichtigsten Onboard-Module.
Erste Schritte mit MicroPython (Fox:bit / ESP32)
Bevor es losgeht: MicroPython auf den Fox:bit flashen
Bevor wir den Fox:bit in MicroPython programmieren können, muss auf dem Mikrocontroller zunächst die passende MicroPython-Firmware installiert werden.
Das klingt komplizierter, als es ist – denn mit der Thonny IDE geht das ganz einfach.
Thonny bietet ein integriertes Tool, mit dem sich die Firmware direkt auf den Mikrocontroller flashen lässt – ganz ohne zusätzliche Software oder Kommandozeilen-Befehle.
Wenn das flashen des Mikrocontrollers erfolgreich war, dann wird in der Konsole folgendes Ausgegeben:
MPY: soft reboot
MicroPython v1.26.1 on 2025-09-11; Generic ESP32 module with ESP32
Type "help()" for more information.Hier können wir auch ablesen welche Version installiert wurde, in meinem Fall die neueste vom 11.09.2025.
Pin-Zentrale anlegen
Lege dir eine kleine Datei foxbit_pins.py an – so bleibt alles konsistent:
# foxbit_pins.py
PINS = {
"BTN_A": 0,
"BTN_B": 4,
"TOUCH": 27,
"I2C_SDA": 21,
"I2C_SCL": 22,
"LIGHT_ADC": 39,
"MIC_ADC": 35,
"BUZZER": 33,
"NEOPIXEL": 13,
"SD_CS": 5,
"SD_MOSI": 23,
"SD_MISO": 19,
"SD_SCK": 18,
"CURR_ADC": 36,
}
Schnelltests (funktioniert alles?)
I²C-Scan (AHT20 & IMU sichtbar?)
from machine import I2C, Pin
from foxbit_pins import PINS
i2c = I2C(0, scl=Pin(PINS["I2C_SCL"]), sda=Pin(PINS["I2C_SDA"]), freq=400_000)
print("I2C Geräte:", [hex(a) for a in i2c.scan()])
Buttons & Touch
from machine import Pin, TouchPad
from time import sleep
from foxbit_pins import PINS
btn_a = Pin(PINS["BTN_A"], Pin.IN, Pin.PULL_UP)
btn_b = Pin(PINS["BTN_B"], Pin.IN, Pin.PULL_UP)
touch = TouchPad(Pin(PINS["TOUCH"]))
while True:
if btn_a.value() == 0:
print("Button A")
sleep(0.25)
if btn_b.value() == 0:
print("Button B")
sleep(0.25)
if touch.read() < 350:
print("Touch!")
sleep(0.25)
sleep(0.05)
Das kleine Script erzeugt nachfolgende Ausgabe wenn man nacheinander die Tasten betätigt. Dabei ist der aufruf der Funktion „sleep(0.25)“ für das entprellen der Taster zuständig.
Onboard-Module nutzen
RGB-LED-Matrix (WS2812 / NeoPixel)
import machine, neopixel, time
from foxbit_pins import PINS
NUM = 35 # 5x7 Matrix
np = neopixel.NeoPixel(machine.Pin(PINS["NEOPIXEL"]), NUM)
# alle rot, dann aus
np.fill((20, 0, 0)); np.write(); time.sleep(0.8)
np.fill((0, 0, 0)); np.write()
# Laufschleife über die Pixel
for i in range(NUM):
np.fill((0,0,0))
np[i] = (0, 0, 30)
np.write()
time.sleep(0.03)
Die kleinen NeoPixel sind sehr leuchtstark und daher drossel ich im Code diese massiv.
Buzzer (Ton/PWM)
from machine import Pin, PWM
from time import sleep_ms, sleep
from foxbit_pins import PINS
# Taster mit Pull-Up (0 = gedrückt)
btn_a = Pin(PINS["BTN_A"], Pin.IN, Pin.PULL_UP)
# Buzzer-Pin zuerst sicher auf LOW ziehen
buzz_pin = Pin(PINS["BUZZER"], Pin.OUT, value=0)
p = PWM(buzz_pin)
p.duty_u16(0) # stumm im Idle
def play_sequence():
for f in (523, 659, 784, 1046): # C5, E5, G5, C6
p.freq(f)
p.duty_u16(20000) # Lautstärke
sleep_ms(150)
p.duty_u16(0) # wieder stumm
while True:
state = btn_a.value()
if state == 0:
play_sequence()
sleep(0.25)
sleep_ms(10)
Wenn man den Taster A betätigt wird eine kleine Tonfolge auf dem Piezo Buzzer abgespielt.
Lichtsensor & Mikrofon (ADC)
from machine import ADC, Pin
from time import sleep
from foxbit_pins import PINS
light = ADC(Pin(PINS["LIGHT_ADC"]))
mic = ADC(Pin(PINS["MIC_ADC"]))
light.atten(ADC.ATTN_11DB) # vollen Bereich nutzen
mic.atten(ADC.ATTN_11DB)
for _ in range(50):
l = light.read_u16()
m = mic.read_u16()
print("Lux-Proxy:", l, "Mic-Level:", m)
sleep(0.1)
Der Lichtsensor reagiert schon auf kleinste veränderungen an der Helligkeit hier reicht es eigentlich auch schon aus mit der Hand darüber zu wischen.
Fazit & Ausblick
Der Fox:bit von Keyestudio zeigt eindrucksvoll, wie vielseitig moderne Lern-Mikrocontroller geworden sind.
Dank ESP32-Power, vielen integrierten Sensoren und MicroPython-Support ist er mehr als nur ein Einsteigerboard – er ist ein echtes Entwicklungswerkzeug für Maker, Schüler und Lehrkräfte.Wer den BBC micro:bit kennt, wird sich beim Fox:bit sofort zurechtfinden – bekommt aber deutlich mehr Leistung, Speicher und Flexibilität.
In einem der nächsten Beiträge zeige ich, wie man mit dem Fox:bit eine kleine Wetterstation mit Temperaturanzeige auf der RGB-Matrix baut. 🌤️
Bleib also dran, wenn du mehr aus dem kleinen Fuchs rausholen willst!
Letzte Aktualisierung am: 10. November 2025
