Test: Volvo XC40 Recharge – Aj då …


<p class="has-medium-font-size"><strong>Trots ett väl tilltaget batteripack klarar inte svensken vårt bistra klimat. Energiförbrukningen är hög och laddkapaciteten för klen på långturen upp till Jokkmokk från Stockholm som slutade med en flygresa.</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>Min fru fyller år. Hon vill ha ett smycke från Jokkmokk med traditionellt samiskt motiv. I dessa tider är det svårt att lita på Postnord. Det är bäst att hämta det själv. Jag packar direkt en Volvo XC40 Recharge P8 AWD och sätter kurs mot Lappland.</p>



<p>Vintern har överraskat med kyla och snö. Men Volvos första elbil är fyrhjulsdriven med två motorer på 150 kW vardera. Med antispinnsystemet på helspänn drar jag norrut på odubbade vinterdäck. Första sträckan sker i plus tre grader. </p>



<p>Jag ska säga att jag har sett fram emot det här. Globalt sett är Sverige en liten marknad. De stora marknaderna har ett klimat som sällan ger någon snö. <br>Volvo känns tryggt. Bilarna är framtagna och anpassade efter hemlandets klimat. Det är sedan länge. För även om Volvo ägs av kineserna, så finns det svenska dna:t fortfarande kvar. Hoppas jag. </p>



<p>Första stoppet efter starten från Stockholm sker i Gävle, 17 mil norrut.&nbsp; Batterierna var laddade till bristningsgränsen vid avfärd och när jag parkerar utanför Max och pluggar in har jag 32 procent kvar av batteriet. Jag hade alltså kunnat köra ytterligare åtta mil innan batteriet var tomt. Men norr om Gävle börjar den mer bitande vintern. Fem mil norrut finns en laddare i Söderhamn, men den står vid en bensinstation, och vi var inte sugna på mack-käk.&nbsp;</p>



<p>Det hade också varit aningen spännande att fortsätta med de små marginalerna. Vi får i oss en burgare på Max och har laddat till 80 procent efter 47 minuter. <br>Vi bör ta oss till Sundsvall, 21,3 mil norrut. Vi ska precis klara det säger bilen. Men så spännande ska vi inte ha det, tänker jag. Fem procents marginal i smällkalla vintern är inget för mig. Så vi smiter in i Hudiksvall på en nyöppnad Ionity-laddare och stannar 15 minuter och laddar med cirka 80 kW. </p>



<p>Nästa stopp: Laddaren i Sundsvall, som är placerad före stan vid en Cirkle K-mack. En körning på sju mil. Där blir vi stående i 50 minuter. Från 29 procent till 87 procent. Vid 87 procent laddar bilen med 15 kW. Aningen bättre än ett trefasuttag alltså. </p>



<p>Nu ska vi klara sista sträckan till övernattningen i Örnsköldsvik, 16 mil norrut. Det är halt. Vi har odubbade däck. I Sundsvall släppte greppet på motorvägen. Jag tar det försiktigt. Vi klarar sträckan med försiktig körning. Dryga 60 procent av batteriet krävs för den sträckan. Nu har det blivit minusgrader, cirka 8 under nollan. <br>Vi sover över i Örnsköldsvik, laddar under natten. På morgonen har vi bara 70 procent, eftersom att vi bara fått med oss en kabel som kan ta enfas. Trots att Volvon kan ta trefas.</p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-11-1030x581.jpg" alt="" class="wp-image-18719"/><figcaption class="wp-element-caption">Bra vägegenskaper med fyrhjulsdriften trots odubbade vinterdäck. Det är dock att rekommendera dubbar på isiga vägar hur bra antisladdsystemet än är.</figcaption></figure>



<p>Nu har vi 42 mil kvar till första målet innan Jokkmokk. Det ska enligt Google Maps ta fem timmar och fem minuter där vi ska övernatta. <br>Det är kristallkart väder och ingen snöyra. Jag lägger mig strax under hastighetsgränsen. Hur lång tid tar då den här 42 mil långa sträckan i 12 minusgrader, med de laddstopp som krävs? Sju timmar och 35 minuter är svaret. </p>



