Långläsning: Elbilsrookiens lyckade ledighet


<p class="has-medium-font-size"><strong>Hur lätt är det att bara låna en elbil och ge sig ut på semester med tre barn om man inte har några förkunskaper om laddning och räckvidd? Vi lät vår formgivare Fanny pröva sina vingar med fyrhjulsdrivna och nyligen prissänkta Nissan Ariya.</strong><div id="elbilen_panorama-1"></div><script>lwhb.cmd.push(function() {lwhb.loadAd({tagId: "elbilen_panorama-1"});});</script><div id="elbilen_mobil-1"></div><script>lwhb.cmd.push(function() {lwhb.loadAd({tagId: "elbilen_mobil-1"});});</script></p>



<p>”Can you please help us! We have been driving around the whole city looking for chargers. How does this work?”</p>



<p>Kvinnan som parkerat vid stolpen bredvid mig har imponerande korta shorts och är i trängande behov av min laddexpertis. Hon har åkt hela vägen från Belarus till Stockholm med sin Tesla Model S, som hon nu alltså äntligen hittat el till – men hur får man igång laddningen när allt står på svenska?</p>



<p>Det är söndag i juli och jag befinner mig på OKQ8 i Solna. Jag ska ladda min Nissan Ariya, eller Ari som jag kallar henne, för allra sista gången, efter tio underbara dagar tillsammans.&nbsp;<br>Men vi tar det från början, som man så ofta gör i en text.&nbsp;</p>



<p>Ni som läser den här tidningen har förmodligen kört elbil ett bra tag. Ni laddar vant både hemma och där ute längs vägarna, det är inte längre en <em>grej</em> för er. Men som Tibor skriver i krönikan på sidan 82: nu är det inte längre bara tekniknördar med batterikemier som största intresse som kör elbil, utan helt vanliga människor som ”har ett liv”. Äsch då, smicker smicker.&nbsp;</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/10/FannyAriya_005_EDIT.jpg"><img src="https://elbilen.se/wp-content/uploads/2023/10/FannyAriya_005_EDIT-1030x549.jpg" alt="" class="wp-image-27635"/></a></figure>



<p>Men visst, jag har ett ”liv”. Och ett begränsat intresse för batterier. Om sanningen ska fram är jag helt ointresserad av bilar. Under alla år som jag jobbat med att rita den här tidningen har jag inte lyckats lära mig någonting om tekniken. Litiumjon är ett ord jag ofta skummar förbi, det verkar vara centralt på något vis. Newtonmeter hit och dit.&nbsp;</p>



<p>Men lika stort som ointresset är för bilar, är den förbehållslösa kärleken till att köra bil. Alltså själva aktiviteten.<br>Att sitta still men ändå röra sig framåt, inne men ändå ute, med spännande saker att titta på genom rutan, sjungandes alldeles för högt. Barnen som bråkar, ber mig sluta sjunga, alternativt sover där bak. Jag älskar det. Tyvärr äger jag inte längre en bil, det blev för dyrt (shoutout till Volvis – jag älskar dig för evigt). Men vi kan väl helt enkelt bara beskriva mig som Sveriges minst bilintresserade bilälskare.&nbsp;</p>



<p>Och nu har jag alltså fått i uppdrag att skriva en hel text i Sveriges största och bästa elbilsmagasin. En spännande resejournal om hur det är att åka på sin allra första elbilssemester, som ni veteraner kan le överseende och nicka igenkännande åt: ”Ha! Hon tog det <em>undre</em> laddhandtaget på superchargern – we have all been there”.&nbsp;</p>



<figure class="wp-block-gallery has-nested-images columns-default is-cropped wp-block-gallery-1 is-layout-flex wp-block-gallery-is-layout-flex">
<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/10/IMG_1823-2_EDIT2.jpg"><img data-id="27644" src="https://elbilen.se/wp-content/uploads/2023/10/IMG_1823-2_EDIT2-687x1030.jpg" alt="" class="wp-image-27644"/></a><figcaption class="wp-element-caption"><br>Allra första laddningen <br>genomförd utan incidenter.</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/10/IMG_1831_EDIT.jpg"><img data-id="27643" src="https://elbilen.se/wp-content/uploads/2023/10/IMG_1831_EDIT-687x1030.jpg" alt="" class="wp-image-27643"/></a><figcaption class="wp-element-caption"><br>I bagaget går det <br>att stuva in det mesta.</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/10/FannyAriya_015_DIT-scaled.jpg"><img data-id="27642" src="https://elbilen.se/wp-content/uploads/2023/10/FannyAriya_015_DIT-687x1030.jpg" alt="" class="wp-image-27642"/></a><figcaption class="wp-element-caption"><br>Och i baksätet är det möjligen olagligt gott om plats, vilket Fanny här demonstrerar med en<br>naturlig pose.</figcaption></figure>
</figure>



