9 HETA FRÅGOR

Text: Lotta Hedin | Foto: ISTOCKPHOTO Orsakar elbilar mer eller mindre klimatutsläpp än bensinbilar, om man räknar in batteriproduktionen? Hur ligger det till med barnarbetet i koboltgruvorna Kongo? Hur vanligt är det att elbilar orskar bränder? Och räcker elen? Vi har sökt svaren på nio heta frågor om elbilar. Är elbilar bättre för klimatet än […]


<pre class="wp-block-preformatted">Text: Lotta Hedin | Foto: ISTOCKPHOTO</pre>



<p><strong>Orsakar elbilar mer eller mindre klimatutsläpp än bensinbilar, om man räknar in batteriproduktionen? Hur ligger det till med barnarbetet i koboltgruvorna Kongo? Hur vanligt är det att elbilar orskar bränder? Och räcker elen? Vi har sökt svaren på nio heta frågor om elbilar.</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>



<h2 class="wp-block-heading">Är elbilar bättre för klimatet än bensin- och dieselbilar?</h2>



<p>Ja. I dagsläget beräknas en elbil spara 60–70 procent av växthusgasutsläppen under sin livstid jämfört med motsvarande fossildriven bil. I takt med att batteriproduktionen blir effektivare och mer av energin som kommer från förnybara källor minskar elbilarnas klimatpåverkan ytterligare.&nbsp;</p>



<p>Det går åt mycket energi för att tillverka batterier, men det har skett en snabb utveckling på området och tillverkningen har blivit betydligt mindre energikrävande än vad den var för 7–8 år sedan. I debatten om elbilars klimatpåverkan används dock ofta gamla beräkningar som är felaktiga.</p>



<p>Forskare räknar fortfarande med att tillverkningen av en elbil generellt sett ger upphov till större utsläpp av växthusgaser än tillverkningen av en fossilbil, på grund av batterierna. Men när bilarna börjar köra kommer de totala utsläppen från de fossildrivna bilarna snart ikapp, och går om elbilarna.&nbsp;</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-1 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<p>I mars 2019 presenterade IVL Svenska Miljöinstitutet tillsammans med bilhandlarnas branchförening Bil Sweden, Motormännen och laddoperatörernas branchorganisation Power Circle en gemensam informationskampanj där man bland annat slog fast att en liten elbil sparar 60–70 procent av växthusgasutsläppen under sin livstid (18 000 mil) jämfört med motsvarande fossildriven bil.&nbsp;</p>
</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<figure class="wp-block-image size-large is-resized"><img fetchpriority="high" decoding="async" src="https://elbilen.se/wp-content/uploads/2020/06/unnamed-8.jpg" alt="" class="wp-image-14929" width="282" height="244" srcset="https://elbilen.se/wp-content/uploads/2020/06/unnamed-8.jpg 372w, https://elbilen.se/wp-content/uploads/2020/06/unnamed-8-300x260.jpg 300w" sizes="(max-width: 282px) 100vw, 282px" /></figure>
</div>
</div>



<p>Uppgifterna baseras på en norsk studie. I uträkningen ovan har man utgått från att elbilen efter tillverkningen laddas med en svensk elmix. Men även om man utgår från att elbilen laddas med en europeisk elmix med en hög andel el från kolkraft, så blir klimatpåverkan lägre från elbilen.</p>



<p>Gamla siffror används i debatten. 2017 publicerade IVL Svenska miljöinstitutet en rapport där man som utifrån tidigare undersökningar räknade fram siffror på hur stor klimatpåverkan elbilars batteritillverkning gav upphov till. Flera av studierna som låg till grund för slutsatserna var redan när rapporten skrevs mellan fem och åtta år gamla. IVL säger nu själva att dessa siffror inte längre stämmer, och använder sig i stället av andra beräkningar. Men trots det hänvisar elbilskritiker ofta till rapporten från 2017.</p>



<p>I april presenterade till exempel det tyska ekonominstitutet IFO en studie där man kommit fram till att en elbil gav upphov till större klimatutsläpp än en dieselbil, om den kördes på tysk elmix. Undersökningen fick stort genomslag i media, även i Sverige där bland annat Sveriges Radio rapporterade om uppgifterna. Som källa till batteritillverkningens klimatpåverkan angav de tyska författarna IVL:s siffror från 2017 – siffror som IVL själva alltså slutat använda.</p>



