Räknare för GPIO-strömbudget

Se hur mycket ström dina förbrukare drar mot kortets publicerade gränser per pinne, för alla pinnar, på 3,3 V och på 5 V — och vad du behöver lägga till när du hamnar över.

Kort

Det du vill koppla in

Flera komponenter på samma pinne? Skriv in dem som en enda förbrukare och lägg ihop deras strömmar — då behöver kontrollen per pinne inte gissa hur du fördelar dem.

Förbrukare 1 — ström per styck

Från komponentens datablad, eller uppmätt.

Hur många

En GPIO-pinne per styck.

Kopplad till

Förbrukare 2 — ström per styck

Hur många

Hur många av dessa som hänger på den pinnen.

Kopplad till

Avancerat — 500 mA nätaggregat · 20 % marginal

Ditt 5 V-aggregat klarar

Fylls i utifrån kortet du valde. Skriv ditt eget värde om du vet det.

Säkerhetsmarginal

Raspberry Pi Pico / Pico W (RP2040) — fyra budgetar kontrollerade

Inom alla gränser — snävast är en pinne på 10 av 12 mA

Din säkerhetsmarginal på 20 % lägger varningslinjen på 9,6 mA; själva gränsen går vid 12 mA.

Alla GPIO-pinnar tillsammans · specifikation

30 mA av 50 mA

20 mA kvar

30 mA av budgeten på 50 mA för alla pinnar

Den hårdast belastade pinnen · specifikation

10 mA av 12 mA

2 mA kvar

3,3 V-pinnen · rekommenderat

20 mA av 300 mA

280 mA kvar

3 GPIO-pinnar används

Dina förbrukare

Förbrukare	Per styck (mA)	Hur många	Kopplad till	Totalt (mA)	Status
Förbrukare 1	10	3	GPIO-pinne	30	snävt
Förbrukare 2	20	1	3,3 V-pinnen	20	bra

GPIO-strömbudget — Raspberry Pi Pico / Pico W (RP2040) Utfall: Inom alla gränser — snävast är en pinne på 10 av 12 mA Per GPIO-pinne | 12 mA | Specifikationsgräns — över den håller utspänningen inte längre specifikationen | 10 mA | 2 mA kvar Alla GPIO-pinnar tillsammans | 50 mA | Specifikationsgräns — över den håller utspänningen inte längre specifikationen | 30 mA | 20 mA kvar 3,3 V-pinnen | 300 mA | Rekommenderat maxvärde — tillverkarens råd, inte en specifikation | 20 mA | 280 mA kvar Ditt 5 V-aggregat | 500 mA | Ditt aggregat, inte kortet | 0 mA | 500 mA kvar Säkerhetsmarginal: 20 %

Det här kortets budgetar

Budget	Gräns	Vilken sorts gräns	Du använder	Kvar
Per GPIO-pinne	12	Specifikationsgräns — över den håller utspänningen inte längre specifikationen	10	2
Alla GPIO-pinnar tillsammans	50	Specifikationsgräns — över den håller utspänningen inte längre specifikationen	30	20
3,3 V-pinnen	300	Rekommenderat maxvärde — tillverkarens råd, inte en specifikation	20	280
Ditt 5 V-aggregat	500	Ditt aggregat, inte kortet	0	500

Värden hämtade ur dokumentationen för Raspberry Pi Pico / Pico W (RP2040). Ett tankstreck betyder att tillverkaren inte publicerar något — den budgeten visas men jämförs inte.

Uträkningen, rad för rad

GPIO-pinnar: 3 × 10 = 30 mA fördelat på 3 pinnar

3,3 V-pinnen: 1 × 20 = 20 mA

5 V-pinnen: ingenting = 0 mA

Snävast: en pinne på 10 av 12 mA — 2 mA kvar

Vad varje kort klarar att leverera

Kort	Per pinne	Sort	Högsta drivsteg	Alla pinnar tillsammans	3,3 V-pinnen	Anmärkning
Raspberry Pi 5 / 500	16	säkert	12	50	inte publicerat	De 16 mA och 50 mA är Raspberry Pis allmänna paddvägledning; inget dokument om BCM2712 eller RP1 publicerar någon ström per pinne eller totalt. RP1:s drivsteg slutar på 12 mA.
Raspberry Pi 4 Model B / 400	16	säkert	8	50	inte publicerat	BCM2711:s paddar börjar på 4 mA drivsteg och går upp till 8 mA — hälften mot de äldre modellerna.
Raspberry Pi 3 (B / B+ / A+)	16	säkert	16	50	inte publicerat	Paddarna i BCM2835-familjen börjar på 8 mA drivsteg och går upp till 16 mA.
Raspberry Pi Zero 2 W	16	säkert	16	50	inte publicerat	RP3A0 använder paddar ur BCM2835-familjen: 8 mA drivsteg som standard, 16 mA som maximum.
Raspberry Pi Zero / Zero W	16	säkert	16	50	inte publicerat	BCM2835:s paddar: 8 mA drivsteg som standard, 16 mA som maximum.
Raspberry Pi Pico / Pico W (RP2040)	12	specifikation	12	50	300	RP2040:s 50 mA gäller GPIO- och QSPI-pinnarna tillsammans, och separat för levererad och upptagen ström. En pinne startar på 4 mA drivsteg, inte 12.
Raspberry Pi Pico 2 / Pico 2 W (RP2350)	12	specifikation	12	100	300	RP2350 delar upp budgeten: 100 mA över GPIO-pinnarna och 20 mA över QSPI, i vardera riktningen. En pinne startar fortfarande på 4 mA drivsteg.
Arduino Uno R3 / Nano (ATmega328P)	40	absolut max	20	200	50	40 mA och 200 mA är absoluta maxvärden, inte driftvärden. Portgrupperna slår till tidigare: 150 mA sammanlagt per grupp som levererar ström (det finns två) och 100 mA per grupp som tar upp ström (det finns tre).
ESP32 dev board (ESP32-WROOM-32)	40	specifikation	40	1 200	inte publicerat	De 1200 mA är ett absolut maxvärde för belastningstoppar, inte en budget — den verkliga taknivån är utvecklingskortets regulator och USB-porten. Strömmen per pinne sjunker dessutom från ungefär 40 mA mot ungefär 29 mA ju fler pinnar i samma domän som levererar ström samtidigt.

Varje värde hämtat ur tillverkarens eget dokument, kontrollerat 2026-09-17. En cell där det står ”inte publicerat” är en som tillverkaren inte anger.

Det här täcker kontrollen inte

