iPhone & iPad · Öppen källkod
En telefon som robotens ansikte.
OpenHead gör en iPhone eller iPad till ett uttrycksfullt robothuvud. Din robot, ett Python-skript eller en AI-agent får det att le, se sig omkring, prata och visa saker, över ditt eget wifi.
Rikta iPhonens kamera mot koden för att öppna appen i App Store.
iOS-appen OpenHead Robot Face för iPhone och iPad. App Store-sidan öppnas när appen är släppt; fram till dess finns den i beta på TestFlight.
En AI-assistent på skrivbordet
En 3D-rendering av testriggen: en iPhone 12 på den fyraxliga halsen från Open Duck Mini. Den följer ditt ansikte, hör din fråga och svarar med egen röst (slå på ljudet), kartlägger rummet med bakkameran medan frontkameran ser dig, går på Open Duck Mini och vet var den är, skickar alla sensorer till din agent och visar allt i cockpiten i webbläsaren. Video på den riktiga riggen kommer härnäst.
Bygg den själv: utskriftsfiler, dellista, firmware och en MCP-server för halsen finns i OpenHead desk body (GitHub).
Allt ett robothuvud behöver
En telefon har redan skärmen, sensorerna och radion. OpenHead gör dem åtkomliga för resten av roboten, som inte behöver veta något om iOS.
28 uttryck
Glad, nyfiken, fundersam, förvånad, orolig, skrattande, självbelåten och fler. Blanda dem, håll dem en stund eller lägg en snabb reaktion ovanpå ett humör.
Ögon som lever
Titta på en punkt på skärmen eller i en riktning från huvudet. Blinkningar, andning och små ögonrörelser håller ansiktet levande mellan kommandona.
En mun som pratar
Roboten skickar hur högt den talar 25 gånger i sekunden, och munnen följer med inom ungefär 70 ms. Känslorna är separata, så humöret kan skifta mitt i en mening.
Talar och lyssnar
Från 0.4 talar huvudet med egen röst, med munnen i takt med ljudet, och spelar upp markeringar i texten: [happy], [laugh], [pause]. Mikrofonen gör om det du säger till text åt din agent, på enheten när det går.
Cockpit
Från 0.5 öppnar openhead cockpit en panel i webbläsaren: huvudets kamera som liten video, alla sensorer, vad det ska säga (med exempel att utgå från), tema och känsla. Flytta, lägg till och ta bort kort; din layout sparas. Telefonen visar ”Camera shared” medan du tittar.
Undertexter
Text ovanpå allt, för en robot utan högtalare eller ett AI-svar som strömmar in ord för ord. Munnen kan röra sig med texten.
Bilder, video, webb
PNG, JPEG, animerad GIF, WebP och SVG; H.264-video; webbsidor. Ansiktet kan fortsätta i ett hörn medan de visas.
Kameravy med HUD
Se det huvudet ser, med en sci-fi-HUD: rutor runt ansikten, ett låst mål, kompass, horisont, batteri och dina egna rader.
Ansiktsspårning
Följer flera ansikten samtidigt, med riktning, storlek och plats på skärmen, 15 gånger i sekunden; med ARKit även avståndet. Robotens ögon följer personen framför den och håller ögonkontakt.
Vet var det är
ARKit följer huvudets position och riktning i rummet 60 gånger i sekunden, bredvid rörelsesensorerna på upp till 100 Hz. Från 0.3 berättar GPS, barometer, magnetometer och kompass var det är utomhus.
Tre utseenden, samma uttryck
Teman är data, inte kod: former, färger och bilder i en mapp. Alla teman har samma 28 uttryck, så roboten behöver aldrig bry sig om vilket som är på.
Se alla 28 uttryck i varje tema