<p>– Det är olyckligt eftersom de uppgifterna inte stämmer längre, säger Lisbeth Dahllöf vid IVL, till Elbilen.</p>



<p>Källor:</p>



<ul class="wp-block-list"><li>Batteriers miljöpåverkan, faktablad från Power Circl, IVL, mars 2019.</li><li>Linda Ager-Wick Ellingsen et al 2016 Environ. Res. Lett. 11 054010.</li><li>Romare Mia, Lisbeth Dahllöf (2017). The Life Cycle Energy Consumption and Greenhouse Gas Emissions from Lithium-Ion Batteries, IVL Report C243.</li><li>Christoph Buchal, Hans-Dieter Karl und Hans-Werner Sinn* Kohlemotoren, Windmotoren und Dieselmotoren: Was zeigt die CO2-Bilanz? ifo Schnelldienst 8/2019 72. Jahrgang 25. April 2019.</li></ul>



<ul class="wp-block-list"><li></li></ul>



<h2 class="wp-block-heading">Kommer elen att räcka?</h2>



<p>Det är ungefär lika mycket el som Sverige exporterar på ett år, eller knappt 10 procent av dagens el- användning. Om alla lastbilar, bussar och arbetsmaskiner också skulle bytas ut skulle elanvändningen öka med ytterligare cirka 10 procent.</p>



<p>Klarar elsystemet att ladda alla elfordon då?</p>



<p>Ja. Men de lokala och regionala elnäten är på många ställen i Sverige relativt hårt belastade i dag. Därför behövs anpassningar och investeringar.&nbsp;</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-2 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<p>Sverige har beslutat om en ny elmätarreform som ska vara genomförd 2025. Den innebär krav på smartare elmätare, vilket skapar förutsättningar för att elnäten ska kunna styras lokalt och med det klara av bland annat fler laddbara personbilar på ett bättre sätt.</p>
</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<figure class="wp-block-image size-large is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/2020/06/unnamed-7.jpg" alt="" class="wp-image-14926" width="224" height="194" srcset="https://elbilen.se/wp-content/uploads/2020/06/unnamed-7.jpg 372w, https://elbilen.se/wp-content/uploads/2020/06/unnamed-7-300x260.jpg 300w" sizes="(max-width: 224px) 100vw, 224px" /></figure>
</div>
</div>



<p>Källa: Energimyndigheten, frågor och svar om laddfordon.</p>



<h2 class="wp-block-heading">Funkar det med elbil på landet?</h2>



<p>Det finns en föreställning om att elbilar bara är för dem som bor i och runt storstäderna.</p>



<p>Men mycket talar för att det tvärt om är de som bor i glesbygdsområden som kan ha störst fördel av att köra på el. Det menar Robert Granström som bor i Älvsbyn i Norrbotten. Han har under flera års tid arbetat med att testa och utvärdera hur det funkar med elbil i Norrlands inland, i praktiken. Den första fördelen han lyfter fram med elbil i glesbygd är kostnaderna.</p>



<p>– Elen du förbrukar för en mils körning kostar två kronor och</p>



<p>det ger oss möjlighet att minska kostnaden för våra långa avstånd, säger han.</p>



<p>Den som bor i eget hus har också lätt att fixa egen laddplats hemma, där man kan ladda på natten. På morgonen kommer man ut till en ”fulltankad” bil och slipper åka till en mack, vilket för vissa kan vara en omväg.</p>



<p>Kylan i norra delarna av landet har heller inte visat sig vara något problem. I tester som Robert Granström varit med och gjort har elbilar parkerats i frysgarage, sedan har räckvidden testats.</p>



<p>Slutsatsen blev att för de flesta jobbpendlare i Norrbotten räcker räckvidden i moderna elbilar för daglig pendling även när det är kallt ute. En nedkyld Kia e-Niro klarade från kallstart till exempel 24 mil i minus 20 grader. (Mer om hur elbilar fungerar i kyla och Roberts tips om hur du maxar räckvidden när det är kallt kan du läsa på sid 39.) I testerna har man provat att kyla ner elbilarna till –35 grader före start.&nbsp;</p>



<p>&nbsp;– De har startat utan problem även då, så jag skulle säga att de är mer pålitliga än fossilbilar i extrem kyla.</p>



<p>Bristen på snabbladdare i glesbygden är ett skäl som får många att välja bort elbil. Men laddinfrastrukturen har förbättrats i Sverige de senaste åren, även utanför storstäderna.</p>



