Hoe JBlanked Flipper Zero, Cardputer en PicoCalc met lokale AI verbindt via ZimaBoard 2

Eva Wong

IceWhale author

Eva Wong is de Technisch Schrijver en en vaste knutselaar bij ZimaSpace. Een levenslange geek met een passie voor homelabs en open-source software, zij is gespecialiseerd in het vertalen van complexe technische concepten naar toegankelijke, praktische handleidingen. Eva gelooft dat zelf-hosting leuk moet zijn, niet intimiderend. Met haar tutorials stelt ze de community in staat om hardware-setup te ontrafelen, van het bouwen van hun eerste NAS tot het beheersen van Docker-containers.

How JBlanked Connects Flipper Zero, Cardputer, and PicoCalc to Local AI with ZimaBoard 2 - Zima Store Online

Bedankt aan JBlanked voor het documenteren van een andere manier om lokale AI te integreren in de ontwikkeling van embeddedapparaten. In zijn volledige video maakt hij van ZimaBoard 2 een lokale Ollama-server en verbindt hij handheldapparaten, waaronder Cardputer-ADV, PicoCalc en Flipper Zero, met die gedeelde AI-omgeving.

In plaats van te proberen op elk klein apparaat rechtstreeks een groot taalmodel te draaien, splitst het experiment de werklast op: ZimaBoard 2 verwerkt de lokale AI-service, terwijl de handhelds fungeren als lichtgewicht ontwikkelinterfaces. JBlanked gebruikt vervolgens zijn open-source Picoware Agent om applicaties te maken, apparaatgegevens te bekijken en hardware te beheren via die lokale AI-verbinding.

Openbaarmaking over de samenwerking: Dit artikel is gebaseerd op de door JBlanked gedemonstreerde opstelling en de openbare documentatie voor Picoware en FlipperHTTP. Softwareversies, beschikbaarheid van AI-modellen, hardwarecompatibiliteit en lokale inferentieprestaties kunnen in de loop der tijd veranderen.

Het resultaat: één compacte thuisserver kan de AI-laag leveren voor verschillende maker-apparaten met beperkte middelen. De handheldhardware blijft zijn eigen firmware en interface draaien, terwijl rekenintensievere taken met taalmodellen door Ollama op de lokale server kunnen worden afgehandeld.

De lokale AI-opstelling in één oogopslag

Het project combineert een compacte x86-server met verschillende embeddedplatforms. In plaats van dezelfde softwarestack op elk apparaat te forceren, gebruikt JBlanked verschillende verbindingslagen, afhankelijk van wat elk apparaat ondersteunt.

Component	Rol in de opstelling	Belangrijk aandachtspunt
ZimaBoard 2	Fungeert als centrale lokale server waarop ZimaOS draait en die de AI-omgeving host.	De modelprestaties zijn afhankelijk van de volledige hardwareconfiguratie, niet alleen van de CPU van het board.
ZimaOS	Biedt de serveromgeving en App Store die worden gebruikt om Ollama te implementeren.	De applicatieconfiguratie en netwerktoegang moeten worden gecontroleerd voordat je de server voor gevoelige projecten gebruikt.
Ollama	Draait het taalmodel lokaal en reageert op verzoeken van verbonden apparaten.	Verschillende modellen hebben verschillende vereisten voor geheugen, opslag en accelerators.
NVIDIA GeForce RTX 3060	Verschijnt in de gedemonstreerde ZimaOS-omgeving als een beschikbare GPU met 12 GB VRAM.	De GPU die in de video wordt getoond, maakt deel uit van de gedemonstreerde configuratie en moet worden meegewogen bij het beoordelen van de inferentieresultaten.
Cardputer-ADV	Draait Picoware en gebruikt de Agent-interface om met de lokale AI-server te communiceren.	Het handheldapparaat blijft de interface; het taalmodel zelf draait op de server.
PicoCalc	Gebruikt Picoware als andere client voor dezelfde lokale AI-workflow.	Beschikbare functies zijn afhankelijk van de huidige Picoware-build en de apparaatconfiguratie.
Flipper Zero	Gebruikt een netwerkverzoekpad om met de lokale AI-service te communiceren.	Voor netwerkcommunicatie is een compatibele bridge of ontwikkelboard met Wi-Fi vereist.