Ström som går in i en pinne. Det är en fråga om klampdioderna i databladet, inte om aritmetik.
Start-, blockerings- och transientströmmar. En motor eller en stor kondensator drar långt mer i ögonblicket den startar.
PWM-pulskvot. Paddet ser toppvärdet, så att dimma en lysdiod sänker inte det den här sidan kontrollerar.
Samtidig omkoppling samt termiska gränser och kapselgränser. Raspberry Pi skriver att de beror på ditt kort, din avkoppling och din last och ligger utanför deras kontroll.
Vad varje komponent drar. Milliamperen skriver du in själv: här finns ingen komponentlista, eftersom inte ens WS2812B:s berömda 60 mA står i dess eget datablad.
Resistorvärden, lysdiodens framspänning och Ohms lag.
Batteritid, nätaggregatets verkningsgrad och spänningsfall i kabeln.
HAT-kortens effektförhandling och USB-uppräkning.

Kortens värden kontrollerade 2026-09-17

Varje värde per pinne, för alla pinnar och per matningsskena är hämtat ur tillverkarens dokument som anges under Källor. Ingenting på den här sidan är en uppskattning från communityn.

Uppdaterad: 18 september 2026

GPIO-strömkalkylator. Per pinne, alla pinnar, 3,3 V-pinnen och ditt 5 V-aggregat.

En GPIO-strömkalkylator ställer dina förbrukare mot de fyra gränser kortet publicerar och pekar ut den som tar slut först. Den skriver ut vilken sorts gräns det är och sätter ett streck där tillverkaren inte publicerar något värde alls.

Vad är en strömbudget för GPIO-pinnar?

Fyra tal avgör om ett bygge får plats på ett kort: vad en enskild GPIO-pinne får lämna ifrån sig, vad alla GPIO-pinnar tillsammans får lämna, vad som får hänga på 3,3 V-pinnen på stiftlisten, och vad som blir kvar av ditt 5 V-aggregat när kortet har försörjt sig självt. Kopplingen måste klara alla fyra, och kortet ger vika vid den gräns dina förbrukare når först.

De fyra talen är inte av samma sort, och sorten avgör hur nära du får gå. Raspberry Pis 16 mA per pinne är en säker ström: paddarna är konstruerade för den siffran, och under den skadar du inte kretsen. Samma dokument lägger till meningen som nästan varje sammanfattning kortar bort, att det därutöver inte finns någon garanterad högsta säker ström. Picons 12 mA är en specifikationsgräns: över den leder pinnen vidare, och det som slutar stämma är utspänningen. Arduino Unos 40 mA per pinne och 200 mA genom VCC eller GND är absoluta maxvärden — Microchip trycker dem under varningen att belastning utöver de listade värdena kan ge bestående skada, alltså siffror att konstruera bort från och inte budgetar att göra av med. Och Picons 300 mA på 3,3 V-pinnen är ett rekommenderat maxvärde, ett råd från Raspberry Pi och ingen mätning.

På svenska är det en siffra till som rör sig, och den finns inte i något dokument. På Svenska ElektronikForumet skriver peoy i tråden om relästyrning (20 juni 2022) att strömmen per reläpinne är uppmätt till ”strax under 4mA” och frågar sig om det ”går det över PI:ns gräns på max 51mA på alla pinnar tillsammans”. Sex år tidigare, i SweClockers tråd ”raspberry pi gpio turtorial” (22 augusti 2016), sammanfattar bardbard samma sak: ”du får belasta 1 pinne max 16mA eller hela GPIO max 51mA”. Det Raspberry Pi faktiskt publicerar står i en enda mening på sidan om strömförsörjning: ”Combined, the GPIO pins can draw 50mA safely; each pin can individually draw up to 16mA”. Femtio, inte femtioett, och siffran är en säker ström med en namngiven sort bakom sig. Den extra milliamperen kommer ur en multiplikation. Paddokumentet skriver att 3,3 V-matningen konstruerades för ungefär 3 mA per GPIO-pinne, och 3 mA gånger de 17 GPIO som satt på den gamla 26-poliga stiftlisten blir 51; gånger dagens 26 blir det 78. Ingen av produkterna är en publicerad gräns för någonting. En milliampere ändrar inget bygge, men skillnaden mellan en publicerad säker ström och en multiplikation är vad de fyra kontrollerna finns till för att hålla isär.

Hur en krets fördelar summan över sina pinnar byter dessutom med kiselgenerationen, och där spricker en tumregel så fort du byter kort. RP2040, kretsen i första Picon, håller summan av allt som dess GPIO- och QSPI-pinnar levererar på 50 mA, med en andra, fristående budget på 50 mA för allt de tar upp. Båda värdena står i tabell 625 i RP2040-databladet, tillsammans med de 12 mA per pinne som där är villkoret på raderna för V_OH och V_OL. RP2350 i Pico 2 delar upp det: 100 mA över GPIO-pinnarna plus 20 mA för QSPI, återigen åt varje håll. Två kort ur samma familj, samma 12 mA per pinne, samma 26 utdragna GPIO — och två olika svar på frågan hur många lysdioder som får plats. På svenska står den uppdelningen ingenstans. Electrokits svenska produktsida för Pico 2 radar upp femton specifikationsrader, från klockfrekvens, SRAM och flash till PIO-enheter, UART, SPI, I2C, PWM, ADC, matningsspänning 1,8–5,5 V och drifttemperatur, och inte en enda av dem bär ett milliampere.

Vissa budgetar är helt enkelt inte publicerade, och att säga det rakt ut är värt mer än att fylla hålet. För 3,3 V-pinnarna på en Raspberry Pis stiftlist anger inget dokument från Raspberry Pi någon gräns. Paddokumentets 3 mA per GPIO-pinne beskriver vad paddarna själva drar ur 3,3 V-matningen, inte vad pinnen på listen kan lämna. I stället cirkulerar två andra tal: pinout.xyz anger 500 mA för modellerna från B+ och framåt och skriver i samma stycke att det i brist på dokumentation och mätningar är en tumregel, medan de 50 mA som också citeras beskriver de tidiga kortens regulator. Den här kalkylatorn skriver ett streck där, håller kontrollen utanför beskedet och säger det på kortet. Ett streck är varken ett godkänt eller en nolla.

En sista skillnad räddar kort: ett drivsteg är ingen strömbegränsning. Stegen 2, 4, 8 och 12 mA på ett RP2040-padd, och stegen från 2 till 16 mA på en Raspberry Pi, bestämmer hur hårt pinnen drar — alltså den ström under vilken utgången fortfarande håller sin spänningsspecifikation. Häng 16 mA på ett padd som står på 4 mA och de 16 mA går fram: spänningen sjunker, och på en Raspberry Pi överlever kretsen därför att 16 mA fortfarande ligger inom den säkra strömmen. En Pico-pinne vaknar för övrigt på steget 4 mA och inte på 12. RP2350-databladet säger samma sak om sin egen tabell på en rad: värdena är inga hårda gränser och betyder inte att pinnen alltid levererar det inställda antalet milliampere.

Ordlistan: svenskan här, raden i det engelska databladet