<p>Många glömmer också att merparten av laddningen sker hemma. För den typiska elbilisten är 90 procent av laddningen normalladdning från vanliga elnätet hemma eller på jobbet, och 10 procents snabbladdning, då oftast inte i var- dagen utan när man är på långresa.</p>



<h2 class="wp-block-heading">Hur vet jag att elbilen jag köpt inte har kobolt som brutits av barn i Kongo?</h2>



<p>Bilder på omänskliga arbetsförhållanden vid koboltbrytningen i Kongo skakade välden för några år sedan – och blev också en väckarklocka för elbilsbranschen. Sedan dess har det enligt Amnesty skett förbättringar, men konsumenter behöver fortsätta att ställa krav.&nbsp;</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-3 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 is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/2020/06/unnamed-10.jpg" alt="" class="wp-image-14932" width="255" height="220" srcset="https://elbilen.se/wp-content/uploads/2020/06/unnamed-10.jpg 372w, https://elbilen.se/wp-content/uploads/2020/06/unnamed-10-300x260.jpg 300w" sizes="(max-width: 255px) 100vw, 255px" /></figure>
</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<p>2016 publicerade människorättsorganisationen Amnesty sin första granskning av koboltbrytningen i Demokratiska Republiken Kongo. Landet står för 50 procent av världens kobolt, ett ämne som används i en mängd produkter, bland annat batterier till telefoner, datorer, maskiner – och elbilar.</p>
</div>
</div>



<p>– Vi blev uppmärksammade på frågan av vår partnerorganisation Afrewatch, som sett hur problemen med koboltbrytningen ökade i takt med efterfrågan, säger Ulrika Sandberg som arbetar med företagsansvar på Amnesty Sverige.</p>



<p>Problemen handlade om livsfarliga arbetsförhållanden, sjukdomar och även barnarbete.</p>



<p>Av brytningen i Kongo beräknas 20 procent vara så kallad ”artisanal mining”, där fattiga människor bryter för hand med mycket enkla verktyg, utan skyddsutrustning.&nbsp;</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-4 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<p>Även om merparten av brytningen sker av stora företag med maskiner, var problemet att företagen i Amnestys granskning inte hade kontroll på var kobolten de använde kom ifrån och med det riskerade att stötta missförhållandena, inklusive barnarbete.</p>
</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<figure class="wp-block-image size-large is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/2020/06/unnamed-9.jpg" alt="" class="wp-image-14933" width="256" height="222" srcset="https://elbilen.se/wp-content/uploads/2020/06/unnamed-9.jpg 372w, https://elbilen.se/wp-content/uploads/2020/06/unnamed-9-300x260.jpg 300w" sizes="(max-width: 256px) 100vw, 256px" /></figure>
</div>
</div>



<p>Efter granskningarna har det skett förbättringar, berättar Ulrika Sandberg</p>



<p>– Ett exempel är Renault, som efter rapporten tagit upp en dialog med Amnesty Frankrike. Enligt företaget blev rapporten en väckarklocka för dem. Nu har de börjat granska sina leverantörer, och de har satt som mål att granska alla.</p>



<p>Men det finns arbete kvar att göra. Amnesty har därför uppmanat elbilsbranschen att ta fram ett etiskt batteri inom fem år. Från industrins håll har man startat samarbeten, till exempel Responsible Cobalt Initiative och Responsible Raw Material Initiative. De företag som gått med där ska bland annat hjälpa varandra att ta fram metoder för att granska leverantörsleden.</p>



<p>Det gäller samtidigt att inte bara fokusera på just kobolt. Efterfrågan växer snabbt på många slags ämnen, och i takt med teknikutvecklingen kan dessa bytas ut. Litium är ett exempel. Jordartsmetaller som neodym är ett annat, där nyheterna har rapporterat om miljöproblem kopplade till brytningen i Kina.</p>



<p>– Det viktiga är att företagen gör regelbundna konsekvensanalyser, och är medvetna om vilka risker för människor och miljö som är kopplade till olika varor och ämnen. Sedan måste man ha en plan för vad man ska göra, om man upptäcker missförhållanden.</p>



<p>Det är också viktigt att företagen offentliggör detta, så att konsumenter, journalister och andra kan se hur de jobbar.&nbsp;</p>



<p>Vad kan jag då göra som konsument? Amnesty avråder inte från att köpa elbil eller andra produkter. Däremot uppmuntrar man konsumenter att ställa krav på tillverkare och återförsäljare.</p>