<p>Snövallarna har inte varit så här höga sedan jag var liten. Det går inte att se över kanten på vissa ställen. Genom det frusna norrbottniska landskapet styr vi Volvos första elbil från laddare till laddare. Det känns som om vi har hamnat i twilight-zone. Eller i filmen Måndag hela veckan.&nbsp;</p>



<p>Det krävdes att vi laddade i Umeå, Skellefteå och Piteå.&nbsp;42 mil och tre laddstopp.&nbsp;Och inte vilka laddstopp som helst. I Umeå, alltså efter cirka tolv mils körning, blir vi sittande i 45 minuter. I Skellefteå 13 mil bort fastnade vi i 32 minuter.&nbsp;Sju mil senare stannar vi i Piteå. Laddtid: 42 minuter.</p>



<p>Vi hade nog kunnat kapa tiden om vi haft en trefaskabel och lämnat Örnsköldsvik med fulla batterier. Då hade vi inte kunnat ta oss till Ånäset. Och sedan tagit oss till Piteå. Det är 17,8 mil mellan Örnsköldsvik och Ånäset. <br>Men det hade inte gjort jättestor skillnad eftersom man laddar i en tämligen låg hastighet. Det är 50 kW-laddare och de ger inte mer än max 40 kW. Det går trögt, framför allt över 50 procent. Och batteriet är stort. </p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-7-1030x686.jpg" alt="" class="wp-image-18715"/></figure>



<p>Energiförbrukningen ligger konstant på strax under 3 kWh/mil. Med hög energiförbrukning kommer med ens kravet på rejäla laddstationer om minst 150 kW. De finns inte norr om Sundsvall, med ett undantag: i Luleå. <br>Med det kommer också krav på att bilen ska klara att ladda med hög effekt. Det gör inte Volvo. Det här gör Volvos elbil till en sävlig bil trots sin acceleration på 0–100 på under fem sekunder. </p>



<p>När man kör i de här temperaturerna, när det nyss har varit snöstorm, vill man ha en buffert. Jag har blivit sittande på E4:an i Norrland i många timmar efter att en långtradare har fått sladd och placerat sig över hela vägbanan. Det kan börja snöa kraftigt och bli svårframkomligt, vilket ger ökad förbrukning. Därför bör man planera för en buffert när man kommer fram. Jag siktade på en planerad körning med 15–20 procent kvar i batterierna vid målet. Volvo XC40 R8 AWD laddar kopiöst långsamt över 80 procent. Det går inte att lägga över en timme eller till och med två, som bilen föreslår vid varje laddstopp.&nbsp;</p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-12-1030x677.jpg" alt="" class="wp-image-18720"/><figcaption class="wp-element-caption">Det frostiga Norrbotten gav storslagen vinterkörning i strålande solsken.</figcaption></figure>



<p>Det innebär att man får ett spann på 60 procent att köra på. Med en förbrukning på cirka 3 kWh per mil ger det en räckvidd i vinterklimat på 15 mil. <br>Laddarna är inte placerade med exakt 15 mil mellan mina laddstopp. Därför får man köra in i varje stad som dyker upp och fylla på. Vi sover över i Norrbotten, vid kusten innan vi tar sista benet till Jokkmokk. </p>



<p>Bilen klarar med nästan fulla batterier att köra upp till fjällvärlden, vilket är en stigning på 240 meter. Från Boden till Jokkmokk i minus 12 grader – en sträcka på 13,4 mil – krävs 60 procent av batterierna. <br>Jokkmokk är tämligen ödsligt i januari månad. Tyst, kallt med massiva snökarmar promenerar vi ner på byn och smiter in på Sameslöjdstiftelsen Sámi Duodji.</p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-8-1030x595.jpg" alt="" class="wp-image-18716"/></figure>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p>”Jag beställer en taxi som tar mig till flygplatsen. Köper flygbiljett. När jag har checkat in och är på väg mot avgången ringer de från Volvo &#8230;”</p>
</blockquote>