<p>Jag ska få låna en Nissan Ariya e4orce, och förväntas nog kunna leverera något slags omdöme om själva bilen också. Jag frågar chefredaktör Fredrik, som jag till mina vänner ofta säljer in som ”elbilsmannen”, vad som är viktigt med en elbil. Han ger förstås ett alldeles för långt svar för att det ska få plats i den här texten, men bra räckvidd och snabb laddning verkar vara någon slags grund för en behaglig körning.&nbsp;</p>



<p>Min andra kollega Joakim (som jag säljer in som ”mannen som är kompis med Boris Brejcha”) tycker att det viktiga med en bil är bra styrning och funktionella hjälpsystem.</p>



<p>Själv har jag inga särskilda önskemål. Medan Fredrik går igång på trådlösa kopplingar är jag mer utav en ”bälte och säten”-tjej. Har också alltid gillat bilar med ratt. Hyfsade högtalare är egentligen mitt enda krav.&nbsp;</p>



<p>Men redan på parkeringen utanför Nissan i Kista inser jag att den här fräsiga suven kommer att höja ribban även för mig. Ni får kanske ta min begeistring med en nypa salt med tanke på krav­nivån, men jag är ganska säker på att vem som helst skulle bli lycklig av att köra den här bilen. Den har&nbsp; både tajt styrning och bra respons i gaspedalen. 498 km räckvidd. Fyrhjulsdrift. Apple Carplay. Bra ljud. Självklart fina lastutrymmen. Eller som mitt sällskap konstaterar några timmar senare när jag tar ut bilen på en obligatorisk shoppingrunda: <br>– Med en sån här bil har man inga bekymmer i världen.</p>



<figure class="wp-block-gallery has-nested-images columns-default is-cropped wp-block-gallery-2 is-layout-flex wp-block-gallery-is-layout-flex">
<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/10/FannyAriya_030_EDIT.jpg"><img data-id="27640" src="https://elbilen.se/wp-content/uploads/2023/10/FannyAriya_030_EDIT-1030x687.jpg" alt="" class="wp-image-27640"/></a><figcaption class="wp-element-caption"><br>Fyrhjulsdrivna Nissan Ariya e4orce med 87 kWh stort<br>batteri gör sommarsemestern enkel. Räckvidden ligger kring 40 mil på motorväg, när den är fulladdad.&nbsp;</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/10/FannyAriya_036_EDIT.jpg"><img data-id="27637" src="https://elbilen.se/wp-content/uploads/2023/10/FannyAriya_036_EDIT-1030x687.jpg" alt="" class="wp-image-27637"/></a><figcaption class="wp-element-caption"><br>Laddlucka fram till<br>höger, ganska smidigt.</figcaption></figure>
</figure>



<p>Det har dock framgått att det kan vara lite meckigt att snabbladda.<br>Tydligen måste man ladda ner <em>appar</em> och <em>registrera</em> <em>betalkort</em>. Dyngsur kan man också räkna med att bli, för det finns nämligen inte en enda laddplats i hela världen som har tak. Källa: Tibor Blomhälls samtliga krönikor.&nbsp;</p>



<p>Och nu ska den ut på elbilssemester, till Småland och Öland. Det här kommer gå bra, det känner jag, trots att jag i princip inte har planerat en sekund av resan. För en sak som jag faktiskt har snappat upp under åren på den här tidningen är att räckvidd inte längre är någon större grej. Det var länge sedan jag läste om räckviddsångest.</p>



<p>Jag fnyser präktigt för mig själv och bestämmer mig för att ta mig an veckans eventuella problem vid laddstolparna som spännande utmaningar. Kanske att man till och med kan gå så långt som att beskriva det som möjligheter? Ja, jag nästan hoppas på att något ska gå riktigt snett, så att den här texten blir lite mer spännande. Jag ska tänka, ja <em>leva</em>, ”content” hela veckan.</p>