<p>– Fråga försäljaren: Kan du berätta hur det här företaget granskar sina leverantörsled? Var hittar jag information om det?</p>



<p><strong>Spelar det verkligen någon roll om jag ställer den frågan till en bilhandlare? Brytningen av metaller och batteritillverkningen sker ju så många led bort?&nbsp;</strong></p>



<p>– Ja, det spelar roll. Vi har sett tidigare att det gett effekt, särskilt när vi riktat in oss på konsumentnära produkter. Vi lyckades till exempel sätta press på Apple i en tidigare kampanj genom att tusentals människor mejlade till återförsäljare. Jag tycker inte man ska avfärda sin egen möjlighet att påverka och tänka ”vad kan jag göra”, säger Ulrika Sandberg.</p>



<p><strong>Skulle du själv kunna tänka dig att köpa en elbil i dag?</strong></p>



<p>– Om jag skulle välja mellan bensin- eller elbil skulle jag välja elbil, med tanke på miljöfördelarna, och jag skulle göra noggrann research för att se hur företagen respekterar mänskliga rättigheter, granskar sina leverantörer och jobbar med speciellt koboltfrågan. Jag har också jobbat som utredare för Amnesty i Nigeria och besökt Nigerdeltat, där det finns enorma problem kopplade till olja- och gasindustrin. Det är inte en oproblematisk industri det heller.</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow"><p>&nbsp;Om jag skulle välja mellan bensin eller elbil skulle jag välja elbil. Jag har också jobbat som utredare för Amnesty i Nigeria och besökt Nigerdeltat, där det finns enorma problem kopp- lade till olja- och gasindustrin. Det är inte en oproblematisk industri det Heller</p></blockquote>



<h2 class="wp-block-heading">Hur länge håller batterierna?</h2>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-5 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 is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/2020/06/6.6.jpg" alt="" class="wp-image-14935" width="228" height="197" srcset="https://elbilen.se/wp-content/uploads/2020/06/6.6.jpg 372w, https://elbilen.se/wp-content/uploads/2020/06/6.6-300x260.jpg 300w" sizes="(max-width: 228px) 100vw, 228px" /><figcaption><strong>Breakit har intervjuat Taxichauffören Azad Hassan, vars Tesla Model S troligen kört längst av alla elbilar i landet: 54 000 mil.</strong><br></figcaption></figure>
</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<p>Många jämför elbilars batterier med batterierna i bärbara datorer och mobiler, som ju inte brukar hålla särskilt länge. Men det är en missvisande jämförelse.&nbsp;Litiumjon-batterier slits nämligen mest när de är 100 procent fulladdade eller helt urladdade. Batterier i elbilar är så gott som aldrig helt fulladdade eller urladdade, och då tål de betydligt fler laddcykler.&nbsp;</p>
</div>
</div>



<p>För att skydda batterierna har alla elbilar på marknaden reserver som är oåtkomliga för föraren. När batterimätaren står på noll och bilen inte kan köras längre finns det egentligen fortfarande cirka 5 procents laddning kvar.</p>



<p>Nya elbilar brukar ha fem till åtta års batterigaranti. Hur mycket av ursprungskapacitet som garanterat ska finnas kvar då skiljer sig något mellan olika biltillverkare. De flesta anger 70 procent.</p>



<p>Men batterierna håller ofta bättre än vad garantin lovar. Det finns flera rapporter om enskilda elbilar som har körts som taxi- eller budbilar och kommit upp i höga miltal.&nbsp;</p>



<p>Till exempel har en taxichaufför i Stockholm som kört 54 000 mil med sin Tesla Model S (alltså motsvarande 13 varv runt jorden!) berättat att hans batteri bara försämrats med cirka 15 procent.</p>



<p>Holländsk-belgiska Teslaklubben undersökte 68 Model S och kom fram till att batterierna tappade cirka 6 procent i kapacitet efter 10 000 mil. Försämringen saktade sedan ner, och efter 27 000 mil hade de undersökta bilarna i genomsnitt 91 procent av den ursprungliga batterikapaciteten kvar.</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-6 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<p>Nissan samlar in data från de runt 400 000 Nissan Leaf som rullar runt om i världen. I somras sa Nissans representanter att man utifrån de uppgifterna kunde se att batterierna i en Leaf har en livstid på cirka 22 år, alltså längre än vad själva bilen beräknas hålla.&nbsp;</p>
</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<figure class="wp-block-image size-large is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/2020/06/unnamed-6.jpg" alt="" class="wp-image-14919" width="225" height="194" srcset="https://elbilen.se/wp-content/uploads/2020/06/unnamed-6.jpg 372w, https://elbilen.se/wp-content/uploads/2020/06/unnamed-6-300x260.jpg 300w" sizes="(max-width: 225px) 100vw, 225px" /></figure>