<p>Vi tar på oss munskydd, vilket är krav, och väljer ut ett par örhängen. Mission completed. Nästan. Nu gäller det bara att ta sig hem till födelsedagen. Vi har två dagar på oss. <br>Det är onsdag. Födelsedagen är lördag. Vi börjar med att sova över i Jokkmokk, eftersom det inte finns någon snabbladdare. Enfaskabeln pluggas in på ett trefasuttag, men vi får som sagt endast 3,7 kW. <br>På torsdagen åker vi till kusten. Vi har några ärenden där, och beger oss på fredagsmorgonen mot Stockholm. På en dag borde det vara görbart. </p>



<p>Temperaturen har sjunkit till –27 grader när vi startar. Förbrukningen hamnar då på 3,8 kWh per mil. Vi måste snabbladda i Luleå. Där finns en 175 kW-laddare. När vi kommer dit är det kö. Två bilar före. Vi åker till en 50-kW-laddare som drivs av Incharge. Den startar inte. Inte snabbladdningen. Inte trefasuttaget. Jag ringer Incharge. De noterar inget fel på laddaren. Vi kör till Kallax flygplats. Nu är temperaturen nere på –17 grader. Snabbladdaren på Kallax drivs av Luleå Energi. Den fungerar inte heller. Vi har 20 procent kvar av batterierna.&nbsp;</p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-9-1030x567.jpg" alt="" class="wp-image-18717"/><figcaption class="wp-element-caption">Nyöppnad Ionity-<br>laddare i Hudiksvall.</figcaption></figure>



<p>Jag kontaktar Volvo, och kör bilen till Bilbolaget och lämnar in den på verkstaden. Där får jag beskedet att den enda som kan ta hand om elbilen inte är inne, utan kommer in veckan efter. <br>Jag blir erbjuden att plocka ut en hyrbil. Det är bara det att alla är uthyrda.  Jag beställer en taxi som tar mig till flygplatsen. Köper flygbiljett. När jag har checkat in och är på väg mot avgången ringer de från Volvo och berättar att de har löst problemet. De hade gjort en uppdatering av mjukvaran. Jag kan hämta bilen. Det är försent. Jag hade aldrig hunnit i tid. Jag hade inte heller fått tillbaka pengarna för flygbokningen. </p>



<p>Det ska också erkännas. Jag har inget emot att köra långt med elbil. Jag tar gärna laddpauser. Men Volvo gav inte mersmak. Deras första riktiga elbil är ingenting för det svenska vinterklimatet. <br>I den första testbilen som Volvo tillverkade i få exemplar för cirka tio år sedan, C30, hade de en etanoltank som man kunde fylla på och som gav värme till kupén. En inte helt osmart lösning. Det är nästan att jag önskar mig en sådan under trippen. Jag sa nästan. </p>



<p>Det är svårt att rekommendera den här bilen till någon som bor i landets norra breddgrader, eller som  vill köra längre turer där det är kallt.  <br>Det är synd. Bilen är galet komfortabel och rymlig trots kardantunnel. Googles infotainmentsystem är grymt. Kartfunktionerna mycket bra. <br>Beräkningarna på hur många procent man kommer att ha vid målet som man matar in är väldigt precisa. De är bara för få.</p>



<div class="wp-block-cover"><span aria-hidden="true" class="wp-block-cover__background has-black-background-color has-background-dim-100 has-background-dim"></span><div class="wp-block-cover__inner-container is-layout-flow wp-block-cover-is-layout-flow">
<p class="has-text-align-center has-large-font-size">Räckviddsberäkning vinter</p>



<p>Hur ska man köra elbil på vintern? Vi ville ha en buffert&nbsp;</p>



<p>för oförutsägbara händelser. Det parat med hög elförbrukning och trög laddningen över 80 procent gav långsam körning på långturen:&nbsp;</p>