<p>Jag kanske träffar en kändis vid en snabbladdare? Tänk om exempelvis ”Parlamentet”-programledaren Anders S Nilsson har problem med att få igång sin laddning på Ionity-stationen i Gränna?&nbsp;</p>



<p>Helt oförberedd är jag inte, Fredrik har berättat att det är i appen Chargefinder det händer. Där kan man se var alla publika laddare finns, och filtrera efter nånting nånting (jag sa ju att jag inte lärt mig orden) och på så vis få fram snabbladdarna.&nbsp;</p>



<figure class="wp-block-gallery has-nested-images columns-default is-cropped wp-block-gallery-3 is-layout-flex wp-block-gallery-is-layout-flex">
<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/10/IMG_1842_EDIT.jpg"><img data-id="27648" src="https://elbilen.se/wp-content/uploads/2023/10/IMG_1842_EDIT-1030x687.jpg" alt="" class="wp-image-27648"/></a><figcaption class="wp-element-caption"><br>Okej utsikt.&nbsp;</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/10/IMG_1843_EDIT.jpg"><img data-id="27649" src="https://elbilen.se/wp-content/uploads/2023/10/IMG_1843_EDIT-1030x687.jpg" alt="" class="wp-image-27649"/></a><figcaption class="wp-element-caption"><br>Nära till glass.&nbsp;</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/10/IMG_1839_EDIT.jpg"><img data-id="27650" src="https://elbilen.se/wp-content/uploads/2023/10/IMG_1839_EDIT-1030x687.jpg" alt="" class="wp-image-27650"/></a><figcaption class="wp-element-caption"><br>13 + 30 minuters tid att blicka inåt vid Ionity i Gränna. Man får räkna med viss kö om man semestrar längs E4 mitt i<br>sommaren.</figcaption></figure>
</figure>



<p>Det är därför detta jag gör kvällen innan avfärd mot Växjö, som är vårt första mål. Fast nu är jag på jakt efter en normalladdare som kan fylla bilen till hundra procent under natten. Att ladda till hundra procent vid en snabbladdare är nämligen belagt med dödsstraff i elbilscommunityt. Efter 80 procent gör du bäst i att lämna plats åt nästa person med laddtorsk. I alla fall om det är kö.&nbsp;</p>



<p>Efter att med visst darr på handen klarat av mitt livs första laddning, som mycket riktigt bjöd på möjligheten att registrera ett betalkort, är bilen fulladdad och äventyret kan börja.</p>



<p>Den här resan, Stockholm–Växjö, har jag kört tusen gånger. Det tar vanligtvis drygt fem timmar inklusive obligatoriskt Donkenbesök i Linköping. Tanka gör man kanske också någonstans på vägen, det är inte så noga, det sker i farten. Men nu känner jag mig plötsligt nervös. Ska jag alltså ändå behöva planera? Hur mycket ska en kvinna behöva anstränga sig? Men vi kommer säkert klara oss till Ionity i Mantorp, tror Fredrik. Man får ha lite koll.&nbsp;</p>



<p>Redan i höjd med Midsommarkransen börjar det pratas om hunger i baksätet, som för övrigt är så luftigt att det nästan är löjligt. Frågan är om det ens är lagligt med så här mycket plats för ben och packning och kuddar och godispapper.&nbsp;</p>



<p>– Kan vi inte stanna på första bästa McDonald’s? ekar det i fjärran och jag lyckas förhandla fram KFC i Nyköping som ett första stopp.&nbsp;</p>



<p>Vi anländer dit med 67 procent batteri kvar, och nu är frågan hur långt vi kommer härifrån innan vi måste ladda. Nervositeten tilltar och jag gör det enda rimliga: messar Fredrik. ”Vi är i Nyköping, 192 km till Mantorp. Bilen säger nåt med 300 km. Ska vi satsa på det?”&nbsp;</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/10/IMG_1872_EDIT.jpg"><img src="https://elbilen.se/wp-content/uploads/2023/10/IMG_1872_EDIT-1030x515.jpg" alt="" class="wp-image-27652"/></a><figcaption class="wp-element-caption">Utefrukost i Ingelstad. Morfar Magnus i en naturlig mitt i steget&#8211;pose.</figcaption></figure>



<p>Inget svar. I’m on my own. I stället för att bryta ihop väljer jag att bli övermodig – nog borde vi klara oss lite längre än till Mantorp om bilen säger nåt med 300 kilometer? Nä, stanna och ladda i Mantorp är för töntar. Jag fylls av tillförsikt, knappar in Ionity i freaking <em>Gränna</em> på GPS:en, höjer volymen och kör som den motorvägens rebell jag är vidare söderut.&nbsp;</p>