<p></p>
</div>
</div>



<p>Men då talar vi fram till batterierna är helt slut. I en bil räknar man med att de kommer fungera bra i 8–10 år. Resten av sin livstid kan batterierna användas som energilager. Till exempel används ett stort antal begagnade Leaf-batterier som energilager vid en idrottsarena i Nederländerna som har solceller på taket.</p>



<p>Källor:</p>



<ul class="wp-block-list"><li>Har hans Tesla rullat längst i Sverige? Breakit 11 maj 2019.&nbsp;</li><li>Nissan Leaf Batteries To outlast Car by 10–12 Years, Insideevs, 24 maj 2019.</li></ul>



<h2 class="wp-block-heading">Vad händer med batterierna när de är uttjänta? I vilken mån återvinns de?</h2>



<p>En viktig del av elbilarnas totala miljöpåverkan är vad som händer med batterierna när de är uttjänta.&nbsp;</p>



<p>Frågan om batterierna går att återvinna eller inte är sedan länge utagerad. Det säger Hans Eric Melin, som arbetar som konsult kring just återvinning av batterier.&nbsp;</p>



<p>– Vi har kunnat återvinna litiumjonbatterier i åtminstone tio år. Det är inte det som är problemet – det som främst fattas är batterier att återvinna. Man har trott att volymerna skulle komma tidigare, men batterierna har varit för bra, säger Hans Eric Melin.&nbsp;</p>



<p>&nbsp;</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-7 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 decoding="async" width="512" height="442" src="https://elbilen.se/wp-content/uploads/2020/06/unnamed-11-1.jpg" alt="" class="wp-image-14939" srcset="https://elbilen.se/wp-content/uploads/2020/06/unnamed-11-1.jpg 512w, https://elbilen.se/wp-content/uploads/2020/06/unnamed-11-1-300x259.jpg 300w" sizes="(max-width: 512px) 100vw, 512px" /></figure>
</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<p>I Europa har vi ännu inte kommit så långt med batteråtervinning. Batterierna härifrån har krossats och man har separerat materialen och exporterat dem, framför allt till Kina och Sydkorea. Det är där den stora merparten av alla batterier produceras, och det är även där den mesta av återvinningen sker. Man återvinner kobolt, nickel, mangan och litium, berättar Hans Eric Melin.</p>
</div>
</div>



<p>Hur stor del av batterierna kan man återvinna?</p>



<p>– Effektiviteten ligger i regel mellan 70 och 80 procent även om det är möjligt att nå nära 100 procent. Allt beror på hur marknaden ser ut för tillfället, säger Hans Eric Melin.</p>



<p>För att Europa ska bli bättre på återvinning, och behålla värdet som batterierna har, behöver vi en europeisk produktion, menar Hans Eric Melin.</p>



<p>– Om det inte finns något behov av återvinningens slutprodukt som ju är råvaror, så finns inga skäl att ta fram det här.&nbsp;</p>



<p>Det här håller redan nu på att hända. Sedan i våras har till exempel energi- bolaget Fortum en anläggning på plats i Finland som står redo för återvinning av elbilsbatterier i större skala.</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<p>– Men med tanke på hur stor efterfrågan det är på batterier och hur mycket elbilsmarknaden växer tror vi att det finns goda förutsättningar för utveckling av återvinningsverksamheten framöver, säger Fortum Sveriges kommunikationschef Per-Oscar Hedman till Elbilen. Northvolt kommer etablera en återvinningsanläggning i Sverige som ska förse fabriken i Skellefteå med råmaterial.</p>
</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-8 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 is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/2020/06/unnamed-12.jpg" alt="" class="wp-image-14937" width="153" height="153" srcset="https://elbilen.se/wp-content/uploads/2020/06/unnamed-12.jpg 495w, https://elbilen.se/wp-content/uploads/2020/06/unnamed-12-300x300.jpg 300w, https://elbilen.se/wp-content/uploads/2020/06/unnamed-12-80x80.jpg 80w" sizes="(max-width: 153px) 100vw, 153px" /><figcaption>Hans Eric Melin</figcaption></figure>
</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow"></div>
</div>
</div>
</div>