<p>Vi ligger konstant på en förbrukning kring 3 kWh per mil vilket ger en räckvidd på 20–25 mil. Blir det minus 20 grader åker förbrukningen upp till närmare 4 kWh per mil och en räckvidd under 20 mil. När man kör med buffert och inte vill ladda över 80 pro-</p>



<p>cent ger det en räckvidd på cirka 15 mil i beskedlig körning på vintern. Det är inte optimalt. Men det fungerar för den som inte&nbsp;</p>



<p>vill ge sig ut på längre resor i kyla. Vintern var hård mot Volvo.&nbsp;&nbsp;&nbsp;</p>



<p>Kostnadskalkylen&nbsp;</p>



<p>Privatköp: Nypris 699 000 kr: 6 514 k/mån (med kontantinsats 20% (139 980 kr) utslagen: 10 403 kr/mån). Beräknat på halverat restvärde efter 3 år.&nbsp;</p>



<p>Privatleasing: 7 995 kr/mån.</p>



<p>förmånsvärde 2021: 5 100 kr/månad för grundversionen.</p>



<p>• 1:a service vid 3 000 mil/2 år: 2 699 kr.</p>



<p>• 2:a service vid 6 000 mil/4 år: 3 693 kr.</p>



<p>• 3:e service vid 9 000 mil/6 år: 2 699 kr.</p>



<p>• 4:e service vid 12 000 mil/8 år: 3 696 kr.</p>
</div></div>



<p></p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-6-1030x584.jpg" alt="" class="wp-image-18714"/><figcaption class="wp-element-caption">Bra drag i Volvos första riktiga elbil.</figcaption></figure>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-10-1030x595.jpg" alt="" class="wp-image-18718"/><figcaption class="wp-element-caption">Laddning i Skellefteå. Gick&nbsp;smidigt, trots den nästan igen- snöade snabbladdaren.<br></figcaption></figure>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-13-1030x672.jpg" alt="" class="wp-image-18721"/><figcaption class="wp-element-caption">Mission completed.&nbsp; Vi nådde Jokkmokk för inköp av present efter en lång körning från Stockholm.&nbsp;<br></figcaption></figure>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-14.jpg" alt="" class="wp-image-18722"/><figcaption class="wp-element-caption">Mission completed.&nbsp; Vi nådde Jokkmokk för inköp av present efter en lång körning från Stockholm.<br></figcaption></figure>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-15-1030x339.jpg" alt="" class="wp-image-18723"/><figcaption class="wp-element-caption">Här på Bilbolaget i Luleå slutar resan för Volvo XC40 Recharge P8 AWD efter att den inte gick att ladda. En taxi plockade upp oss och körde oss till flygplatsen.</figcaption></figure>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-16-1030x652.jpg" alt="" class="wp-image-18724"/></figure>
</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-17-1030x674.jpg" alt="" class="wp-image-18725"/></figure>
</div>
</div>



<h2 class="wp-block-heading">Testfakta &#8211; Volvo XC40 Recharge</h2>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p>Betyg</p>
</blockquote>



<p>Köregenskaper: Här sitter allt på plats. Det är tajt, smidigt, snabbt, kul och responsivt. Fyrhjulsdriften plogar genom snö, parerar på halkiga vägar och styrningen är precis och exakt. Den vassa accelerationen är svår att njuta av på odubbade vinterdäck i vinterföret.&nbsp;&nbsp;</p>



<p>Betyg: 5</p>



<p>Komfort: Volvo gör numera ingen besviken. Stolarna med de utfällbara lårstöden ger härlig komfort under hela sittningen. Perfekt chassi, som en del kan tycka vara lite hård, jag upplever den följsam. Aningen stötigt i baksätet, men inte farligt.&nbsp;</p>



<p>Betyg: 5</p>



<p>Säkerhet: Fem stjärnor i Euro NCAP för Volvo XC40 2018. Volvo har lagt mycket krut på att stabilisera upp batteripacket så att det fördelar kraft vid en kollision. Säkerhetssystemen är på topp på vår körning. Väl värt att lägga på assistentsystemet om man ska slå till.&nbsp;</p>