Waarom ZimaBoard 2 gebruiken als AI-server?

Het interessante aan dit project is niet alleen dat ZimaBoard 2 een AI-toepassing kan uitvoeren. Het is vooral de manier waarop het board de architectuur van kleine embeddedprojecten verandert.

Apparaten zoals Cardputer, PicoCalc en Flipper Zero zijn ontworpen met het oog op draagbaarheid en gespecialiseerde embedded hardware. Ze zijn geschikt voor interfaces, scripts, firmware-experimenten, netwerktools en draagbare toepassingen, maar hun ingebouwde bronnen zijn veel beperkter dan die van een conventioneel AI-werkstation.

De ZimaBoard 2 Mini-thuisserver biedt een afzonderlijke x86-host met bekabelde netwerkverbinding, aansluitmogelijkheden voor opslag en PCIe-uitbreiding. Daardoor kunnen de handheldapparaten klein blijven terwijl de zwaardere serverbelasting elders wordt uitgevoerd.

In de workflow van JBlanked draait ZimaBoard 2 ZimaOS en levert Ollama de lokale taalmodelservice. Zodra die service beschikbaar is op het lokale netwerk, kunnen compatibele apparaten ermee communiceren zonder dat elk handheldapparaat zelf over voldoende rekenkracht en geheugen hoeft te beschikken om het model te hosten.

De video toont ook een belangrijk detail over de gedemonstreerde serverconfiguratie: terwijl Ollama draait, meldt het ZimaOS-systeemdashboard een NVIDIA GeForce RTX 3060 met 12 GB VRAM. Dat betekent dat de in de demo getoonde prestaties moeten worden gezien in de context van een lokale server met GPU, en niet als een test van een CPU-only ZimaBoard 2.

Ollama draait in ZimaOS, waarbij in het systeemdashboard een NVIDIA GeForce RTX 3060 en 12 GB VRAM zichtbaar zijn

Ollama draait binnen de ZimaOS-omgeving. Het systeemdashboard dat erachter zichtbaar is, meldt een NVIDIA GeForce RTX 3060 en 12 GB VRAM. Dit toont aan dat de gedemonstreerde lokale AI-server GPU-versnelling beschikbaar heeft.

Hoe de lokale AI-verbinding werkt

Het basisontwerp kan worden begrepen als drie lagen:

Serverlaag: ZimaBoard 2 draait ZimaOS en host Ollama.
Agent- of netwerklaag: Picoware of de netwerkstack van de Flipper verzendt aanvragen tussen het ingebedde apparaat en de lokale server.
Apparaatlaag: Cardputer-ADV, PicoCalc of Flipper Zero biedt de fysieke interface en voert apparaatspecifieke acties uit.

Deze scheiding is nuttig, omdat het taalmodel niet rechtstreeks op elk afzonderlijk hardwareonderdeel hoeft te draaien. De firmware op elk apparaat kan de ondersteunde functies beschikbaar stellen, terwijl de server de modelmogelijkheden levert die worden gebruikt om aanvragen te interpreteren of te helpen bij ontwikkeltaken.

Cardputer-ADV en PicoCalc gebruiken Picoware Agent

Het Picoware-project van JBlanked is een opensourcefirmwareomgeving voor Cardputer-ADV, PicoCalc, Flipper Zero en andere apparaten op basis van ESP32 of Raspberry Pi Pico.

Voor dit experiment is Picoware Agent het belangrijkste onderdeel. De Agent biedt een door een taalmodel aangestuurde interface met verschillende gebruikscontexten, in plaats van alleen als generiek chatvenster te fungeren.

De gedocumenteerde modi omvatten algemene chat, een App Creator voor het maken of bewerken van Picoware-applicaties en apparaatbeheerfuncties die met informatie en opdrachten kunnen werken. Door deze mogelijkheden te verbinden met de Ollama-instantie op de lokale server, krijgt het handheld apparaat een AI-ondersteunde ontwikkelworkflow, terwijl de modelbelasting niet op het kleine apparaat terechtkomt.

Flipper Zero verzendt aanvragen naar de lokale AI-server

De Flipper Zero hanteert een ander interactiepatroon. In de video laat JBlanked zien hoe het apparaat via een wifi-ontwikkelbord dat aan de Flipper is bevestigd een gestructureerde aanvraagpayload voor het lokale model voorbereidt.