Se det huvudet ser
Visa frontkameran med en HUD ritad ovanpå. HUD:en markerar varje ansikte, låser på det närmaste och visar huvudets egna värden. Fyra utseenden, alla data precis som ansiktsteman, så du kan göra egna.
På en riktig telefon
Skärmdumpar från en iPhone 18 Pro: rutan sitter på ansiktet den hittade, ögonen följer det, och telefonens eget batteri, kompassriktning och lutning syns på HUD:en.
Lägg in din egen information
- Inbyggda värden: batteri, temperatur, kompassriktning, lutning, position, ansikten i bild, det låsta målet.
- Instrument: kompassband, konstgjord horisont, batterimätare.
- Roboten lägger till egna värden och rader när som helst, till exempel uppgift, hastighet eller mål.
- Ett HUD-tema är en liten JSON-fil: färger, ton, scanlines, rutor, lås, textblock och instrument.
# robotens egna rader på HUD:en
openhead camera camcorder --follow
openhead hud --set task="DELIVER CUP" --set speed=0.4 \
--line "TASK {task}" --line "SPEED {speed} M/S" --widget compass
Sensordata
Allt huvudet känner av kommer som små JSON-meddelanden som du prenumererar på, i den takt du ber om. Vinklar följer huvudet: + åt dess vänster och uppåt; rörelse följer ROS-konventionerna. Diagrammen nedan är en inspelning på 15 sekunder från en iPhone 18 Pro i handen, med en person framför (tools/sensor_plots.py spelar in vilket huvud som helst).
Data: imu.csv · faces.csv · pose.csv · fler diagram: rotationshastighet, position över tid.
Alla sensorer huvudet använder
En iPhone 12 har redan allt detta. OpenHead läser sensorerna och skickar resultaten; inget annat behöver kopplas in på roboten.
| Sensor | Vad OpenHead gör med den | Ström |
|---|---|---|
| Frontkamera (TrueDepth) | ansiktsspårning: hittar flera ansikten; med ARKit följs ett ansikte med avstånd | faces, kameravy |
| Bakre kamera | ARKit-spårning i rummet (visuell-inertiell SLAM): var huvudet är och hur det är vridet | pose |
| Accelerometer och gyroskop | orientering, rotationshastighet och acceleration enligt ROS; lutning på HUD:en | imu |
| Magnetometer | magnetfält och kompassriktning (geografisk nord med platsåtkomst) | env |
| Barometer | lufttryck och höjdförändring | env |
| GNSS: GPS, GLONASS, Galileo, QZSS, BeiDou | latitud, longitud, höjd, noggrannhet, hastighet och färdriktning | gps |
| Mikrofon (från 0.4) | tal till text, på enheten när det går; huvudet ser uppmärksamt ut medan du pratar | speech |
| Högtalare (från 0.4) | huvudets egen röst, med munnen i takt med ljudet och uttryck på rätt ställen | speech.say |
| Batteri och temperatur | batterinivå, laddning och temperaturläge | status |
Från 0.4 även mikrofonen och högtalaren: huvudet talar med egen röst och gör om det du säger till text. Används inte: närhetssensorn (den släcker skärmen och skulle dölja ansiktet) och ljussensorn (inget öppet API). iPhone 12 har ingen LiDAR, och OpenHead behöver ingen. Från 0.5, som tillval bara på Pro-modeller: LiDAR-djup för exakta avstånd och en 3D-karta av rummet.
| Ström | Takt | Fält | När |
|---|---|---|---|
imu | upp till 100 Hz | orientering (kvaternion), rotationshastighet, acceleration, sensortid | alltid |
faces | 15 Hz | id, riktning, höjdvinkel, storlek, säkerhet, ruta på skärmen, låst; avstånd med ARKit | lägena capture och sensing |
pose | upp till 60 Hz | position (m), orientering, spårningsläge och orsak | läget sensing (ARKit) |
gps | 1 Hz | latitud, longitud, höjd, noggrannhet, hastighet, färdriktning | från 0.3; när användaren tillåtit platsåtkomst |
env | upp till 10 Hz | lufttryck, höjdförändring, magnetfält, kompassriktning och noggrannhet | från 0.3; barometern efter åtkomst till Rörelse & fitness |
status | 1 Hz | batteri, laddning, temperaturläge, vy, tema, känsla, läge, ansikten, klienter | alltid |
log | när det händer | nivå, delsystem, meddelande | alltid (utvecklarläge för att läsa historiken) |
camera | upp till 10 Hz | liten JPEG-bild, bredd, höjd, front- eller bakkamera | från 0.5; lägena capture och sensing, ”Camera shared” på telefonen |
mesh | upp till 1 Hz | ändrade delar av rummets nät (LiDAR) | från 0.5; bara Pro-modeller, tillval |
Två kameralägen, eftersom ARKit äger kamerorna: capture visar frontkameran och hittar flera ansikten; sensing kör ARKit för huvudets position i rummet och följer ett ansikte med djupkameran.
Cockpit
Från 0.5 öppnar ett kommando en panel för huvudet i webbläsaren: vad kamerorna ser, alla sensorer, vad det ska säga, tema och humör. Inget att installera utöver Python-verktygen; sidan körs på din dator och pratar bara med ditt huvud.
Båda kamerorna
Video med låg upplösning, 160 till 640 pixlar, 1 till 10 bilder i sekunden. Läget capture visar frontkameran med ansiktena den hittar; läget sensing visar bakkameran som ARKit följer rummet med. Telefonen visar ”Camera shared” hela tiden någon tittar, och ingen bild sparas.
Prata genom den
Skriv vad huvudet ska säga, med markeringar som [happy] och [laugh], eller utgå från ett exempel: skämtet från filmen, en hälsning, en mötespåminnelse. Lyssna visar vad mikrofonen hör, ord för ord.
Din egen layout
Varje funktion är ett kort: kamera, tala, lyssna, uttryck och tema, status, ARKit-karta, IMU, kompass och lufttryck, GPS, ansikten, logg, LiDAR på Pro-modeller. Dra dem, lägg till och ta bort; webbläsaren minns din layout, och Reset layout tar tillbaka standardläget.
openhead cockpit --device 192.168.1.20 # eller: openhead viewer openhead sim --pro # prova utan telefon
Så fungerar det
Telefonen sitter liggande på roboten. Allt stannar i ditt lokala nätverk: inga konton, inget moln.
Montera och öppna
Sätt telefonen liggande på roboten och öppna appen. Ansiktet syns direkt.
Para en gång
En styrenhet på samma wifi hittar huvudet och ber om att paras; du skriver in den sexsiffriga koden som visas på skärmen.
Styr det
Uttryck, blick, tal, undertexter, bilder och video kommer som små JSON-kommandon över en WebSocket.
Kontrollera
I utvecklarläget visar skärmdumpar och loggar exakt vad huvudet gjorde, för dig eller en AI-agent.
Inställningar på enheten
- Håll fingret på ansiktet i 1,5 sekunder för att öppna dem.
- Namn och port, temat som visas när inget är anslutet, och hur telefonen är monterad.
- Se varje parad styrenhet och återkalla vilken som helst av dem.
- Utvecklarläget tillåter skärmdumpar, loggar och diagnostik över nätverket; låt det vara av på en robot som används.
Appen visar sina inställningar på engelska.
Byggd för utvecklare och AI-agenter
Protokollet är produkten: JSON över WebSocket med ett publicerat schema. Runt det finns:
- En Python-klient och kommandoradsverktyget
openhead. - En simulator för datorn som talar samma protokoll, så att du kan utveckla innan en servo rör sig.
- YAML-scenarier med referensbilder, som körs mot simulatorn och mot telefonen.
- En MCP-server, så att en AI-agent kan styra huvudet och kontrollera sitt arbete.
- Apache 2.0. Källkoden på GitHub.
# installera verktygen från Git-taggen uv add "openhead @ git+https://github.com/PatrikBichis/openhead@v0.4.0#subdirectory=python" # hitta huvudet och para (skriv koden från skärmen) openhead discover openhead pair --device 192.168.1.20 # få det att göra saker openhead emotion curious openhead subtitle "Hej! Jag skriver när jag inte kan prata." --mouth openhead show clip.mp4 --overlay face-corner openhead camera hunter --follow openhead watch faces -n 5
Använd det från en AI-agent
OpenHead har en MCP-server, så att en AI-agent kan styra huvudet och kontrollera sitt arbete: känslor, undertexter, kameran med HUD, vem som står framför, GPS och kompass, skärmdumpar. Den körs på din dator och pratar med telefonen över wifi. Du behöver uv och huvudets adress från appens inställningar (eller auto).
Claude Code
I en terminal:
claude mcp add openhead --scope user -- uvx --from "openhead[mcp] @ git+https://github.com/PatrikBichis/openhead@v0.4.0#subdirectory=python" openhead mcp --device 192.168.1.20
Claude Desktop
Settings → Developer → Edit Config (claude_desktop_config.json), starta sedan om. Om uvx inte hittas, ange hela sökvägen.
{
"mcpServers": {
"openhead": {
"command": "uvx",
"args": ["--from", "openhead[mcp] @ git+https://github.com/PatrikBichis/openhead@v0.4.0#subdirectory=python", "openhead", "mcp", "--device", "192.168.1.20"]
}
}
}
Codex CLI
I en terminal, eller i ~/.codex/config.toml:
codex mcp add openhead -- uvx --from "openhead[mcp] @ git+https://github.com/PatrikBichis/openhead@v0.4.0#subdirectory=python" openhead mcp --device 192.168.1.20 # or ~/.codex/config.toml [mcp_servers.openhead] command = "uvx" args = ["--from", "openhead[mcp] @ git+https://github.com/PatrikBichis/openhead@v0.4.0#subdirectory=python", "openhead", "mcp", "--device", "192.168.1.20"]
Cursor och Gemini CLI
Cursor: ~/.cursor/mcp.json. Gemini CLI: ~/.gemini/settings.json. Samma block som för Claude Desktop:
{
"mcpServers": {
"openhead": {
"command": "uvx",
"args": ["--from", "openhead[mcp] @ git+https://github.com/PatrikBichis/openhead@v0.4.0#subdirectory=python", "openhead", "mcp", "--device", "192.168.1.20"]
}
}
}
VS Code med GitHub Copilot
Agentläge, .vscode/mcp.json:
{
"servers": {
"openhead": {
"type": "stdio",
"command": "uvx",
"args": ["--from", "openhead[mcp] @ git+https://github.com/PatrikBichis/openhead@v0.4.0#subdirectory=python", "openhead", "mcp", "--device", "192.168.1.20"]
}
}
}
Över nätverket (HTTP)
För en agent på en annan dator: kör servern på robotens dator med en token. Utan --token lyssnar den bara på 127.0.0.1.
openhead mcp --http 0.0.0.0:8800 --token "$(openssl rand -hex 16)" --device 192.168.1.20 # Claude Code on the other machine claude mcp add --transport http openhead http://robot-pc.local:8800/mcp --header "Authorization: Bearer <token>"
Första gången: be agenten para med huvudet och läs upp den sexsiffriga koden från telefonen. Prova sedan ”Se nyfiken ut och skriv Hej som undertext”, ”Visa kameran med HUD:en hunter; hur många personer ser du?” eller ”Åt vilket håll pekar huvudet, och vad är lufttrycket?”
Frågor
Fungerar appen på egen hand?
Den visar ansiktet och håller sig levande med blinkningar och andning, men den är gjord för att styras: av robotens dator, ett skript eller en AI-agent i samma nätverk.
Vilka enheter stöds?
iPhone 12 eller nyare och iPad med iPadOS 17 eller senare. iPhone 12 är grundnivån som varje funktion byggs och testas för.
Samlar appen in data?
Nej. Inget lämnar ditt lokala nätverk och det finns inga konton, ingen analys och ingen reklam. Plats och sensorvärden går bara till de styrenheter du parat, och bara när de ber om dem. Läs integritetspolicyn.
Spelar kameran in eller skickar video?
Nej. Kameran körs bara när en parad styrenhet ber om det, och bilderna behandlas i telefonen och sparas eller skickas aldrig. Bara positioner och vinklar för ansikten lämnar telefonen, och ingen identifieras. Läs integritetspolicyn.
Kan jag använda det med ROS 2?
Ja, via en brygga byggd på Python-klienten. Huvudet vet inget om robotens kropp; roboten äger sin kinematik.