<p>Betyg: 5</p>



<p>Miljö: Batterierna kommer från Asien, antingen från LG Chem eller CATL. Hur miljöprofilen på de batterierna ser ut vet vi inte. Bilen är dessutom törstig på el. Men en Volvo utan utsläpp är värt högsta betyg.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</p>



<p>Betyg: 5</p>



<p>Autonomi: Riktigt bra system för filhållning. Det är i klass med Teslas autopilot. Det är dock lätt att man glömmer bort att rucka på ratten och bilen hotar med att stanna.&nbsp;</p>



<p>Betyg: 4</p>



<p>Utrustning: Volvo har ett&nbsp;utrustningspaket för cirka&nbsp;30 000 kronor där bland annat glastak, bättre ljud och förarstöd ingår.&nbsp;Efter det bör man lägga på värmepump för 6 900 kronor. Med trådlös laddning av mobilen landar man på cirka 750 000 kronor för en topputrustad bil. Trefaskabel ingår.&nbsp;</p>



<p>Betyg: 4</p>



<p>Utrymmen: Förvånansvärt rymlig för att inte vara byggd på en ren elbilsplattform även om en sådan hade gett ännu bättre space. Lastkapaciteten är duglig för bilens storlek.&nbsp;&nbsp;&nbsp;&nbsp;</p>



<p>Betyg: 3</p>



<p>Ekonomi: Det här är en dyr Volvo. Inga folkliga priser direkt, men å andra sidan får man den absolut bästa varianten av XC40 i fråga om prestanda och körupplevelse. En billigare variant med framhjulsdrift och mindre batteripack ska vara på väg.&nbsp;&nbsp;</p>



<p>Betyg: 3</p>



<p>Räckvidd: Energislukande bil, som i kyliga temperaturer blir frustrerande. Tester visar att Kias och Hyundais elbilar med mindre batteripack kommer åtta mil längre i bistert vinterklimat. Volvo har en hel del jobb med att få ner förbrukningen i kommande bilar. Kanske kan de även uppdatera den här bilen, med bättre mjukvara. Det ingår i konceptet. Uppdateringar alltså, frågan är bara om de kan förbättra detta.&nbsp;</p>



<p>Betyg: 3</p>



<p>Laddning: De utlovade 150 kilowatten ser vi inte snöröken av. Vi toppar på 80 kW. Korta stunder. Efter 80 procent är det mycket klent. Men när vi tar ut bilen efter att vi kommit hem för att testa laddningen efter uppdateringen presterar den bättre. Nu kan den ta 155 kW, hälsar Volvo! Den verkar också ladda snabbare över 80 procent. Kanske blir bilen ännu bättre med uppdateringar, som kan ske trådlöst.&nbsp;</p>



<p>Vår upplevelse försämrades av att vi bara hade med oss en enfaskabel. Bilen kan ladda med trefas vilket gör stor skillnad om man laddar över natten.&nbsp;&nbsp;&nbsp;</p>



<p>Betyg: 3</p>



<p>Utseende: XC40 har blivit en vanlig syn på vägarna. Elbilen sticker inte ut på många sätt, möjligtvis i fronten, med den stängda grillen. Det är lite tråkigt.&nbsp;</p>



<p>Totalt: 40 av 50 poäng</p>



<p>SUMMA SUMMARUM</p>



<p>En premiumbil som spelar i elitserien när det kommer till komfort och köregenskaper. Men som dessvärre lattjar i korpligan när det handlar om elbilspspecifika saker som energiförbrukning och laddkapacitet.&nbsp;</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p>Snabbfakta</p>
</blockquote>