Säker ström

En ström under vilken tillverkaren säger att du inte skadar kretsen. Raspberry Pis paddar är konstruerade för 16 mA på den grunden. I dokumentationen heter avsnittet ”Safe current”, och det är den enda av de fyra sorterna som handlar om skada i stället för om spänningar. Ovanför siffran finns ingen brant, utan ett område där tillverkaren inte lovar något.

Specifikationsgräns

En ström över vilken pinnen fortsätter att fungera elektriskt medan utspänningen inte längre når det publicerade värdet. Picons 12 mA per pinne och ESP32:ans 40 mA är av den sorten. I ett engelskt datablad läser du den på raderna I_OH och I_OL under ”DC Characteristics”, alltid med spänningsvillkoret (V_OH, V_OL) bredvid. För ditt bygge betyder det att logiknivåerna går sönder före hårdvaran.

Absolut maxvärde

Ett belastningsvärde, tryckt under varningen att ett överskridande kan ge bestående skada. Arduino Unos 40 mA per pinne och 200 mA genom VCC eller GND, och ESP32:ans 1 200 mA sammanlagt, är sådana. Tabellen heter ”Absolute Maximum Ratings” och brukar följas av meningen att normal drift vid de villkoren inte är underförstådd. Hur ett sådant värde tas fram syns i Espressifs egen fotnot till de 1 200 mA: kretsen visade sig fullt funktionsduglig efter att alla dess I/O-pinnar hållits höga mot jord i 24 timmar i sträck vid 25 °C. Det beskriver ett prov kretsen ska överleva, inte ett läge den ska köras i.

Rekommenderat maxvärde

Tillverkarens råd i stället för en mätt specifikation. Picons 300 mA på 3,3 V-pinnen och Unos 50 mA på sin är båda av den sorten. De står som löpande text i dokumentet och inte som en tabellrad, och det är precis därför de försvinner först när någon sammanfattar.

Drivsteg

En inställning i paddet som väljer hur hårt utgången drar: 2, 4, 8 eller 12 mA på ett RP2040 eller RP2350, och en stege från 2 till 16 mA på en Raspberry Pi som halveras på 4-seriens kretsar. Det är aldrig en begränsare. I kretsens register är det fältet DRIVE i PADS_BANK0, och båda Pico-kretsarna vaknar på steget 4 mA.

Att leverera och att ta upp

Att leverera är ström som går ut ur pinnen till lasten; att ta upp är ström som går in i pinnen från en last som hänger på plus. RP2040 publicerar en egen budget på 50 mA åt vardera hållet, så tio lysdioder som pinnarna levererar till plus tio som de tar upp går igenom där tjugo levererade faller. Den här kalkylatorn modellerar inte riktningen: den frågar aldrig efter den och summerar allt som hänger på GPIO-pinnarna mot en enda gräns, vilket är den strängare läsningen.

QSPI-pinnar

De pinnar som ett RP2040 eller RP2350 når sitt flashminne med. RP2040 räknar dem inom samma 50 mA som GPIO; RP2350 ger dem egna 20 mA vid sidan av GPIO-pinnarnas 100 mA. De sticker inte ut ur Picons kant, men de äter ur samma budget, och därför tar en Picos summa slut tidigare än det ser ut när man bara räknar de pinnar man ser.

3,3 V-pinnen

Den reglerade 3,3 V-utgången på stiftlisten, som små moduler och sensorer matas från. Dess budget kommer från kortets regulator och inte från kretsens paddar, och därför publicerar vissa kort ett värde (300 mA på en Pico, 50 mA på en Uno) medan andra inte publicerar något alls.

Säkerhetsmarginal

Den andel under varje publicerad gräns där kalkylatorn börjar kalla en kontroll snäv: 0, 10, 20 eller 30 %, med 20 % som förval. Vid 20 % blir en Pico-pinne gul redan vid 9,6 mA mot sin gräns på 12 mA. Marginalen finns för att svälja komponenttolerans, matningsspänning och temperatur, som alla flyttar den verkliga strömmen runt siffran du skrev in.

Kortets egen förbrukning

Vad ett kort drar åt sig självt innan du kopplat in något, publicerat av Raspberry Pi modell för modell: 800 mA på Pi 5-raden och på Pi 4-raden, 150 mA på raden för Zero / Zero W. Kalkylatorn drar bort det från ditt aggregat för att få 5 V-budgeten, och där en rad täcker flera modeller bär den det högsta publicerade värdet av dem den nämner.

Nio siffror som går runt på svenska — och vad dokumenten säger

”51 mA för alla pinnar tillsammans.” Talet står i två oberoende svenska trådar: hos peoy på Svenska ElektronikForumet (juni 2022) och hos bardbard på SweClockers (augusti 2016). Raspberry Pi publicerar 50 mA, i klartext på sin sida om strömförsörjning, som en säker ström. De 51 kommer ur en multiplikation: 3 mA per GPIO-pinne, som paddokumentet anger för 3,3 V-matningens konstruktion, gånger de 17 GPIO som fanns på den gamla 26-poliga stiftlisten. Båda trådarna ger för övrigt rätt råd i sak — det är härkomsten som saknas, och den är det enda någon kan slå upp.
Läsa 50 mA som ett ungefär. På paddbacken.se, en av få svenska genomgångar som faktiskt skriver ut en siffra, står det att ”maximal ström man kan ta ut från signalpinnarna på Raspberry Pi (GPIO) ligger runt 50mA”. Rådet i samma artikel är helt rätt, med NPN-transistor och basmotstånd per relä. Men 50 mA ligger inte ”runt” någonting: det är ett publicerat värde med en sort fäst vid sig.
Läsa Picons 50 mA som ett värde per pinne. Det är summan av allt som RP2040:ans GPIO- och QSPI-pinnar levererar samtidigt, med en andra, fristående budget på 50 mA för allt de tar upp. Per pinne är det 12 mA, och båda talen står i samma tabell i databladet, den 625:e: summan på egna rader som IIOVDD_MAX och IIOVSS_MAX, de 12 mA som villkoret på raderna för V_OH och V_OL.
Ta drivsteget för taket. Stegen 2, 4, 8 och 12 mA väljer hur hårt paddet drar, inte hur mycket det släpper igenom. En Pico-pinne vaknar på steget 4 mA, och det steget är lika lite ett tak som steget på 12 mA. På en Pi 4 slutar stegen vid 8 mA medan den säkra strömmen ligger kvar på 16 mA, och mellanrummet däremellan är precis det fönster där kalkylatorn skriver ut sin rad om drivsteget.
Anta att det finns ett värde för en Raspberry Pis 3,3 V-pinne. De 500 mA som citeras kommer från pinout.xyz, som i samma stycke skriver att det i brist på dokumentation och mätningar är en tumregel; de 50 mA som också citeras beskriver de tidiga kortens regulator. Ingen av dem står i ett dokument från Raspberry Pi. På en Pico finns svaret däremot — under 300 mA, rekommenderat av databladet — och på en Arduino Uno är det 50 mA ur kortets egen regulator.
Göra av med ett absolut maxvärde. Unos 40 mA per pinne står hos Microchip under rubriken som varnar för bestående skada. Arduinos egna tekniska data anger 20 mA som likström per I/O-pinne, och det är vid det värdet som ATmega-kretsen är karakteriserad. Samma sak gäller ESP32:ans 1 200 mA: det är den enda sammanlagda siffra Espressif publicerar, och den står i tabellen över absoluta maxvärden.
Lita på ett komponentrykte. De 60 mA per WS2812B som citeras överallt står inte i WS2812B:s datablad, där ingen strömförbrukning per lysdiod anges alls. Kjell & Companys svenska Arduino-guide ”Styr lysdioder med Arduino” ger dig lasten men inte taket: den skriver att RGB-lysdioden ”ska drivas på 20 mA per färg (i stället för 10 mA)” och nämner ingen gräns per pinne någonstans på sidan. Tre färger à 20 mA är samma räkning som gör åtta RGB-lysdioder till 24 kanaler.
Tro att PWM delar strömmen. En lysdiod som dimras till 50 % pulskvot halverar medelvärdet, och paddet ser hela toppen så länge pinnen är hög. Alla budgetar på den här sidan är toppvärden, så skriv in toppen. En multimeter i medelvärdesläge ger dig här den vänligare och den felaktiga siffran.
”Jag testade, det funkar.” I SweClockers tråd om att driva ett relä från en GPIO-pinne rapporterar en läsare i januari 2015 att ”jag köpte just artikel 87913 hos Kjelle å den går att driva direkt utan nånting på GPIO pinnarna. Testat!”. Båda sakerna kan vara sanna samtidigt: många reläkort har redan transistor och optokopplare monterade, och då är det ingången du belastar och inte spolen. Skriv in ingångens ström. Ovanför den säkra strömmen lovar tillverkaren däremot ingenting, inte ens att kortet går sönder samma dag.