<p>När vi med goda 17 procent kvar i batteriet svänger in vid Ionitys laddstation i Gränna är det kö till laddarna. Men vädret är strålande, liksom utsikten över Vättern, barnen är utlovade glass och bilkön som skapats är underbart svensk och tydlig, så jag parkerar bakom en ID Buzz och ler harmoniskt mot alla mina medladdare. Vi är ett härligt gäng, känner jag, mer sammansvetsade än fossilklungan på macken bredvid som knappt hinner titta på varandra, än mindre le harmoniskt, innan de tankat klart och måste jäkta vidare. Ha! Vi elriddare har vett att uppskatta nuet. Vi flyr inte från oss själva. Vi har hittat lugnet inom oss.&nbsp;</p>



<p>När det efter 13 minuters underbar väntan och endast fem stycken ”när är det vååår tur?” blir just vår tur att ladda får jag hjälp att backa på plats vid stolpen av en ovanligt lång och entusiastisk skåning.&nbsp;<br>– Och så fullt rattutslag nu! Nej, andra hållet! Så ja!<br>Men vänta lite – det är ju Anders S Nilsson, ”Parlamentet”-programledaren! Tänka sig, att just han skulle vara här.&nbsp;</p>



<p>Att behöva extern hjälp med backningen är egentligen bortom pinsamt; klarar man inte av att backa med den här bilen som har kameror åt alla håll och skärm som till och med visar bilen ovanifrån (Fredrik säger att det är någon slags AI, men jag väljer att beskriva det som ett teknikens mirakel) så kanske man ska fundera på att vara passagerare i stället för förare. Men nu är ju barnen under 18, och vem är förresten jag att tacka nej till live-­assistans av en folkkär tv-profil? <br><br>Jag får plågsamma flashbacks till för några veckor sedan då David Sundin höll upp porten till förskolan åt mig och jag glatt utbrast ”tackar tackar!” som svar. Detta är min chans till upprättelse, tänker jag, kväver impulsen att säga ”här får man tips från coachen minsann!” och tackar Anders S Nilsson på vad jag tror är ett helt normalt sätt (jag säger tack).</p>



<figure class="wp-block-gallery has-nested-images columns-default is-cropped wp-block-gallery-4 is-layout-flex wp-block-gallery-is-layout-flex">
<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/10/IMG_1856_EDIT.jpg"><img data-id="27654" src="https://elbilen.se/wp-content/uploads/2023/10/IMG_1856_EDIT-687x1030.jpg" alt="" class="wp-image-27654"/></a><figcaption class="wp-element-caption"><br>Barnen trivdes så bra<br>att de ville sova i bilen. Takfönstret höjde mys-faktorn till max.</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/10/IMG_1888_EDIT.jpg"><img data-id="27655" src="https://elbilen.se/wp-content/uploads/2023/10/IMG_1888_EDIT-687x1030.jpg" alt="" class="wp-image-27655"/></a><figcaption class="wp-element-caption"><br>Exotiska åsnor på<br>Ingelstad djurpark.</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/10/IMG_2010_EDIT.jpg"><img data-id="27656" src="https://elbilen.se/wp-content/uploads/2023/10/IMG_2010_EDIT-687x1030.jpg" alt="" class="wp-image-27656"/></a><figcaption class="wp-element-caption"><br>Ölands djurpark – med tivoli som var lika kul för 6-åringen som <br>för 14-åringen &#8230;</figcaption></figure>
</figure>



<p>Det visar sig att han har haft problem med att få igång sin laddning, och att han tillbringat den senaste halvtimmen med att gå runt och be om hjälp. Vilket han naturligtvis fick, vi i är ju ett solidariskt gäng vi. Detta är hans första resa med en elbil, en hyr-mg. Det har tagit honom otroligt mycket längre tid än vanligt att ta sig från Stockholm hit, och han lär inte vara framme i Skåne förrän sent ikväll, men han är självklart lika glad för det, för han har ju semester.<br>Och är en elriddare. Och kändis.&nbsp;</p>



<p>Den första snabbladdningen är genomförd. Det tog prick 30 minuter från 17 till 81 procent och kostade<br>420 kronor. Vi anländer till Växjö med 40 procent kvar. Great success.</p>