De payload die op het scherm wordt weergegeven, bevat een modelfield voor qwen3.5:9b. Dit illustreert de taakverdeling duidelijk: de Flipper bereidt de aanvraag voor en verzendt deze, terwijl het geselecteerde taalmodel op de krachtigere lokale server draait.

Flipper Zero voert een lokale AI-aanvraagpayload in voor het qwen3.5:9b-model, met een bevestigd wifi-ontwikkelbord

Flipper Zero bereidt een aanvraagpayload voor de lokale AI-service voor. Op het scherm staat het modelfield ingesteld op qwen3.5:9b, terwijl er boven op het apparaat een ontwikkelbord met wifi-ondersteuning is bevestigd.

Dit onderscheid is belangrijk. De Flipper draait niet lokaal het volledige taalmodel. Zijn rol is het bieden van de draagbare interface en netwerkverbinding, terwijl Ollama en het geselecteerde model op de server worden uitgevoerd.

Wat kan de lokale AI Agent eigenlijk doen?

Een handheld-apparaat verbinden met een LLM wordt interessanter wanneer het model meer kan doen dan een vraag beantwoorden. JBlanked demonstreert de AI-server als onderdeel van een workflow voor embeddedontwikkeling.

Picoware-apps maken

Picoware bevat een App Creator-context voor zijn AI Agent. Hiermee kan een ontwikkelaar in natuurlijke taal een applicatie of wijziging beschrijven en het model helpen de bijbehorende Picoware-applicatie te maken of te bewerken.

In de demonstratie wordt de App Creator gevraagd een eenvoudige applicatie te bouwen die bij het starten de begroeting „hello from youtube” weergeeft. De Agent geeft een gestructureerde beschrijving van het gewenste gedrag en van de werking van de interface.

PicoCalc met Picoware App Creator voor een „hello from youtube”-applicatie naast Flipper Zero en Cardputer-ADV

Picoware's App Creator draait op PicoCalc. De Agent werkt aan een aanvraag voor een applicatie die „hello from youtube” weergeeft, terwijl Flipper Zero en Cardputer-ADV naast het apparaat liggen.

Dat kan de afstand tussen een idee en een prototype verkleinen, vooral op een apparaat waarop het anders omslachtig zou zijn om rechtstreeks op het kleine scherm grote hoeveelheden broncode te typen en te bewerken.

Door AI gegenereerde code moet nog steeds worden gecontroleerd. Output die aannemelijk lijkt, kan onjuiste API's, onvolledige foutafhandeling, onveilige aannames of gedrag bevatten dat niet overeenkomt met de doelhardware.

Firmware- en ontwikkelinformatie inspecteren

De Agent-workflow kan ook worden gebruikt als ontwikkelassistent. In plaats van het handheld-apparaat als een conventionele chatclient te behandelen, kan het systeem lokale modelreacties combineren met informatie die door het apparaat en zijn firmware beschikbaar wordt gesteld.

Deze aanpak is vooral nuttig op kleine schermen, waar het handmatig doornemen van logboeken, documentatie of commando-uitvoer trager kan zijn dan de Agent vragen om een specifieke aanvraag te interpreteren.

Het apparaat beheren

Het Agent-framework van Picoware bevat ook functies voor apparaatbeheer. Het model kan werken met tools die door de firmware beschikbaar worden gesteld, in plaats van alleen tekst terug te geven die de gebruiker handmatig moet uitvoeren.

In één voorbeeld in de video wordt gevraagd: „hoeveel netwerken zijn er in de buurt”. De apparaatbeheerder antwoordt dat er zes wifi-netwerken in de buurt beschikbaar zijn. Daarmee laat hij zien dat de Agent apparaatgegevens kan gebruiken om een praktische vraag te beantwoorden, in plaats van alleen te vertrouwen op algemene modelkennis.

PicoCalc Picoware-apparaatbeheerder meldt zes wifi-netwerken in de buurt naast Flipper Zero en Cardputer-ADV

Picoware Device Manager op PicoCalc beantwoordt de vraag: “hoeveel netwerken zijn er in de buurt?” De interface meldt zes nabijgelegen wifi-netwerken en laat zien hoe de agent lokale AI kan combineren met informatie die van het apparaat afkomstig is.