Vad varje kort publicerar, och vilken sorts siffra det är

Kort	Per GPIO-pinne	Alla GPIO-pinnar	3,3 V-pinnen	Högsta drivsteg
Raspberry Pi 5 / 500	16 mA — säker ström	50 mA — säker ström	Inte publicerat	12 mA
Raspberry Pi 4 Model B / 400	16 mA — säker ström	50 mA — säker ström	Inte publicerat	8 mA
Raspberry Pi 3 (B / B+ / A+)	16 mA — säker ström	50 mA — säker ström	Inte publicerat	16 mA
Raspberry Pi Zero 2 W	16 mA — säker ström	50 mA — säker ström	Inte publicerat	16 mA
Raspberry Pi Zero / Zero W	16 mA — säker ström	50 mA — säker ström	Inte publicerat	16 mA
Pico / Pico W (RP2040)	12 mA — specifikation	50 mA — specifikation, GPIO och QSPI ihop	300 mA — rekommenderat	12 mA
Pico 2 / Pico 2 W (RP2350)	12 mA — specifikation	100 mA — specifikation, plus 20 mA för QSPI	300 mA — rekommenderat	12 mA
Arduino Uno R3 / Nano (ATmega328P)	40 mA — absolut maxvärde	200 mA — absolut maxvärde	50 mA — rekommenderat	20 mA
ESP32-utvecklingskort (ESP32-WROOM-32)	40 mA — specifikation	1 200 mA — absolut maxvärde	Inte publicerat	40 mA

Tio räknade fall, ordnade efter vilket av de tre beskeden du får

Inom alla gränser, och ändå gult: startläget med tre förbrukare på 10 mA på en Pico

Sidan öppnar på en Raspberry Pi Pico med tre förbrukare på 10 mA var på GPIO-pinnar, en på 20 mA på 3,3 V-pinnen och en säkerhetsmarginal på 20 %. Alla fyra kontroller går igenom: 10 mA av 12 på den hårdast belastade pinnen, 30 mA av 50 på alla pinnar tillsammans, 20 mA av 300 på 3,3 V-pinnen, och ingenting alls på 5 V-sidan. Snävast är pinnen, med 2 mA kvar till gränsen.

Ändå är kortet gult. Vid 20 % marginal ligger linjen för en gräns på 12 mA vid 9,6 mA, och de 10 mA har redan passerat den. Det är hela poängen med startläget: en marginal och en gräns är två olika saker, och beskedet följer den kontroll som binder, inte den vänligaste.

Inom alla gränser: sex lysdioder på 20 mA på ett ESP32-utvecklingskort

20 mA per pinne mot ESP32:ans 40 mA, och 120 mA mot ett sammanlagt värde på 1 200 mA. De två budgetar kortet publicerar går båda igenom, och den snävaste är pinnen på halva sin gräns, med 20 mA kvar. För 3,3 V-pinnen på ett ESP32-utvecklingskort finns ingen publicerad siffra, så den kontrollen står utanför.

Läs sorten innan du lutar dig tillbaka. De 1 200 mA är ett belastningsvärde ur tabellen med absoluta maxvärden, och Espressif antecknar själv att strömmen per pinne sjunker från omkring 40 mA mot omkring 29 mA ju fler pinnar i samma matningsdomän som levererar samtidigt. Taket du möter på riktigt på ett utvecklingskort är dess 3,3 V-regulator och USB-porten bakom den, och eftersom den siffran tillhör den som byggde kortet och inte Espressif kan den här kontrollen inte ta med den.

Inom alla gränser, men det är aggregatet som sätter den: en motor på 1 A på 5 V-pinnen på en Pi 4

5 V-budgeten är vad ditt aggregat lämnar minus vad kortet drar åt sig självt. En Pi 4 med ett aggregat på 3 000 mA och radens egen förbrukning på 800 mA — det högre av Pi 4 Model B:s 600 mA och Pi 400:ans 800 mA — lämnar 2 200 mA på 5 V-pinnen. En motor på 1 000 mA går alltså igenom med 1 200 mA kvar, och kontrollen som binder är ditt 5 V-aggregat. GPIO-budgetarna är inte inblandade alls.

Det här är den enda av de fyra budgetarna du kan höja genom att köpa ett större aggregat; de andra tre ligger fast i kislet. Start- och blockeringsström är en annan fråga som kontrollen inte modellerar: toppen vid start kan vara flera gånger det stabila värde du skrev in, och den som ska överleva den är aggregatet och inte kalkylatorn.

För mycket på en enda pinne: en förbrukare på 15 mA på en Pico