<figure class="wp-block-table is-style-stripes"><table><tbody><tr><td>Ord. pris:</td><td>699 000 kr.</td></tr><tr><td>Batterikap:</td><td>78 kWh.</td></tr><tr><td>Deklarerad räckvidd:</td><td>418 km.</td></tr><tr><td>Snabbladdn:</td><td>150 kW.</td></tr><tr><td>Ombordladdare:</td><td>11 kW.</td></tr><tr><td>Drivning:</td><td>Fyrhjulsdrift.</td></tr><tr><td>Max motoreffekt:</td><td>300 kW.</td></tr><tr><td>Acceleration 0–100 km/h:</td><td>Ca 4,9 sek.</td></tr><tr><td>Topphastigh:</td><td>180 km/h.</td></tr><tr><td>Antal platser:</td><td>5.</td></tr><tr><td>Tjänstevikt:</td><td>2  150 kg.</td></tr><tr><td>Bagagevolym:</td><td>413/1 342 l.</td></tr><tr><td>Dragvikt:</td><td>1 500 kg.</td></tr><tr><td>Nybilsgaranti:</td><td>3 år.</td></tr><tr><td>Batterigaranti:</td><td>8 år/16 000 mil.</td></tr></tbody></table></figure>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-18-1030x731.jpg" alt="" class="wp-image-18726"/><figcaption class="wp-element-caption">Efter att bilen uppdaterats tar vi ut den och gör en testladdning. Den har då fått förbättrad prestanda. Den laddar aningen bättre i de högre registren än på vår långkörning och kan nu ta 155 kW istället för som tidigare 135. I plusgrader antar vi, minus 12 grader ger segare snabbladdning. &nbsp; &nbsp;</figcaption></figure>



<p>Förbrukning och räckvidd: Temperatur: -11 grader. Officiell&nbsp;</p>



<p>Räckvidd: 418 km WLTP. Räckvidd på långa provkörningen: 22 mil i minus tio grader vid kallstart. Snittförbrukning: 3–3,5 kW/mil.</p>



<div class="wp-block-media-text alignwide is-stacked-on-mobile"><figure class="wp-block-media-text__media"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-19-1030x675.jpg" alt="" class="wp-image-18727 size-full"/></figure><div class="wp-block-media-text__content">
<p>BATTERIER.&nbsp;</p>



<p>78 kWh stort, med 75 kWh tillgänglig energi. Inget platt batteripack. Man får leva med kardantunnel i elbilen.</p>
</div></div>



<div class="wp-block-media-text alignwide has-media-on-the-right is-stacked-on-mobile"><div class="wp-block-media-text__content">
<p>BAKSÄTE. Bra baksäten, men mest för två personer&nbsp;eller tre barn.&nbsp; &nbsp;</p>
</div><figure class="wp-block-media-text__media"><img src="https://elbilen.se/wp-content/uploads/2021/04/unnamed-2.jpg" alt="" class="wp-image-18728 size-full"/></figure></div>



<div class="wp-block-media-text alignwide is-stacked-on-mobile"><figure class="wp-block-media-text__media"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-20.jpg" alt="" class="wp-image-18729 size-full"/></figure><div class="wp-block-media-text__content">
<p>BAGAGE.</p>



<p>Bra med plats även under lastgolvet.</p>
</div></div>



<p></p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-21.jpg" alt="" class="wp-image-18730"/></figure>



<p>APP.&nbsp;</p>



<p>Volvo har en app till sin elbil, med grundläggande funktioner som att värma upp bilen och kontrollera laddning.</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/2021/04/unnamed-3.jpg" alt="" class="wp-image-18731"/></figure>



<p>LADDNING.&nbsp;</p>



<p>Det blir segt på vintern, speciellt på 50 kW-stationerna.</p>
</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/2021/04/unnamed-4.jpg" alt="" class="wp-image-18732"/></figure>



<p>DISPLAY.&nbsp;</p>



<p>Smidig, snabb, responsiv och mycket användbart system. Google har gjort underverk.</p>
</div>
</div>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-22.jpg" alt="" class="wp-image-18733"/></figure>



<p>FRUNK.&nbsp;</p>



<p>Perfekt för laddkabeln, även en mindre väska går in i frunken – front trunk.&nbsp;</p>