<p>Imorgon ska vi på en spännande utflykt och titta på zebror och känguruer i Ingelstad, och det kanske är lika bra att slänga in lite el i Ari och samtidigt få 30 minuters värdefull egentid. Men kan man göra det, duttladda lite då och då? Man vet ju att mobiler mer eller mindre exploderar om man okynnesladdar dem i stället för att låta batterierna ladda ur helt mellan varven. Jag kontaktar Elbilsjouren (Fredrik) som har lugnande sms-besked: ”Litiumbatterier har ingen minneseffekt och kan duttladdas hur mycket som helst. Det gäller även din telefon. Det var länge sedan telefoner inte skulle duttladdas. Skärpning”.&nbsp;</p>



<p>Chargefinder guidar mig till OKQ8 i industriområdet Norremark och jag parkerar vid en av de fyra laddstolparna.&nbsp;<br>– Vilket väder vi fått! ropar David Hellenius glatt från platsen bredvid.&nbsp;<br>Nä, skojar. Jag är alldeles ensam, och den här gången är det precis så lätt att ladda som Tibor och co drömmer om: jag bara blippar mitt betalkort. Sen är det bara att vänta. Meditera, blicka inåt, kanske möta Gud, vem vet. 148 kronor kostar den 20 minuter långa laddningen från 40 till 70 procent, men flera dagar senare är det fortfarande 500 kronor reserverat på mitt kort. Det är lika bra det.</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/10/IMG_1865-kopiera_EDIT.jpg"><img src="https://elbilen.se/wp-content/uploads/2023/10/IMG_1865-kopiera_EDIT-1030x515.jpg" alt="" class="wp-image-27657"/></a><figcaption class="wp-element-caption">Snabbladdning vid OKQ8 Norremark. Bilen bredvid är gissningsvis inte eldriven.&nbsp;</figcaption></figure>



<p>Efter en dag fylld av exotiska djur i småländsk natur, innan färden går vidare mot Ölands djurpark och en dag fylld av exotiska djur i öländsk natur, kör jag på ännu en laddutflykt. Den här gången till Circle K Samarkand i Växjö. Här kan man inte blippa kortet utan får välja mellan att ladda ner en app och att engångsbetala genom att scanna en QR-kod som leder till en sajt där man får fylla i sina kortuppgifter. Självklart väljer jag engångsbetalningen: <em>tänk alltid kort­siktigt</em> är nämligen mitt livsmotto.&nbsp;</p>



<p>Att ladda elbil i närheten av en handelsplats är lite mer spännande än i ett industriområde. Det är dock sämre för ekonomin, eftersom det är lätt hänt att man slinker in på Netonnets lagershop som ligger granne med Circle K och impulsköper exempelvis en 24-liters party cooler för 699 kronor, eller varför inte en rullbar luftkonditionerare för ett behagligt inomhusklimat för endast 1&nbsp;490 kronor.&nbsp;</p>



<p>Valet att engångsbetala visar sig vara inte fullt så ”smidigt” som det först verkade, för när jag återvänder från Netonnet med min rullbara luftkonditionerare (skojar igen) kan jag inte avsluta laddningen. På sajten har jag blivit utloggad och när jag försöker ”ansluta” igen på samma stolpe står det att laddaren är upptagen av en lätt förvirrad trebarnsmamma med problematiskt shoppingbeteende och diskutabelt livsmotto (<em>tonen?</em>). Äntligen en äkta ladd­utmaning! jublar jag och går in i butiken och ber om hjälp.&nbsp;</p>



<p>– Ring numret som står på laddstolpen, säger mannen i kassan på ett sätt som får mig att misstänka att han har sagt det några gånger förut.&nbsp;<br>Ett samtal till en telefonjour brukar innebära en stor del telefonkö och en liten del hjälp, men på det här numret får man hjälp direkt. Jag känner mig utvald och speciell och drar slutsatsen att snabb telefonassistans är ett privilegium som vi elriddare verkligen förtjänar.&nbsp;<br>Nu har jag laddat från 47 till 90 procent (oops) på en dryg halvtimme och det kostar 265 kronor.&nbsp;</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/10/IMG_1917-kopiera_EDIT.jpg"><img src="https://elbilen.se/wp-content/uploads/2023/10/IMG_1917-kopiera_EDIT-1030x579.jpg" alt="" class="wp-image-27659"/></a><figcaption class="wp-element-caption">Laddning med möjligheten att kontakta telefonsupporten.</figcaption></figure>