<p>En kommande brist på råvaror är också en faktor som talar för att efterfrågan på uttjänta elbilsbatterier kommer bli stor. En av metallerna man tror att det kommer bli brist på är kobolt.</p>



<p>Återvinns det kobolt i dag?</p>



<p>– Våra siffror säger att det återvanns 14 000 ton kobolt 2018.&nbsp; Det är 10–20 procent av hela marknaden beroende på hur mycket av det som går till batterier, säger Hans Eric Melin.</p>



<p>Att tillverka litiumjonbatterier kräver mängder med energi, och beroende på var den energin kommer ifrån kan produktionen vara en stor miljöbelastning. Hur ser miljöpåverkan ut när man återvinner batterier?&nbsp;</p>



<p>– Det beror på vilken metod man använder, men generellt sett har återvinning inte en stor miljöpåverkan, säger Hans Eric Melin.</p>



<h2 class="wp-block-heading">Vad kostar det att ha en Elbil?</h2>



<p>Elbilar är dyrare i inköp än bilar med förbränningsmotorer, men billigare i drift. Störst skillnad är det på bränslekostnaderna, som ligger runt 2 kronor milen för elbilen om man laddar hemma.&nbsp;</p>



<p>Men även skatt och kostnader för reparationer är lägre för elbilar. Här är några exempel på vad kostnaderna kan landa på.&nbsp;</p>



<p><strong>Kostnader för laddning/bränsle</strong></p>



<p>Undersökningar bland elbilister visar att i genomsnitt 90 procent av laddningen är normalladdning hemma eller på arbetsplatsen. Cirka 10 procent av laddningen är snabbladdning.</p>



<p>Elpriset i Sverige ligger på i genomsnitt 1,50 kr /kWh. (Ofta är priset lägre på natten, när merparten av elbilsladdningen sker.) Priset för snabbladdning varierar mellan olika operatörer, men ligger ofta runt 4 kr/kWh.</p>



<figure class="wp-block-image size-large"><img decoding="async" width="1030" height="889" src="https://elbilen.se/wp-content/uploads/2020/06/6.8-1030x889.jpg" alt="" class="wp-image-14946" srcset="https://elbilen.se/wp-content/uploads/2020/06/6.8-1030x889.jpg 1030w, https://elbilen.se/wp-content/uploads/2020/06/6.8-300x259.jpg 300w, https://elbilen.se/wp-content/uploads/2020/06/6.8-768x663.jpg 768w, https://elbilen.se/wp-content/uploads/2020/06/6.8-1536x1326.jpg 1536w, https://elbilen.se/wp-content/uploads/2020/06/6.8.jpg 1552w" sizes="(max-width: 1030px) 100vw, 1030px" /></figure>



<p>För en elbil som förbrukar 2 kWh el per mil och normalladdas/snabbladdas enligt ovan skulle drivmedelskostnaden bli 5 250 kr, för en årlig körsträcka på 1500 mil. Förbrukar elbilen 1,5 kWh per mil blir kostnaden 3 375 kr.</p>



<p>För en bensinbil med en förbrukning på 0,7 liter milen blir bränslekostnaden för samma sträcka 15 750 kr, om man räknar med ett bensinpris på 15 kr litern. Förbrukar bensinbilen 0,5 liter milen blir kostnaden 11 250 kr.</p>



<p><strong>Skatt, bonus och malus</strong></p>



<p>Rena elbilar erhåller en miljöbilspremie på 60 000 kr som betalas ut ett halvår efter att bilen tagits i trafik.&nbsp;Skatten för en elbil är sedan 360 kr per år. Skatten för en bensinbil varierar beroende på bilens utsläpp. De tre första åren tas även malusskatt ut på nya bensinbilar. För en ny VW Golf är årsskatten till exempel 2 246 kr de tre första åren, därefter 514 kr.&nbsp;För en ny bensindriven Volvo XC60 blir årsskatten 9 507 kronor de första tre åren, därefter 2 120 kr.&nbsp;</p>



<p><strong>Reparationer</strong></p>



<p>Kostnader för reparationer och service är i regel lägre för elbilar än för bilar med förbränningsmotorer. Det finns helt enkelt färre delar som kan gå sönder och inget byte av olja behövs.&nbsp;Hur mycket kostnaderna skiljer sig åt kan variera – tvåårsservicen på e-Golfen som Elbilen nu långtidstestar kostade 4 000 kronor. För motsvarande Golf med förbränningsmotor hade den kostat ytterligare 2 500 kronor, enligt verkstaden.&nbsp; Konsumentverket räknar generellt med 1 000 kr lägre reparation och servicekostnad per år för elbilar.</p>