En ensam förbrukare på 15 mA på en GPIO-pinne på en Pico kommer ut med 3 mA för mycket. Summan är avslappnad, 15 mA av 50, och 3,3 V-pinnen rörs inte; det som faller är bara pinnen själv, 15 mA mot en specifikationsgräns på 12 mA.

Eftersom kretsen har plats och det bara är en pinne som går över heter åtgärden transistor eller MOSFET och inte drivkrets: ”En pinne ska styra den här lasten, inte bära den”. Samma 15 mA på en pinne på en Raspberry Pi 5 får plats, med 1 mA kvar, därför att Pi:ns värde per pinne är 16 mA säker ström där Picons är 12 mA specifikation. En tumregel tar sig inte oskadd från det ena kortet till det andra.

För mycket på alla pinnar tillsammans: fyra lysdioder på 15 mA på en Raspberry Pi 5

15 mA på en enskild pinne ryms inom Pi:ns säkra ström på 16 mA med 1 mA kvar, vilket kalkylatorn målar som snävt och inte som grönt. Fyra av dem är 60 mA över GPIO-pinnarna mot 50 mA säker ström för alla tillsammans, så beskedet blir 10 mA för mycket och kontrollen som binder är summan.

Under den dyker en andra rad upp: ”En pinne för 15 mA, över det här paddets högsta drivsteg på 12 mA. Strömmen går fram, men utspänningen håller inte längre specifikationen.” Det som ser ut som en anspråkslös panel med fyra lysdioder passerar två olika tak samtidigt, och inget av dem syns om man bara tittar på förkopplingsmotståndet.

För mycket på alla pinnar tillsammans: åtta RGB-lysdioder direkt på en Picos pinnar

Åtta RGB-lysdioder med gemensam katod är 24 separata kanaler, och vid 20 mA styck begär de 480 mA av GPIO-pinnarna, fördelat på 24 pinnar. Picons budget för alla pinnar är 50 mA, så beskedet blir 430 mA för mycket på alla GPIO-pinnar tillsammans. Kontrollen per pinne faller också, 20 mA mot en specifikationsgräns på 12 mA, men det är summan som avgör svaret: att flytta förbrukare mellan pinnar lagar ingen kretssumma, och åtgärdskortet säger det i sin rubrik — ”Kretsen klarar inte det här, vad du än gör per pinne”.

De 20 mA per kanal är inte påhittade. Kjell & Companys svenska Arduino-guide anger just 20 mA per färg för en RGB-lysdiod. Vägen som fungerar är en drivkrets: en PCA9685 för vanliga lysdioder, eller ett byte till adresserbara WS2812B eller APA102, som bär sin egen matning och tar en eller två pinnar i stället för 24.

Fortfarande för mycket efter kortbytet: samma åtta RGB-lysdioder på en Pico 2

Byt RP2040 mot RP2350 och potten som föregångaren delade mellan GPIO och QSPI blir 100 mA enbart för GPIO-pinnarna, med 20 mA vid sidan om för QSPI. De 480 mA är fortfarande 380 mA för mycket, och värdet per pinne har inte rört sig: 20 mA mot samma specifikationsgräns på 12 mA.

Kortbytet köper 50 mA där lysdioderna begär nästan tio gånger så mycket. Det här paret är det starkaste argumentet för en tabell per kort i stället för en enda uppsättning siffror: samma mening, om samma koppling, får två olika svar på två kort som i vilket samtal som helst båda heter ”en Pico”.

För mycket på pinnen, och ändå är svaret en drivkrets: ett reläkort på 70 mA på en Pi 5

70 mA ur en pinne är 54 mA för mycket över Pi:ns säkra ström på 16 mA, och samma last ensam är redan 20 mA för mycket över de 50 mA för alla pinnar. Kontrollen som binder är pinnen, och ändå öppnar kalkylatorn åtgärdskortet om drivkrets och inte det om transistor, eftersom kretssumman går före pinnen när båda överskrids: lasten är för stor för kretsen och inte bara för en av dess pinnar.

Uppställningen som fungerar matar modulen från 5 V-pinnen och låter GPIO:n koppla den via en transistor, MOSFET eller optokopplare, så att pinnen styr lasten i stället för att bära den. På paddbacken.se är det precis så det svenska bygget ser ut: ett mekaniskt relä som enligt specifikation drar 900 mW över spolen, alltså 75 mA, kopplas via en BC547B med ett basmotstånd på 2,2 kΩ, vilket ger ”en ström vid påslag på 3,3/2200=1,5mA” från pinnen. Många reläkort bär redan transistorn och optokopplaren — när ditt gör det är siffran du skriver in ingångens ström och inte spolens.

För mycket på 3,3 V-pinnen: 60 mA på 3V3 på en Arduino Uno

Arduinos egna tekniska data ger Unos 3,3 V-pinne 50 mA, ett värde som kommer från regulatorn på kortet och inte från ATmega328P. En förbrukare på 60 mA är 10 mA för mycket, kontrollen som binder är 3,3 V-pinnen, och åtgärden heter ”Ge den ett eget aggregat”, eftersom det som är för knappt är matningen och inte en pinne.

Kretsens budgetar ligger orörda bredvid: 0 mA mot det absoluta maxvärdet 40 mA per pinne och 0 mA mot de 200 mA totalt. En sensor på 3,3 V rör aldrig vid ATmega-kretsen, och därför skulle en kontroll byggd enbart av mikrokontrollerns värden per pinne och i summa släppa igenom det här bygget utan ett ord.

Ingen publicerad gräns att jämföra mot: en sensor på 30 mA på 3,3 V-pinnen på en Pi 5

På GPIO-pinnarna hänger ingenting, och den enda förbrukaren sitter på 3,3 V-pinnen på stiftlisten. Beskedet säger det rakt ut — ”Kortet har ingen publicerad gräns” — skriver summan bredvid, 30 mA på 3,3 V-pinnen, och lämnar jämförelsen ogjord. Raspberry Pi har aldrig förklarat vad den pinnen duger till, så ett streck är den ärliga utdatan, och ett streck är varken ett godkänt eller en nolla.

Samma 30 mA skulle på en Pico mätas mot de 300 mA databladet rekommenderar, och på en Arduino Uno mot de 50 mA Arduino publicerar. Av de tre korten har bara två ett tal att jämföra sensorn med, och kortet talar om vilket av fallen du befinner dig i i stället för att tyst släppa dig vidare.

Så använder du GPIO-strömkalkylatorn

Formuläret är kort med flit: välj kort, räkna upp vad du vill koppla in, och läs beskedet. Allt som kräver eftertanke ligger under ”Avancerat”.

1. Välj ditt kort i fältet ”Kort”. På det hänger de fyra budgetarna, drivstegen, antalet GPIO-pinnar och det förifyllda 5 V-aggregatet. För ett kort som listan inte känner finns posten där du själv skriver in de tre gränserna ur ett datablad.