Hierin verschilt een AI-agent van een normale chatbot. Het taalmodel levert de interpretatie- en instructielaag, terwijl de firmware bepaalt welke apparaatbewerkingen en informatiebronnen daadwerkelijk beschikbaar zijn.

Waarom een gedeelde lokale AI-server nuttig is voor kleine apparaten

De architectuur pakt een fundamentele mismatch in embedded AI-projecten aan: de meest draagbare apparaten beschikken vaak over de minste rekenkracht voor taalmodellen.

Een gedeelde server verandert die afweging. Een ontwikkelaar kan de fysieke interface in een apparaat ter grootte van een zak houden en het via het netwerk toegang geven tot een krachtigere lokale machine.

AI rechtstreeks op de handheld uitvoeren	ZimaBoard 2 gebruiken als AI-server
De rekenkracht is beperkt tot de embeddedprocessor.	De AI-verwerking wordt verplaatst naar een speciale x86-server en de beschikbare acceleratorhardware daarvan.
De modelgrootte wordt sterk beperkt door het apparaatgeheugen.	De server kan zijn eigen systeemgeheugen, GPU-VRAM en opslag gebruiken voor modelbestanden.
Elk apparaat heeft een eigen AI-implementatie nodig.	Meerdere clients kunnen één lokale inferentieservice delen.
Voor het bijwerken van het model zijn mogelijk wijzigingen op elk apparaat nodig.	Het model kan centraal aan de serverzijde worden beheerd.
De handheld moet zowel de interface- als inferentietaken verwerken.	De handheld kan zich richten op de interface, firmware, netwerken en apparaatspecifieke functies.

Eén AI-backend, meerdere makerapparaten

Een van de nuttigste ideeën in het experiment van JBlanked is dat ZimaBoard 2 niet aan één frontend gebonden is. PicoCalc en Cardputer-ADV kunnen via Picoware deelnemen, terwijl Flipper Zero via zijn eigen netwerkworkflow met dezelfde lokale AI-omgeving kan communiceren.

Hierdoor wordt de server een herbruikbaar onderdeel van een groter makerlab. In plaats van voor elke nieuwe microcontroller of draagbare computer een nieuwe AI-omgeving op te bouwen, kunnen ontwikkelaars de inferentieservice gecentraliseerd houden en zich richten op het bouwen van de clientintegratie die voor elk apparaat het meest geschikt is.

Het concept kan experimenteren ook vereenvoudigen. Een model kan op de server worden gewijzigd zonder de handheld te vervangen, terwijl de firmware op de handheld onafhankelijk van de AI-runtime kan worden doorontwikkeld.

Wat dit experiment wel en niet aantoont

De build van JBlanked is een nuttige demonstratie van hoe lokale AI kan worden geïntegreerd in embeddedontwikkeling, maar het is belangrijk om de architectuur te onderscheiden van garanties voor prestaties of beveiliging.

Het experiment toont aan	Het geeft geen garantie
De ZimaBoard 2 kan fungeren als lokale Ollama-host voor clients met embeddedapparaten.	Zonder de GPU die in de gedemonstreerde omgeving wordt getoond, worden dezelfde prestaties behaald.
De ZimaOS-demoomgeving herkent een NVIDIA GeForce RTX 3060 met 12 GB VRAM.	Elk model past in 12 GB VRAM of werkt met dezelfde snelheid.
PicoCalc en Cardputer-ADV kunnen Picoware gebruiken als onderdeel van een lokale AI-workflow.	Elke Picoware-functie of elk model werkt identiek op elk ondersteund apparaat.
De Flipper Zero kan via een netwerkverbonden configuratie gestructureerde verzoeken naar de lokale AI-server sturen.	De Flipper Zero zelf voert het taalmodel uit.
Een AI-agent kan helpen bij het maken van apps en workflows voor apparaatbeheer.	Door AI gegenereerde code, interpretaties of opdrachten zijn niet automatisch correct of veilig.
Eén lokale server kan meerdere interfaces voor kleine apparaten ondersteunen.	Een lokaal netwerk biedt niet automatisch authenticatie, isolatie of volledige privacy.

Lokaal betekent niet zonder configuratie