<p><strong>Investering i laddbox till elbilen</strong></p>



<p>Den som skaffar elbil rekommenderas att installera en laddbox, som kostar från cirka 5 000 kronor plus installation.&nbsp; Man kan få bidrag för hälften av kostnaden för hela installationen, upp till maxbeloppet på 10 000 kronor (privatpersoner).&nbsp; Under 2018 låg stödnivån i genomsnitt på cirka 7 500 kronor – vilket betyder att den som köpt boxen stått för motsvarande kostnad själv.</p>



<h2 class="wp-block-heading">Hur är elbilarnas andrandsvärde?</h2>



<p>Många som funderar på sitt första elbilsköp är oroliga över hur andrahandsvärdet kommer se ut.</p>



<p>En färsk undersökning visar dock att elbilar behåller sitt andrahandsvärde mycket bra, och att snittpriset för begagnade elbilar stigit med 25 procent under det senaste året.</p>



<p>Undersökningen har gjorts av Wayke, som är bilhandlarnas annonssajt på nätet. De har analyserat begagnatpriset på över tiotusen bilar av 2016 års modell och jämfört dem med listpriser från 2016 som berättar vad bilarna kostade som nya.&nbsp;</p>



<figure class="wp-block-image size-large"><img decoding="async" width="1030" height="889" src="https://elbilen.se/wp-content/uploads/2020/06/6.10-1030x889.jpg" alt="" class="wp-image-14945" srcset="https://elbilen.se/wp-content/uploads/2020/06/6.10-1030x889.jpg 1030w, https://elbilen.se/wp-content/uploads/2020/06/6.10-300x259.jpg 300w, https://elbilen.se/wp-content/uploads/2020/06/6.10-768x663.jpg 768w, https://elbilen.se/wp-content/uploads/2020/06/6.10-1536x1326.jpg 1536w, https://elbilen.se/wp-content/uploads/2020/06/6.10.jpg 1552w" sizes="(max-width: 1030px) 100vw, 1030px" /></figure>



<p>Att Wayke valde just 2016 års modeller beror på att elbilar får sin andra ägare efter i snitt tre år. Företaget har undersökt hur många procent respektive elbil minskat i värde per avverkad mil samt hur många mil den rullar innan värdet halverats.&nbsp;</p>



<p>Såhär ser topp fem ut:</p>



<p>Att Teslas andrahandsvärde står sig bäst är tydligt.&nbsp;</p>



<p>– Tesla har på det stora hela visat sig rulla betydligt längre än vad många först trodde men priset har framför allt att göra med den begränsade tillgången på nya bilar, tror jag. Det ska bli intressant att se vad som händer med andrahandspriset när Teslaproduktionen ökar samtidigt som tillgången på elbilar blir betydligt större överlag, säger Martin Fransson, vd på Wayke.</p>



<p>Att andrahandspriset ökat på elbilar generellt sett beror enligt Martin Fransson delvis på att utlandsintresset för svenska begagnade elbilar ökat i och med den svaga kronan, men det är främst tillgången som pressar upp priset.&nbsp;&nbsp;</p>



<p>– Svenskarna verkar alltmer redo att byta till elbil men producenterna hänger inte med. Det är brist på både nya och begagnade elbilar, vilket är den främsta orsaken till att priserna ökar, säger Martin Fransson.</p>



<p>Tidningen Teknikens Världs ekonomikalkyler bekräftar Waykes statistik, att elbilarna står sig starka på begagnatmarknaden. Elbilarna har efter tre år (6 000 mil) oftast 60–70 procent kvar av nybilsvärdet, vilket få andra bilar med annan drivlineteknik når upp till, skriver Teknikens Värld.</p>



<figure class="wp-block-table is-style-stripes"><table><tbody><tr><td>Tillverkare</td><td>Modell</td><td>Värdeminskning / 1000 Mil </td><td>Halverat värde efter antal mil</td></tr><tr><td>Tesla</td><td>Model S</td><td>4%</td><td>15839</td></tr><tr><td>Tesla</td><td>Model X</td><td>5%</td><td>13941</td></tr><tr><td>Hyundai</td><td>Ioniq</td><td>10%</td><td>6502</td></tr><tr><td>Kia</td><td>Soul EV</td><td>10%</td><td>6308</td></tr><tr><td>VW</td><td>e-Golf</td><td>10%</td><td>6297</td></tr></tbody></table></figure>