2. Fyll i första raden under ”Det du vill koppla in”: ström per styck, hur många, och vad den är kopplad till — en GPIO-pinne, 3,3 V-pinnen eller 5 V-pinnen. Sex förbrukare får plats, med en åtgärd under blocket för att lägga till en och en för att ta bort.

3. Skriv in den ström komponenten drar i din krets, mätt eller läst ur dess eget datablad. Något komponentbibliotek finns här medvetet inte: vad en lysdiod drar beror på förkopplingsmotståndet, på färgen och på spänningen du kör den vid, och vissa berömda tal står ingenstans skrivna — de 60 mA per WS2812B finns inte i WS2812B:s datablad.

4. Öppna ”Avancerat” när du behöver det. Där ligger ”Ditt 5 V-aggregat klarar”, ”Säkerhetsmarginal” med 0, 10, 20 eller 30 %, och för ett egeninskrivet kort de tre gränserna du anger själv.

5. Läs beskedskortet först. Det går i full bredd och bär färgen från den kontroll som binder, så ett grönt besked ovanför en gul kontroll kan inte stå där. Antingen namnger det den snävaste budgeten med båda talen, eller skriver hur många milliampere för mycket det är och på vilken kontroll.

6. Gå igenom kontrollkorten under: ”Alla GPIO-pinnar tillsammans” med en stapel, ”Den hårdast belastade pinnen”, ”3,3 V-pinnen” och ”Ditt 5 V-aggregat”, det sista bara när något hänger på den. Varje rubrik bär med sig vilken sorts gräns den prövar, så du ser om det du närmar dig är en säker ström eller ett absolut maxvärde.

7. Läs detaljraderna: hur många pinnar du har i bruk, raden om drivsteget när en pinne för mer än paddets högsta steg, och listan över budgetar som faller utanför jämförelsen därför att tillverkaren inte publicerar någon siffra.

8. Kopiera budgetarna. Tabellen ”Det här kortets budgetar” har en kopieringsknapp, och det den ger — fyra märkta rader, beskedet, marginalen och ett streck där ingenting är publicerat — är precis det block man klistrar in under en forumfråga. Under den ligger uträkningen rad för rad, referenstabellen över vad varje kort klarar att leverera, och avsnittet om vad kontrollen inte täcker.

När det lönar sig att räkna efter — och när det inte gör det

För en ensam lysdiod med förkopplingsmotstånd på en pinne behöver du inget verktyg. Tre lägen är värda de två minuterna.

När du byter kortfamilj. Ett bygge som gick på en Pi 3 går inte automatiskt likadant på en Pi 4: 4-seriens drivstege slutar vid 8 mA medan den säkra strömmen på 16 mA ligger kvar. Däremellan finns ett område där pinnen för strömmen och utspänningen lämnar specifikationen. Samma sak skiljer RP2040 från RP2350 åt andra hållet: summan fördubblas, värdet per pinne rör sig inte.

När mer än en förbrukare hänger på samma kort. Kontrollen per pinne är den man gör själv; kretssumman är den man glömmer. Fyra lysdioder på 15 mA på en Pi 5 klarar sig var för sig och faller tillsammans, med 10 mA för mycket. Därför prövar den här sidan alla fyra samtidigt och skriver beskedet på den kontroll som binder.

Innan du frågar i en tråd. Tabellen ”Det här kortets budgetar” har en kopieringsknapp, och de fyra märkta raderna plus beskedet och marginalen svarar på den första motfrågan innan någon hinner ställa den. Tråden på Svenska ElektronikForumet om relästyrning börjar precis så: med en uppmätt ström per pinne, ett tak hämtat någonstans ifrån, och en fråga om de två går ihop.

Kalkylatorn behövs däremot inte när förbrukaren ändå har sin egen matning och pinnen bara levererar styrsignalen. Då för pinnen bas- eller gate-strömmen, och den ligger i en storleksordning där ingen av de fyra budgetarna börjar svaja: i bygget på paddbacken.se blir det 1,5 mA genom ett basmotstånd på 2,2 kΩ, mot spolens 75 mA på andra sidan transistorn.

Så tar du en koppling genom alla fyra kontrollerna

Titta på vilken sorts siffra det är innan du pressar den. En säker ström har konstruktionsutrymme ovanför sig och ett absolut maxvärde har inget alls, så 14 mA mot en Pi:s säkra ström på 16 mA är ett designval medan 38 mA mot en Unos absoluta maxvärde på 40 mA är en chansning.
Låt marginalen sköta räknandet. Den ligger under ”Avancerat” med 0, 10, 20 och 30 %, kommer på 20 %, och färgar en kontroll gul så fort du passerar linjen. I startläget blir tre förbrukare på 10 mA gula vid 9,6 mA i stället för att vänta på de 12 mA.
Para ihop åtgärden med kontrollen som föll. En överskriden pinne med frisk kretssumma ber om transistor eller MOSFET, så att pinnen kopplar lasten i stället för att bära den. En överskriden kretssumma ber om en drivkrets — PCA9685 för vanliga lysdioder, WS2812B eller APA102 för adresserbara — eftersom omflyttning inte lagar en summa. En överskriden matningsskena ber om ett eget reglerat aggregat.
Kom ihåg vilken av dem som går före. Kalkylatorn öppnar exakt ett åtgärdskort, och kretssumman slår pinnen: när alla pinnar tillsammans går över får du åtgärdskortet om drivkrets, även när det dessutom finns en enskild pinne som går över.
På en Pi 4, se upp för glappet mellan drivsteg och säker ström. 4-seriens stege slutar vid 8 mA medan de 16 mA säker ström står kvar, så allt däremellan låter pinnen föra strömmen med utspänningen utanför specifikationen. Kalkylatorn skriver ut den raden när den gäller.
En Pico 2 lyfter summan och lämnar pinnen där den var. RP2350 tar GPIO-värdet från 50 till 100 mA och ger QSPI egna 20 mA, medan de 12 mA per pinne står exakt kvar. Var det kontrollen per pinne som föll ändrar kortbytet ingenting.
Dimensionera 5 V-pinnen utifrån ditt aggregat. Den budgeten är vad du angett att aggregatet klarar, minus kortets publicerade egna förbrukning: 800 mA på raderna för Pi 5 och Pi 4, 150 mA på raden för Zero / Zero W. Ett större aggregat lyfter den enda budgeten; på de andra tre händer ingenting.
Skriv in toppen och inte medelvärdet. För PWM, blinkmönster och allt som klockar är talet paddet ser strömmen i påslaget läge, oavsett hur låg pulskvoten är.

Det här täcker kontrollen inte

Varje värde per pinne, för alla pinnar och per matningsskena är läst ur det tillverkardokument som står under Källor, och datamängden härleddes om cell för cell den 17 september 2026. Där en rad täcker flera modeller bär den den högsta publicerade egna förbrukningen av dem den nämner, så att 5 V-utrymmet aldrig blir för generöst räknat. Ingenting i tabellen är en uppskattning från communityn och ingenting är interpolerat.