Ollama lokaal uitvoeren neemt de vereiste weg om elk inferentieverzoek naar een gehoste chatbotservice te sturen, maar het complete systeem vereist nog steeds een normale planning van server en netwerk.

De eerste model- en applicatiepakketten moeten worden geïnstalleerd, de handheldapparaten hebben netwerktoegang tot de server nodig en elke blootgestelde service moet worden geconfigureerd met de beoogde netwerkgrenzen in gedachten. Ontwikkelaars moeten ook precies controleren welke tools een AI-agent mag aanroepen voordat ze apparaatbeheerfunctionaliteit inschakelen.

Ook de configuratie van de accelerator is van belang. De RTX 3060 die zichtbaar is in het ZimaOS-dashboard van JBlanked heeft 12 GB VRAM. Bij de keuze van een model moet daarom nog steeds rekening worden gehouden met het beschikbare GPU-geheugen, de runtime-ondersteuning en de prestatievereisten van de beoogde werklast.

Voor toepassingen waarbij code wordt gegenereerd, zijn back-ups of versiebeheer bijzonder belangrijk. Als een door AI ondersteunde bewerking een onbruikbare applicatie of firmwareconfiguratie oplevert, heeft de ontwikkelaar een bekende werkende staat nodig om naar terug te keren.

Voor wie is een dergelijke configuratie geschikt?

Deze architectuur is vooral interessant voor ontwikkelaars en makers die al met embeddedapparaten werken, maar willen experimenteren met lokale LLM's zonder van elk project een integratie met een cloud-API te maken.

Dit kan nuttig zijn voor:

Cardputer- en PicoCalc-ontwikkelaars die Picoware-applicaties bouwen.
Flipper Zero-gebruikers die experimenteren met netwerkverbonden tools.
Embeddedontwikkelaars die AI-assistentie dicht bij hun testhardware willen.
Homelabgebruikers die op zoek zijn naar een andere praktische werklast voor een lokale server.
Makers die meerdere energiezuinige apparaten één AI-backend willen laten delen.

Een cloud-AI-service kan nog steeds eenvoudiger zijn voor gebruikers die slechts af en toe chatten of code genereren en geen server willen onderhouden. Een groter workstation of een krachtiger systeem met GPU kan ook geschikter zijn wanneer modelgrootte en inferentiesnelheid de belangrijkste prioriteiten zijn.

De aanpak met ZimaBoard 2 wordt nog aantrekkelijker wanneer het doel is om de AI-service binnen hetzelfde homelab te houden en die service beschikbaar te maken voor meerdere onafhankelijke projecten.

Bouw een lokale AI-hub voor je makerlab

Het project van JBlanked laat een interessante richting voor lokale AI zien: vraag niet of elk klein apparaat een taalmodel kan uitvoeren, maar of die apparaten een gedeeld model kunnen gebruiken dat ergens draait waar het daar beter voor geschikt is.

Met ZimaOS waarop Ollama draait op ZimaBoard 2, Picoware dat een AI-ondersteunde interface biedt voor apparaten zoals PicoCalc en Cardputer-ADV, en een netwerkgeschikte workflow die Flipper Zero in dezelfde omgeving brengt, wordt het systeem een flexibele lokale AI-hub voor experimenten met embedded apparaten.

De vier demonstraties laten ook zien waarom de server als compleet systeem moet worden geëvalueerd. De handheldapparaten leveren de interfaces en apparaatspecifieke functies, Ollama levert de modellag voor het uitvoeren van modellen en de GPU die zichtbaar is in ZimaOS levert extra rekenkracht voor de lokale AI-workload.

Bekijk voor een andere kijk op wat lokale modellen op hetzelfde platform kunnen doen de test van de lokale AI-assistent op ZimaBoard 2, waarin de relatie tussen compacte serverhardware, modelgrootte, opslag en AI-workloads wordt onderzocht.

Bekijk JBlankeds volledige video om de opstelling en apparaatworkflow rechtstreeks te bekijken, of ontdek het Picoware-project op GitHub als je wilt begrijpen hoe de Agent en ondersteunde apparaten op elkaar aansluiten.

Wil je zien wat andere bouwers doen met compacte servers, lokale AI en ongebruikelijke hardware? Word lid van de ZimaSpace Discord-community om meer builds te ontdekken, opstellingen te vergelijken en je eigen experimenten te delen.