<p>Modellerna ovan behöll värdet bäst. Wayke har analyserat begagnatpriset på bilar av 2016 års modell, och undersökt hur många procent de minskat i värde per avverkad mil.</p>



<h2 class="wp-block-heading">Hur vanligt är det med bränder i elbilar?</h2>



<p>Om elbilar inte laddas på rätt sätt kan det innebära en brandfara. Det är en varning som naturligtvis ska tas på största allvar. Men det betyder inte att det är vanligt att bränder orsakas av elbilar. Tvärtom.</p>



<p>– Det är väldigt sällsynt med bränder i elfordon i Sverige, säger Mattias Strömgren, olycksutredare på Myndigheten för samhällsskydd och beredskap, MSB.</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-10 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<p>Totalt sett inträffar cirka 3 000 bilbränder årligen i Sverige. Ännu finns ingen samlad statistik över antalet elbilsbränder, men MSB arbetar just nu med att sammanställa det. Bland annat söker man i gamla olycksrapporter, med start från tre–fyra år bakåt i tiden fram till nu.</p>
</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<figure class="wp-block-image size-large"><img decoding="async" width="512" height="442" src="https://elbilen.se/wp-content/uploads/2020/06/unnamed-14.jpg" alt="" class="wp-image-14944" srcset="https://elbilen.se/wp-content/uploads/2020/06/unnamed-14.jpg 512w, https://elbilen.se/wp-content/uploads/2020/06/unnamed-14-300x259.jpg 300w" sizes="(max-width: 512px) 100vw, 512px" /></figure>
</div>
</div>



<p>– Personligen känner jag bara till fyra fall där elbilar varit inblandade, två där bilar stått på laddning och två där de börjat brinna på vägen, säger Mattias Strömgren.</p>



<p>Ett omtalat fall inträffade i värmländska Sunne 2017, där en laddhybridbil stod på laddning i en carport. Familjen hade kopplat en timer till det vanliga vägguttag som bilen laddade från. Utredningen visade senare att det var i just uttaget eller timern som branden startade. Branden spred sig och huset totalförstördes.</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-11 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<p>Ett annat fall inträffade i ett radhusområde utanför Luleå i augusti 2019, och resulterade i flera totalförstörda bostäder och att många människor fick evakueras. Radhusägarens laddhybridbil laddade från en godkänd laddbox. Enligt ägaren själv ska lågorna dock ha börjat inuti bilen, inte vid boxen eller kontakten. Vad som orsakade den branden är ännu inte fastställt.</p>
</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<figure class="wp-block-image size-large"><img decoding="async" width="512" height="442" src="https://elbilen.se/wp-content/uploads/2020/06/unnamed-13.jpg" alt="" class="wp-image-14943" srcset="https://elbilen.se/wp-content/uploads/2020/06/unnamed-13.jpg 512w, https://elbilen.se/wp-content/uploads/2020/06/unnamed-13-300x259.jpg 300w" sizes="(max-width: 512px) 100vw, 512px" /></figure>
</div>
</div>



<p>I takt med att andelen elbilar ökar i den svenska fordonsflottan är det troligt att antalet bränder i elbilar bli fler. Och när en elbilsbrand inträffar kan det vara en utmaning för brandkåren, eftersom förloppet och riskerna skiljer sig åt från en brand i en bensin eller dieselbil.</p>



<p>– Dels kan det uppstå gaser av väteflourid som är giftig för brandmännen, säger Mikael Andersson, tillförordnad räddningschef i Luleå. Bränder i elbilar bekämpas med vatten och skum, på samma sätt som vid andra bilbränder.</p>



<p>Det finns ingen risk för elektrisk chock om man sprutar vatten på en brinnande elbil som en del tror, för det blandas i så mycket luft, förklarar Mikael Andersson.&nbsp;</p>



<p>– Om det väl har börjat brinna inne i själva batteripacket kan det däremot vara svårt att släcka med vanliga släckmedel.&nbsp;</p>



<p>Ibland finns inte mycket annat att göra än att låta det brinna ut. Man har gjort försök med något som liknar storskaliga brandfiltar, eller att hälla på sand eller motsvarande, men än så länge är detta en trevande bransch, säger Mikael Andersson.</p>



<h2 class="wp-block-heading"></h2>



<p></p>