<p>Väl på Öland börjar jag bli varm i kläderna. Vi kan det här nu. Man kör omkring som vanligt och så stannar man och laddar. Jag tänker inte ens börja planera! Lite mer meck är det förstås. Vi väljer till exempel att åka till turistfällan Böda sand, där det finns laddare, i stället för underbara pärlan Lyckesand en bit bort, där det inte finns laddare.&nbsp;</p>



<p>Sista kvällen i Borgholm, innan hemfärd mot Stockholm, uppstår ännu en spännande utmaning vid en publik laddstolpe. Nämligen den att jag startar laddningen, men återigen tappar kopplingen till sajten eller vad det nu är som jag är inne på för att börja ladda. Det är inte en app i alla fall, för någon sådan står det inget om på stolpen. </p>



<p>Det ser nu alltså ut som att jag laddar, men jag vet inte hur jag ska kunna avsluta. Jag ringer supporten som självklart svarar direkt och jag förklarar att jag har problem – förlåt, möjligheter – med stolpen som inte vill veta av mig och mitt betalkort. Killen i telefonen blir äkta imponerad över att jag över huvud taget har fått igång laddningen utan appen. Som tydligen ändå finns. Vi kommer överens om att jag ska ringa tillbaka när det väl är dags att avsluta laddningen. Han jobbar till klockan 22.&nbsp;</p>



<p>När jag återvänder till bilen ett par timmar senare är den fulladdad och kabeln går att dra ut, och inte en enda krona är dragen från mitt konto. Det här med att köra elbil och betala för sig verkar lite svajigt. Ibland reserveras dubbla belopp, ibland dras pengarna flera veckor senare, och ibland – om man har riktigt tur – så laddar man helt gratis.&nbsp; &nbsp;</p>



<p>Och bilen då? Nissan Ariya e4orce är lite som en dröm. Bättre än så kan jag inte beskriva körupplevelsen. Minsta tryck på gasen ger omedelbar effekt; det känns lite som att jag är ett med bilen, inte bara med vindrutan (ja, jag har en osedvanligt framåtlutad körstil). Det är lätt att gasa på lite väl mycket, men min hastighet projiceras i vindrutan, och under den ser man den tillåtna farten, och det blinkar uppfodrande om man kör minsta för fort. Lite störigt för en lättdistraherad människa som jag själv, men oerhört effektivt för en rättskaffens duktig flicka som aldrig vill göra fel, som jag själv. Det blir lite av en sport att så att säga köra blinkfritt.</p>



<p>Jag uppskattar att det finns en panel som man kan trycka på under själva skärmen, för att ställa in fläkt och värme. Den använder jag var femte minut och det är skönt att slippa klicka sig fram för sånt på en skärm.&nbsp;</p>



<p>Jag är inte helt överens med vindrutetorkarna om hur mycket regn en människa egentligen kan stå ut med innan det är dags att rensa rutan, men det är jag å andra sidan inte med människor heller. Det visar sig på sista dagen att man självklart kan ställa in hur snabb autofunktionen är och jag har stört mig helt i onödan.&nbsp;</p>



<figure class="wp-block-gallery has-nested-images columns-default is-cropped wp-block-gallery-5 is-layout-flex wp-block-gallery-is-layout-flex">
<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/10/IMG_2156-kopiera_EDIT.jpg"><img data-id="27662" src="https://elbilen.se/wp-content/uploads/2023/10/IMG_2156-kopiera_EDIT-1030x687.jpg" alt="" class="wp-image-27662"/></a><figcaption class="wp-element-caption"><br>Böda Sand. Snabbt ombyte till badkläder, men vi får hålla oss i närheten i 45 minuter innan vi kan gå och bada eftersom bilen måste parkeras om<br>– lite meckigt är det allt med elbil.&nbsp;</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/10/IMG_2178-kopiera_EDIT.jpg"><img data-id="27661" src="https://elbilen.se/wp-content/uploads/2023/10/IMG_2178-kopiera_EDIT-1030x687.jpg" alt="" class="wp-image-27661"/></a><figcaption class="wp-element-caption">Gratis laddning i Borgholm.</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/10/IMG_2188-kopiera_EDIT.jpg"><img data-id="27660" src="https://elbilen.se/wp-content/uploads/2023/10/IMG_2188-kopiera_EDIT-1030x687.jpg" alt="" class="wp-image-27660"/></a><figcaption class="wp-element-caption">Blöt laddning i Nyköping.</figcaption></figure>
</figure>