Flera saker ligger med flit utanför räkningen, och ett bygge kan klara alla fyra budgetarna och ändå haverera på någon av dem.

Ström som går in i en pinne. Det är en annan fråga, besvarad av ingångsspecifikationen och klampdioderna och inte av en utgångsbudget.

Start-, blockerings- och transientström. En motors startström och en kondensators laddningsstöt ligger flera gånger över det stabila värde du skriver in, och ingen av dem är modellerad.

Pulskvoten vid PWM. Paddet ser toppen så länge pinnen är hög, så en dimrad lysdiod bidrar här med hela sin ström. Det är den konservativa läsningen och för en paddgräns den rätta.

Strömmens riktning. RP2040 publicerar en egen budget på 50 mA för det som levereras och en för det som tas upp, vilket betyder att en last faktiskt går att dela mellan dem. Den här sidan frågar aldrig efter riktningen och summerar allt som hänger på GPIO-pinnarna mot en enda gräns, vilket är den strängare läsningen.

Samtidig omkoppling samt termiska gränser och kapselgränser. Espressifs anteckning om att ESP32:ans ström per pinne sjunker från omkring 40 mA mot omkring 29 mA när fler pinnar i samma domän levererar samtidigt är ett exempel; kapselns totala förlusteffekt ett annat.

Arduino Unos portgrupper. Två källgrupper på 150 mA var och tre sänkgrupper på 100 mA var slår till före de 200 mA totalt, och att tillämpa dem skulle kräva att man vet på vilken fysisk pinne varje förbrukare sitter och åt vilket håll strömmen går — två uppgifter den här sidan aldrig frågar efter.

Pi 5:ans värden är Raspberry Pis allmänna paddvägledning. Inget dokument om BCM2712 eller RP1 publicerar en ström per pinne eller i summa; RP1:ans periferihandbok har över huvud taget inget avsnitt om elektriska data. De 16 mA och de 50 mA kommer från de modellövergripande sidorna om paddar och strömförsörjning, som räknar Pi 5 bland de kort de täcker utan att begränsa siffrorna per modell. Det som däremot är dokumenterat är att RP1:ans drivsteg slutar vid 12 mA.

På ett ESP32 binder summakontrollen så gott som aldrig. De 1 200 mA är den enda sammanlagda siffra Espressif publicerar och den är ett belastningsvärde, så ett bygge som drar 400 mA över pinnarna läses här som inom alla gränser medan utvecklingskortets egen 3,3 V-regulator redan kan vara på väg att ge vika. Den regulatorn tillhör den som tillverkade kortet och inte Espressif, och därför finns ingen siffra för den i den här datamängden.

Ohms lag bor någon annanstans. Motståndsvärden, lysdiodens framspänning, ett batteris drifttid, aggregatets verkningsgrad, spänningsfall i kabeln, en HATs effektförhandling och USB-enumerering är egna räkningar, och ingen av dem körs här.

GPIO-ström — vanliga frågor

Hur mycket ström tål en GPIO-pinne?

Det beror på kretsen. Ett padd på en Raspberry Pi är konstruerat för 16 mA som säker ström, en pinne på en Pico eller Pico 2 är specificerad till 12 mA, en ESP32-pinne till 40 mA, och en Arduino Uno-pinne bär 40 mA som absolut maxvärde vid 20 mA likström.

Är gränsen 50 eller 51 mA för alla GPIO-pinnar på en Raspberry Pi?

50 mA. Raspberry Pi skriver det i klartext på sin sida om strömförsörjning: alla GPIO-pinnar tillsammans kan dra 50 mA säkert, och varje pinne för sig upp till 16 mA. De 51 mA som går runt på svenska forum står inte i något dokument från Raspberry Pi. De faller ut av en multiplikation: paddokumentets 3 mA per GPIO-pinne gånger de 17 GPIO som satt på den gamla 26-poliga stiftlisten. Skillnaden på en milliampere ändrar inget bygge, men 50 är en publicerad säker ström och 51 är en uträkning.

Är Raspberry Pi Picos 50 mA per pinne eller för alla pinnar tillsammans?

För alla tillsammans. RP2040-databladet håller summan av vad GPIO- och QSPI-pinnarna levererar på 50 mA, och håller separat allt de tar upp på 50 mA. Per pinne är det 12 mA.

Klarar Pico 2 mer ström än Pico?

I summan ja, per pinne nej. RP2350 publicerar 100 mA över GPIO-pinnarna plus 20 mA för QSPI-pinnarna, åt vardera hållet, där RP2040 lade GPIO och QSPI i en enda siffra på 50 mA per håll. Per pinne är båda kretsarna specificerade till 12 mA, båda har 12 mA som högsta drivsteg och båda vaknar på steget 4 mA. För en panel med indikeringslysdioder betyder den fördubblade summan något på riktigt; för vad en ensam pinne gör betyder den ingenting. Den uppdelningen står i den elektriska tabellen i RP2350-databladet, och den finns bara på engelska — inte ens Electrokits svenska produktsida för Pico 2 nämner ett milliampere.

Hur många lysdioder kan jag koppla till en Raspberry Pi Pico?

Dela de 50 mA i summan med vad en lysdiod drar, och pröva värdet per pinne separat. Vid 2 mA per lysdiod, vilket räcker gott för en indikering, landar tjugo lysdioder på tjugo pinnar på 40 mA och går igenom. Vid 20 mA styck skulle summan räcka till två, men 20 mA på en pinne har redan passerat specifikationsgränsen på 12 mA, så det ärliga svaret är då en transistor per lysdiod eller en drivkrets. Åtta RGB-lysdioder, alltså 24 kanaler, begär 480 mA och ligger nästan tio gånger över: det är en drivkrets eller en adresserbar slinga, inte en annan koppling.

Hur mycket ström ger 3,3 V-pinnen på en Raspberry Pi?

Raspberry Pi publicerar ingen siffra för den pinnen. Paddokumentet skriver att 3,3 V-matningen konstruerades för ungefär 3 mA per GPIO-pinne, vilket beskriver vad paddarna själva drar och inte vad pinnen på stiftlisten kan lämna, och inget annat dokument från Raspberry Pi anger någon gräns för pinnen. Talen som cirkulerar kommer utifrån: 50 mA beskriver de tidiga kortens regulator, och pinout.xyz:s 500 mA erbjuds av sidans egen författare som en tumregel i brist på dokumentation och mätningar. Den här kalkylatorn skriver ett streck där och lämnar 3,3 V-pinnen utanför beskedet på en Pi. På en Pico finns svaret — under 300 mA, rekommenderat av databladet — och på en Arduino Uno är det 50 mA ur kortets egen regulator.