<p>Sista dagen är också dagen då Ari verkligen ska visa vad hon går för. Svaret är: från Borgholm till Nyköping utan stopp. Hela resan har faktiskt gått över all förväntan. Barnen trivs så bra i baksätet att de inte ens kommer en slentrianprotest från dem när det är dags för laddpauser, även när det regnar och vi måste stanna i bilen (Tibor har rätt, taken lyser med sin frånvaro). Sitta still som sitta still, de bryr sig inte om att bilen inte rör sig.&nbsp;</p>



<p>Men innan det är dags att skiljas från bilen bjuds jag på en allra sista ladd­stolpsutmaning i form av de förvirrade belarusierna som irrat runt i hela stan i jakt på el. Så tillbaka till dem. Ni minns, kvinnan i korta shorts?</p>



<p>Jag undrar försynt om de inte vill köra några kilometer till och (eventuellt) ladda gratis på Teslas Supercharger i Sollentuna i&nbsp;stället.&nbsp;<br>– I don’t <em>care</em> about the money! I just want to charge and move on, säger mannen i sällskapet (hennes make eller pappa, det är omöjligt att avgöra) uppgivet och viftar med ett guldigt betalkort.&nbsp;</p>



<p>Jag hjälper dem att dra igång laddningen och tar därefter ett stolt andetag och försöker ta in det stora i att det nu är jag som är proffset. Det är min tur att sprida evangeliet. Cirkeln är sluten. Nu är det jag som är Fredrik. Je suis Frédérick.<br>– Chargefinder, säger jag världsvant, det är där det händer. You should check it out.</p>



<p>Det har de aldrig ens hört talas om, och jag ler överseende och visar hur man filtrerar på kilowatt (äsch, det vet väl varje människa att det är så det heter), och shortskvinnan är så tacksam, så tacksam, och jag önskar dem en trevlig semester i Sverige.&nbsp;<br>Sedan kör jag norrut mot Kista för att lämna tillbaka Ari.&nbsp;<br>Jag kommer sakna henne nästan lika mycket som Volvis.</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/10/nissan_1.jpg"><img src="https://elbilen.se/wp-content/uploads/2023/10/nissan_1-1030x687.jpg" alt="" class="wp-image-27646"/></a></figure>



<p class="has-luminous-vivid-orange-background-color has-background has-medium-font-size"><strong>FAKTA: Nissan Ariya E-4orce Evolve</strong></p>



<figure class="wp-block-table is-style-stripes"><table><tbody><tr><td><strong>Pris:</strong> 653.200 kr.</td></tr><tr><td><strong>Räckvidd:</strong> 498 km.</td></tr><tr><td><strong>Förbrukning:</strong> 2,04 kWh/mil.</td></tr><tr><td><strong>Batteri:</strong> 87 kWh.</td></tr><tr><td><strong>Snabbladdning:</strong> 130 kW.</td></tr><tr><td><strong>Normalladdning:</strong> 22 kW.</td></tr><tr><td><strong>Drivning:</strong> Fyrhjulsdrift.</td></tr><tr><td><strong>Motoreffekt:</strong> 225 kW.</td></tr><tr><td><strong>Vridmoment: </strong>600 Nm.</td></tr><tr><td><strong>0-100 km/h:</strong> 5,7 sek.</td></tr><tr><td><strong>Antal platser:</strong> 5.</td></tr><tr><td><strong>Yttermått LxBxH: </strong>4.595&#215;1.850&#215;1.650 mm.</td></tr><tr><td><strong>Bagage:</strong> 415 liter.</td></tr><tr><td><strong>Tjänstevikt:</strong> 2.323 kg.</td></tr><tr><td><strong>Batterigaranti:</strong> 8 år/16.000 mil.</td></tr></tbody></table></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2023/10/FannyAriya_008_EDIT.jpg"><img src="https://elbilen.se/wp-content/uploads/2023/10/FannyAriya_008_EDIT-1030x549.jpg" alt="" class="wp-image-27663"/></a><figcaption class="wp-element-caption">Ariya är en riktig bjässe även brevid 172 centimeter långa Fanny.</figcaption></figure>



<p class="has-text-align-right"><em><strong>Reportage från Elbilen 8/2023<br>Foto Peter Gunnars och Fanny Lundstedt</strong></em></p>