Är drivsteget samma sak som en strömgräns?

Nej. Drivsteget är den ström under vilken paddet fortfarande håller sin spänningsspecifikation. Belasta pinnen över sitt steg och den levererar strömmen med sjunkande spänning. RP2350-databladet kallar uttryckligen sina egna värden för icke hårda gränser.

Vad händer om jag går över strömgränsen?

Det beror på vilken gräns och vilken sort den är. Bortom en specifikationsgräns leder pinnen vidare medan utspänningen lämnar det angivna intervallet, så logiknivåerna går sönder före hårdvaran. Bortom ett absolut maxvärde är du i området där tillverkaren aviserar bestående skada. Om mellanrummet däremellan är Raspberry Pis paddokumentation rakt på sak: 16 mA är det säkra värdet under vilket du inte skadar enheten, och därutöver finns ingen garanterad högsta säker ström. Den sista meningen är den att ha till hands när någon föreslår att bara prova — ovanför det säkra värdet lovar tillverkaren ingenting, inte ens att kortet går sönder samma dag.

Kan jag koppla ett reläkort direkt till en GPIO-pinne?

Titta först på vad modulens ingång drar. Ett relä på 70 mA på en pinne på en Raspberry Pi 5 kommer ut med 54 mA för mycket över den säkra strömmen på 16 mA per pinne, och samtidigt 20 mA för mycket över kretssummans 50 mA. Uppställningen som fungerar matar modulen från 5 V-pinnen och låter GPIO:n koppla en transistor, MOSFET eller optokopplare, så att pinnen styr lasten i stället för att bära den; en frihjulsdiod över spolen hör till. På svenska forum dyker rapporten upp att ett färdigt reläkort gick att driva direkt från pinnarna, och den kan mycket väl stämma: många reläkort bär redan transistorn och optokopplaren, och då är siffran du ska skriva in ingångens ström och inte spolens.

Hur många lysdioder klarar en Arduino Uno?

Taket Uno publicerar är 200 mA genom sina VCC- och GND-pinnar, och det är ett absolut maxvärde och ingen driftbudget; Arduinos tekniska data anger 20 mA som likström per I/O-pinne. Under de 200 mA slår gruppgränser till först: två källgrupper på 150 mA och tre sänkgrupper på 100 mA, beroende på vilka fysiska pinnar du använt. Räkna med de 20 mA, håll avstånd till gruppgränserna, och behandla varje panel vars summa passerar en av dem som ett jobb för skiftregister eller drivkrets.

Varför står det 1 200 mA i ESP32-databladet, och får jag använda dem?

De 1 200 mA är den sammanlagda utgångsströmmen för I/O ur tabellen med absoluta maxvärden, publicerad som ett belastningsvärde under anteckningen att normal drift vid de villkoren inte är underförstådd. Just därför bär siffran etiketten absolut maxvärde här, och praktiskt följer att summakontrollen på ett ESP32 så gott som aldrig binder. Gränsen du möter först på ett utvecklingskort är dess 3,3 V-regulator och USB-porten bakom den, och den siffran tillhör tillverkaren av ditt kort och inte Espressif, så den finns inte i den här datamängden. Espressif antecknar dessutom att strömmen per pinne sjunker från omkring 40 mA mot omkring 29 mA ju fler pinnar i samma matningsdomän som levererar samtidigt.

Var kommer gränserna i den här kalkylatorn ifrån?

Varje värde är läst ur tillverkarens eget dokument, uppräknade under Källor vid kalkylatorn: RP2040- och RP2350-databladen för Pico-kortens värden per pinne och i summa, Pico- och Pico 2-databladen för deras rekommendation om 3,3 V, Raspberry Pis hårdvarudokumentation för paddarna och strömförsörjningen, RP1:ans periferihandbok för Pi 5:ans drivsteg, ESP32-databladet för Espressifs siffror, och ATmega328P-databladet tillsammans med Unos tekniska data för Arduino. Datamängden härleddes om cell för cell den 17 september 2026. Där ett dokument inte publicerar något står ett streck i stället för en ersättare — och därför kommer Unos 3,3 V-värde från Arduinos produktsida: det nuvarande databladet för UNO R3 lämnar sin egen rad om strömförbrukning som ett outfyllt ”xx mA”.

Kan jag använda kalkylatorn för ett kort som inte finns i listan?

Ja. Välj posten för ett eget kort och skriv in de tre gränserna — per pinne, för alla pinnar och för 3,3 V — under ”Avancerat”, hämtade ur kortets datablad. De tre rutorna kommer förifyllda med 12, 50 och 300 mA, så skriv över dem med kortets egna värden. Lämna en nolla där dokumentationen inte publicerar något — den budgeten visas då med ett streck och hålls utanför jämförelsen, och nollar du alla tre står det i beskedet att inga gränser är angivna, tillsammans med dina summor på GPIO-pinnarna, 3,3 V-pinnen och 5 V-pinnen. En tom ruta räknas aldrig som ett godkänt.

Är den här GPIO-strömkalkylatorn gratis?

Ja, utan konto och utan installation. Uträkningen sker i webbläsaren medan du skriver, och budgettabellen har en kopieringsknapp tänkt för att klistra in resultatet i en forumtråd eller i projektloggen.

Kalkylatorn säger att jag är över. Vad ändrar jag?

Läs vilken kontroll som föll, för de tre fallen ber om olika komponenter. En överskriden pinne med frisk kretssumma är ett kopplingsproblem: sätt en transistor eller MOSFET mellan pinnen och lasten, så för pinnen därefter bara det som kostar att koppla. En överskriden kretssumma går inte att laga genom omflyttning — där behövs en drivkrets som tar hela gruppen, PCA9685 för vanliga lysdioder och WS2812B eller APA102 för adresserbara, med egen matning till lysdioderna. En överskriden matningsskena, vare sig det är 3,3 V-pinnen eller 5 V-aggregatet, betyder ett eget reglerat aggregat eller ett större. Kalkylatorn öppnar exakt ett åtgärdskort, och kretssumman går före pinnen.

Mitt resultat är snävt och inte över. Är det ett problem?

Snävt betyder att du ligger inom den publicerade gränsen men ovanför säkerhetsmarginalen, som förvalt står på 20 %. På en Pico-pinne är det bandet från 9,6 mA till 12 mA. Om du accepterar det beror på sortens tak: en säker ström har konstruktionsutrymme ovanför sig, en specifikationsgräns betyder att utspänningen redan är nära kanten av sitt fönster, och ett absolut maxvärde närmar man sig inte alls. Komponenttolerans, matningsspänning och temperatur flyttar den verkliga strömmen runt talet du skrev in, och att svälja det är precis vad marginalen är till för.

Källor och referenser

Innehåll verifierat av Smart Calculators-teamet