Test: Hyundai Nexo vs Tesla Model S – religionskriget

VÄTGAS VS EL En vätgasbil får energin till sin elmotor från komprimerad vätgas, utsläppet blir vatten. En batteribil laddas med el. Inga konstigheter. TEXT: Fredrik Sandberg FOTO: Stefan Nilsson Men debatten mellan vad framtidens bränsle är, om det är vätgas eller batterier, ser aldrig ut att ebba ut. Vad beror det på? Det är ju […]


<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p><em>VÄTGAS VS EL</em><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>
</blockquote>



<p><strong>En vätgasbil får energin till sin elmotor från komprimerad vätgas, utsläppet blir vatten. En batteribil laddas med el. Inga konstigheter.</strong> </p>



<p>TEXT: Fredrik Sandberg FOTO: Stefan Nilsson</p>



<p>Men debatten mellan vad framtidens bränsle är, om det är vätgas eller batterier, ser aldrig ut att ebba ut. Vad beror det på? Det är ju två nollutsläppstekniker, kopplade till elmotorer som har potential att göra resandet klimatneutralt. Måste man välja? Är inte mac eller pc-konflikten rätt löjlig?</p>



<p>Men låt oss börja med hur de båda teknikerna funkar i praktiken. Dags för en långkörning. Vem kommer först ner till Frankfurt från Stockholm, en vätgasbil som kan tanka på fem minuter eller en laddbar elbil som måste ladda på snabbladdare? Vi lånade den senaste vätgasbilen på marknaden, Hyundai Nexo, med en räckvidd på över 60 mil, och en Tesla Model S Raven med en räckvidd på över 60 mil, och drog iväg en söndagsmorgon i september.</p>



<figure class="wp-block-image size-large"><img fetchpriority="high" decoding="async" width="512" height="294" src="https://elbilen.se/wp-content/uploads/2020/07/unnamed-18.jpg" alt="" class="wp-image-16088" srcset="https://elbilen.se/wp-content/uploads/2020/07/unnamed-18.jpg 512w, https://elbilen.se/wp-content/uploads/2020/07/unnamed-18-300x172.jpg 300w" sizes="(max-width: 512px) 100vw, 512px" /><figcaption class="wp-element-caption">Starten gick på Södermalm. Vem tar sig fram först till Frankfurt? Hastighetsgränserna hölls hela vägen.</figcaption></figure>



<h2 class="wp-block-heading">Tankstationsångest i vätgasbilen</h2>



<p><strong>Trippen ner till Frankfurt startade med en omväg för Hyundai Nexo. Det finns nämligen inga tankstationer efter E4an. Vi fick istället ta en omväg via Mariestad för att tanka. Skulle vi hinna ikapp Teslan?</strong></p>



<pre class="wp-block-preformatted">Text och Foto: Fredrik Sandberg och Johan stenvall</pre>



<figure class="wp-block-image size-large"><img decoding="async" width="512" height="320" src="https://elbilen.se/wp-content/uploads/2020/07/unnamed-20.jpg" alt="" class="wp-image-16091" srcset="https://elbilen.se/wp-content/uploads/2020/07/unnamed-20.jpg 512w, https://elbilen.se/wp-content/uploads/2020/07/unnamed-20-300x188.jpg 300w" sizes="(max-width: 512px) 100vw, 512px" /><figcaption class="wp-element-caption">Johan Stenvall</figcaption></figure>



<p class="has-drop-cap">Vi startade samtidigt i Stockholm på Södermalm och letade oss parallellt ut ur Stockholm en sömnig söndagmorgon i början av september. Klockan var 08:33, trafiken var lätt och snart vek vi av mot Mariestad, medan Teslan kunde fortsätta på E4an ner mot kontinenten. Enda stället att tanka vätgas mellan Stockholm och Köpenhamn är Mariestad.&nbsp;</p>



<p>Nexo är Huyndais första vätgasbil som är byggd på en egen plattform. Tidigare har det funnits en variant av deras SUV ix 35 som vätgaskonverterats och fått tillägget Fuel Cell i namnet. Nexo är större om än inte riktigt lika stor som deras stora SUV Santa Fe. Det är på många sätt en mer färdig produkt än den tidigare vätgasbilen och Hyundai vill visa vad en vätgasbil för framtiden kan vara.&nbsp;</p>



<p>Bara vetskapen om att en enda pump fanns till förfogande och att vi var helt utlämnade till dess funktion gjorde att Johan sov dåligt natten innan avfärd.&nbsp;</p>



<p>Känslan var lite av den samma som de tidiga elbilsresorna där statusen på de få laddstationerna som fanns kunde vara avgörande för när slutmålet nåddes. Men det här var på många sätt värre, om en pump inte fungerar så skulle vi bli stående. Med en ren elbil gick det alltid att leta upp någon sämre laddpunkt, stoppet kunde bli ofrivilligt långt men det blev ju inte helt stopp.&nbsp;</p>



<p class="has-text-color" style="color:#20bdc4">Mariestad 11:43.&nbsp;</p>



<p>Vi anländer till tankstationen i Mariestad, stänger av Nexon och väntar på att systemet ska koppla ner. Sedan kan vi öppna tanklocket och plugga in munstycket. Vi drar kortet i kortläsaren och trycker på startknappen.&nbsp; Ingenting händer på displayen. Är den trasig?</p>



<p>Efter ett tag ser vi dock att det blir frostigt vid tankhandtaget, vätgasen håller minus 30 grader inne i tankstationen därav frosten. Det spolar och låter inne i tankstationen och vi antar att vi faktiskt får vätgas. När vi startar bilen ser vi att vi har fyllt upp. Det är bara mätaren som är trasig. Vi har inte fått 100 procent, men 94 procent. Det är, enligt räckvidssangivelsen, tillräcklig räckvidd för att ta oss till Köpenhamn där nästa tankstopp är. Cirka 45 mils körning. Vi kör försiktigt ner till Jönköping, aningen nervösa över att rädckvidden inte ska vara tillräcklig, vana som vi är vid elbilar som lovar mer räckvidd än vad man verkligen får.&nbsp;</p>



<p>Det visar sig vara ganska onödigt. Vi kan köra motorvägshastighet och mätaren stämmer bra jämfört med hur långt vi kan köra.&nbsp;</p>



<p>Vi har 10 mil till godo när vi anländer till Köpenhamn och den tankstation som där fungerar. Vi har fått många felmeddelanden under vägen, bland annat att nyckeln inte ska fungera. Teslan har redan lämnat Köpenhamn och är på väg mot Middlefart i Danmnark.&nbsp;</p>



<figure class="wp-block-image size-large"><img decoding="async" width="512" height="302" src="https://elbilen.se/wp-content/uploads/2020/07/unnamed-19.jpg" alt="" class="wp-image-16090" srcset="https://elbilen.se/wp-content/uploads/2020/07/unnamed-19.jpg 512w, https://elbilen.se/wp-content/uploads/2020/07/unnamed-19-300x177.jpg 300w" sizes="(max-width: 512px) 100vw, 512px" /><figcaption class="wp-element-caption">Mariestad. Här tankar vi första gången. En av få tankstationer i Sverige. Vätgasen produceras på plats av solceller på baksidan. Svårt att tänka sig ett miljövänligare sätt att köra bil på.&nbsp;<br></figcaption></figure>



<p class="has-text-color" style="color:#20bdc4">Köpenhamn 16:50.&nbsp;</p>



<p>Vi träffar en tysk som laddar … förlåt, tankar utanför Köpenhamn. Han talar sig varm om vätgas men tycker även att batterier har sin roll att spela, ”i mindre fordon för stadstrafik”. En fras vi har hört många gånger av vätgasentusiaster, och då främst från Toyota. Det är lite märkligt att säga efter att Teslas stora suv Model X, i många år har trafikerat Europas motorvägar. Batteribilar funkar även i större format.&nbsp;</p>



<p>Nu rullar dessutom flera stora suvar från olika märken på vägarna med batterier. Så det där argumentet har passerat bäst-före-datum för länge sedan. Kan vi vara överrens om det i alla fall?</p>



<p>Han tankar och vi tankar efter honom. Men vi får inte full tank, bara kring 75 procent. Vi tänker att det inte gör så mycket, eftersom det ju går så fort att fylla på och vi har siktat in oss på Kolding i Danmark, som ligger på Jylland direkt när man kommer över från Fyn.&nbsp;Det var ett misstag som skulle kosta oss ett par timmar.<strong>&nbsp;</strong></p>



<p>Vi är på god väg att komma i kapp Teslan, som lossar från Middlefart, strax innan Kolding, när vi startar.&nbsp; På väg mot Kolding får vi ett meddelande om en station i Danmark som har slut på gas. Det låter oroväckande. Men Kolding ska fungera.&nbsp;Det gör den inte när vi kommer fram.</p>



<p></p>



<p class="has-text-color" style="color:#20bdc4">Kolding 19:28</p>



<p>Vi provar fyra gånger att starta den, men ingenting händer. Jag ringer numret jag har fått, men får inget svar. Nu måste vi ta ett snabbt beslut. Vi kan inte köra till norra Tyskland, eftersom vi har ett tankkort som ligger och väntar på oss i Hamburg. Med vätgas är det samma som med laddkort för elbilar. Var och en har sin egen standard. Varför kan man inte få betala med kort?</p>



<p>Vad göra?</p>



<p>Vi kör till Esbjerg, det är den närmaste stationen, men det innebär också fel riktning. Och förlorad tid. Men vi har inget val, och vi måste snabbt lösa situationen. Sagt och gjort, vi kör västerut istället för söderut. Det är 7,1 mil extra. Åt ett håll.&nbsp;</p>



<p>Stationen ska fungera säger H2Live-kartan. Men när vi väl är framme startar inte stationen.&nbsp;</p>



<p class="has-text-color" style="color:#20bdc4">Esbjerg 20:25</p>



<p>Nu blir vi svettiga. Ska det stanna här i Esbjerg? Ska vi ringa bärgning?&nbsp;&nbsp;Jag ringer åter servicemannen, Steffan, som den här gången svarar. Han lugnar oss och säger att det finns gas. Han kan starta stationen från sin dator. Men det tar längre tid att fylla upp. Vi får tillräckligt med gas och kan åter börja jaga Teslan. 7 mil tillbaka till Kolding och sedan söderut. Mot Hamburg! De 30 milen, på motorvägar, inklusive Autobahn är inga svårigheter för Nexon. Vi har gott om räckvidd när vi tankar vår första tank i Tyskland.&nbsp;</p>



<p class="has-text-color" style="color:#20bdc4">Hamburg 22:56</p>



<p>Tankkortet som vi har beställt innan avfärd ligger på plats inne på macken.</p>



<p>Nu fungerar det precis som det är tänkt att fungera. Vätgaspumpen ser ut som en vanlig bensinpump och ligger bredvid de traditionella pumparna. Vi fyller upp på mindre än fem minuter och drar vidare söderut. Autobahn är inte jättetrafikerad och vi kan stå på. Vi kommer upp i 170 km/h. Men nu slukar bilen vätgas. Vi får en snittförbrukning på 2,6 kilo per tio mil. Det är dubbla mot för vad den drar i mer normala motorvägshastigheter.&nbsp;</p>



<p>Vår omväg i Danmark har nog kostat oss segern, inser vi. Teslan är på god väg att vara framme.&nbsp;</p>



<div class="wp-block-media-text alignwide is-stacked-on-mobile"><figure class="wp-block-media-text__media"><img decoding="async" width="656" height="676" src="https://elbilen.se/wp-content/uploads/2020/07/1-35.jpg" alt="" class="wp-image-16092 size-full" srcset="https://elbilen.se/wp-content/uploads/2020/07/1-35.jpg 656w, https://elbilen.se/wp-content/uploads/2020/07/1-35-291x300.jpg 291w" sizes="(max-width: 656px) 100vw, 656px" /></figure><div class="wp-block-media-text__content">
<p>På bilden ser vi förbrukningen när vi pressade bilen på Autobahn, mer än dubbla förbrukningen än vid mer normal motorvägskörning</p>
</div></div>



<p class="has-text-color" style="color:#20bdc4">Kassel 01:52</p>



<p>Tankningen i Kassel går lika smärtfritt som i Hamburg. In med kortet, starta. Fem minuter sedan iväg, med endast vattenånga från avgasröret.&nbsp;</p>



<p>Klockan har nu passerat midnatt och nu tillåts långtradare att börja trafikera vägarna. De är förbjudna att köra på helgerna. Trafiken blir tyngre och flera vägarbeten stör vår körning. Och nu får vi också ett samtal från Tibor om att Teslan minsann är i mål.&nbsp; Vi glider in vid hotellet cirka en timme efter honom.</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p>Vilket ös! När det fungerar. Det&nbsp; verkar som om vätgastekniken inte&nbsp; har nått den mognadsgrad som vi förväntade oss.</p>
</blockquote>



<div class="wp-block-media-text alignwide has-media-on-the-right is-stacked-on-mobile"><div class="wp-block-media-text__content">
<p>Här står Fredrik och pratar med supporten på Nel, som äger tankstationerna i Danmark. Vi befann oss i Esbjerg och fick inte igång tankstationen själva. Men med lite hjälp så kom den igång.&nbsp;</p>
</div><figure class="wp-block-media-text__media"><img decoding="async" width="594" height="676" src="https://elbilen.se/wp-content/uploads/2020/07/1-36.jpg" alt="" class="wp-image-16093 size-full" srcset="https://elbilen.se/wp-content/uploads/2020/07/1-36.jpg 594w, https://elbilen.se/wp-content/uploads/2020/07/1-36-264x300.jpg 264w" sizes="(max-width: 594px) 100vw, 594px" /></figure></div>



<figure class="wp-block-image size-large"><img decoding="async" width="1030" height="703" src="https://elbilen.se/wp-content/uploads/2020/07/1-37-1030x703.jpg" alt="" class="wp-image-16094" srcset="https://elbilen.se/wp-content/uploads/2020/07/1-37-1030x703.jpg 1030w, https://elbilen.se/wp-content/uploads/2020/07/1-37-300x205.jpg 300w, https://elbilen.se/wp-content/uploads/2020/07/1-37-768x524.jpg 768w, https://elbilen.se/wp-content/uploads/2020/07/1-37-1536x1048.jpg 1536w, https://elbilen.se/wp-content/uploads/2020/07/1-37.jpg 1600w" sizes="(max-width: 1030px) 100vw, 1030px" /></figure>



<div class="wp-block-media-text alignwide is-stacked-on-mobile"><figure class="wp-block-media-text__media"><img decoding="async" width="710" height="1030" src="https://elbilen.se/wp-content/uploads/2020/07/1-38-710x1030.jpg" alt="" class="wp-image-16095 size-full" srcset="https://elbilen.se/wp-content/uploads/2020/07/1-38-710x1030.jpg 710w, https://elbilen.se/wp-content/uploads/2020/07/1-38-207x300.jpg 207w, https://elbilen.se/wp-content/uploads/2020/07/1-38-768x1114.jpg 768w, https://elbilen.se/wp-content/uploads/2020/07/1-38-1059x1536.jpg 1059w, https://elbilen.se/wp-content/uploads/2020/07/1-38.jpg 1103w" sizes="(max-width: 710px) 100vw, 710px" /></figure><div class="wp-block-media-text__content">
<p>1. Första tankningen i Mariestad. Den tog 19 minuter, då vi hade svårigheter att få igång den och sedan blev osäkra på om den verkligen tankade. Displayen visade ingenting, men vi märkte på handtaget att det blev frostigt och förstod att tankning hade påbörjats.&nbsp;</p>



<p>2. Tanknig i Köpenhamn. Dit tog vi oss utan problem. 46 mils körning och ändå hade vi cirka tio mil kvar. Det blev dock sega mil för att ta oss ner till Jönköping, då det var vägbyggen vid Skövde.&nbsp;</p>



<p>3. Vi hade planerat att tanka i Kolding, som ligger på vägen ner, men stationen fungerade inte, så det fick bli en extratur på 14, 2 mil till Esbjerg.&nbsp;</p>



<p>4. Första tankstoppet i Tyskland. Här fick vi se hur en vätgasstation ska se ut i framtiden. Insprängd bland andra pumpar stack den inte ut. Vi fick vårt tankkort här och fyllde upp på 5 minuter. Sedan i väg.</p>



<p>5. Tankning i Kassel, som gick prickfritt.</p>
</div></div>



<p>MÅL! I mål drygt en timme efter Teslan, 03.48. Det var oväntat.</p>



<h2 class="wp-block-heading">Superchargergate i Middlefart</h2>



<p><strong>Nya Tesla Model S har en rekordlång räckvidd för batteribilar och den ska ladda snabbare än tidigare. Kanske inte en lätt match att komma före fram till Frankfurt, men det borde kunna ge vätgasbilen en match. Om det inte hade varit för sega superchargers.</strong></p>



<pre class="wp-block-preformatted">Text: Tibor Blomhäll
Foto: Kasper Dudzik
</pre>



<figure class="wp-block-image size-large"><img decoding="async" width="1030" height="608" src="https://elbilen.se/wp-content/uploads/2020/07/1-40-1030x608.jpg" alt="" class="wp-image-16097" srcset="https://elbilen.se/wp-content/uploads/2020/07/1-40-1030x608.jpg 1030w, https://elbilen.se/wp-content/uploads/2020/07/1-40-300x177.jpg 300w, https://elbilen.se/wp-content/uploads/2020/07/1-40-768x453.jpg 768w, https://elbilen.se/wp-content/uploads/2020/07/1-40-1536x906.jpg 1536w, https://elbilen.se/wp-content/uploads/2020/07/1-40.jpg 1600w" sizes="(max-width: 1030px) 100vw, 1030px" /><figcaption class="wp-element-caption">Blicken på vägen, handen på ratten – men det är ändå autopiloten som kör.<br><br></figcaption></figure>



<p>Första laddstoppet kl 10:50 blev ändå vid Ödeshög. Jag skulle plocka upp min fotograf i Jönköping och var osäker på hur stor omväg detta skulle innebära. Skulle det gå åt många batteriprocent för omvägen skulle jag kommit fram till Lagan Supercharger med alldeles för få batteriprocent kvar. Under 10% laddas bilens batterier långsammare för att inte slita på dem för mycket. Första strategiska laddbeslutet av många längs vägen. Fick 140 kW, laddade från 37 procent till 79 procent på exakt 30 minuter.</p>



<p>Kasper, fotografen, hoppade så ombord vid trafikplats Ljungarum i Jönköping – platsen där våra och vätgasbilens vägar åter korsades efter deras omväg till Mariestad. Vi passerade korsningen 11:57</p>



<p>Andra laddstoppet kl 14:20: Ånej! Exakt varannan laddstolpe vid Löddeköping var upptagen! Teslas Supercharger är så konstruerad att två laddstolpar delar på en laddare. Står det redan en bil och laddar på stolpe 1A får du bara effekten som blir över på stolpe 1B, du bör välja en annan stolpe. Men nu stod det redan bilar på alla A platserna! Vanligtvis spelar lite mindre laddeffekt ingen roll – men nu räknades varenda minut. Efter att ha testat två andra stolpar hittade vi så en som gav 120 kW laddeffekt (andra bilen på den laddaren var nästan färdigladdad). För några veckor sedan skulle vi ha jublat över så hög effekt, men nu ville vi ju ha nya utlovade 150 kW… aldrig är man nöjd. Vi laddade från 11 procent till 67 procent på 44 minuter.</p>



<figure class="wp-block-image size-large"><img decoding="async" width="980" height="650" src="https://elbilen.se/wp-content/uploads/2020/07/1-41.jpg" alt="" class="wp-image-16099" srcset="https://elbilen.se/wp-content/uploads/2020/07/1-41.jpg 980w, https://elbilen.se/wp-content/uploads/2020/07/1-41-300x199.jpg 300w, https://elbilen.se/wp-content/uploads/2020/07/1-41-768x509.jpg 768w" sizes="(max-width: 980px) 100vw, 980px" /><figcaption class="wp-element-caption">Tyska vägarbeten mil efter mil – men autopiloten hade inga problem att följa de gula linjerna istället.</figcaption></figure>



<p>Tredje laddstoppet kl 17:29: Katastrof! När vi kom fram var 8 av de 12 laddstolparna upptagna. Vi fick bara 70 kW laddeffekt. Paniken sprider sig när bilen säger att den vill ladda i en timme. Efter några minuter åker de andra bilarna så vi blir nästan ensamma kvar på hela stationen, endast en annan Tesla till som laddar på en stolpe långt borta från oss &#8211; men vi får ändå inte mer än 80 kW laddeffekt?! Vi segar upp laddningen från 16 procent till 75 procent på 50 minuter medan vi tittar på Glympse-kartan hur vätgasbilen knappar in. Vi åker över Lilla Bält bron samtidigt de åker över Stora Bält. Vi passerar Kolding kl 18:40.</p>



<p>Fjärde laddstoppet kl 19:30: Vi hade äntligen nått tyska Autobahn som har fri fart så vi buskörde de sista milen till Superchargern i Busdorf med bilens maxfart 252 km/h. I de farterna drog bilen runt 6 kWh/mil. När vi kom fram till Superchargern gick bilens fläktar på högvarv för att kyla batterierna – men vi fick 140 kW laddeffekt när vi pluggade in sladden! Från 33 procent till 80 procent på 38 minuter. Samtidigt som vi betraktade vätgasgängets irrfärder i Danmark på kartan. Nu tog fotografen Kasper över ratten.</p>



<p>Femte laddstoppet kl 21:32 i Bispingen. Vi märkte efter ett tag att bilens dator räknade med 130 km/h som fart för sina batteriberäkningar så vi höll den farten (…typ) för att komma fram med 10% batteriladdning. Sedan tog det 45 minuter att ladda upp till 75 procent.</p>



<figure class="wp-block-image size-large"><img decoding="async" width="980" height="627" src="https://elbilen.se/wp-content/uploads/2020/07/1-42.jpg" alt="" class="wp-image-16098" srcset="https://elbilen.se/wp-content/uploads/2020/07/1-42.jpg 980w, https://elbilen.se/wp-content/uploads/2020/07/1-42-300x192.jpg 300w, https://elbilen.se/wp-content/uploads/2020/07/1-42-768x491.jpg 768w" sizes="(max-width: 980px) 100vw, 980px" /><figcaption class="wp-element-caption"><br>Laddningen går långsammare om man måste dela på ett par supercharger-stolpar.<br></figcaption></figure>



<p>Sjätte laddstoppet kl 00:55 i Malsfeld. Stackars Kasper fick masa sig fram med ibland 60 km/h på grund av massor med motorvägsbyggen söder om Hannover. Tack vare det, och ibland till och med negativ förbrukning i nedförsbackarna kring Kassel kom vi fram med hela 25 procent laddning istället för planerade 10 procent. Toppade upp till 40 procent laddning på 15 minuter innan sista sträckan där det åter var undertecknad som greppade ratten. Även den sträckan kännetecknades av vägbyggen, nu i kombination med mörker, dimma och regn. Inget kul väder att köra i – men autopiloten verkade vara opåverkad av det.</p>



<p>MÅL! Kl 02:50</p>



<p>var vi så äntligen framme vid hotellet i Frankfurt som var vårt mål på resan. Vi hade 16 procent laddning kvar i batterierna vid målgång, som vi sedan toppade upp från hotellets laddbox. När vi kom i mål var vätgasbilen fortfarande i höjd med Alsfeld, med drygt 10 mil till att köra. De kom i mål en timme efter oss.</p>



<figure class="wp-block-image size-large"><img decoding="async" width="710" height="1030" src="https://elbilen.se/wp-content/uploads/2020/07/1-43-710x1030.jpg" alt="" class="wp-image-16100" srcset="https://elbilen.se/wp-content/uploads/2020/07/1-43-710x1030.jpg 710w, https://elbilen.se/wp-content/uploads/2020/07/1-43-207x300.jpg 207w, https://elbilen.se/wp-content/uploads/2020/07/1-43-768x1114.jpg 768w, https://elbilen.se/wp-content/uploads/2020/07/1-43-1059x1536.jpg 1059w, https://elbilen.se/wp-content/uploads/2020/07/1-43.jpg 1103w" sizes="(max-width: 710px) 100vw, 710px" /></figure>



<p>Reflektion:</p>



<p>Vi kom fram snabbare än vätgasbilen. Teorin säger någonting helt annat. Men nu var vi ute i verkligheten, som har en förmåga att sätta käppar i hjulet. Och det gäller båda teknikerna.&nbsp;</p>



<p>Tesla hade just några veckor innan knappat in några rader extra kod i sina Supercharger snabbladdares mjukvara och skruvat upp deras maxeffekt från 120 till 150 kW. Och släppt en förbättrad version av sin Model S elbil med en ny strömsnålare motor. Vilket skulle sänka tiden det tar att ladda på långresor.</p>



<p>Efter att ha studerat Tesla Model S laddkurva såg vi att bilen kan ta emot maximal laddeffekt mellan 10 procent och 50 procent batteriladdning. Är batterierna mer eller mindre laddade än så kan man inte ladda lika snabbt. Alltså försökte vi komma fram med 10 procent laddning till laddarna och ladda till 50 procent för att komma fram så snabbt som möjligt.</p>



<p>Vätgasgänget berättar i separat artikel om deras kamp mot verkligheten. Att åka vätgasbil i Europa idag är långt ifrån lika lätt och smärtfritt som det teoretiskt skulle vara. Men även vi i elbilen råkade ut för liknande problem.</p>



<p>150 kW laddeffekt låter jättebra – på pappret. I verkligheten fick vi aldrig över 140 kW. För att inte tala om Katastrofen i Middelfart (som det säkerligen kommer heta i historieböckerna) då vi inte fick mer än 80 kW trots i stort sett tom station. I vanliga fall skulle 10–15 minuter extra laddtid bara fått oss säga “det var väl tråkigt” men nu var ju varenda laddminut viktig!</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">
<figure class="wp-block-image size-large"><img decoding="async" width="1030" height="602" src="https://elbilen.se/wp-content/uploads/2020/07/1-46-1030x602.jpg" alt="" class="wp-image-16102" srcset="https://elbilen.se/wp-content/uploads/2020/07/1-46-1030x602.jpg 1030w, https://elbilen.se/wp-content/uploads/2020/07/1-46-300x175.jpg 300w, https://elbilen.se/wp-content/uploads/2020/07/1-46-768x449.jpg 768w, https://elbilen.se/wp-content/uploads/2020/07/1-46.jpg 1270w" sizes="(max-width: 1030px) 100vw, 1030px" /><figcaption class="wp-element-caption">Förbrukningen blir till och med negativ i nedförsbackarna.</figcaption></figure>
</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="1030" height="671" src="https://elbilen.se/wp-content/uploads/2020/07/1-44-1030x671.jpg" alt="" class="wp-image-16103" srcset="https://elbilen.se/wp-content/uploads/2020/07/1-44-1030x671.jpg 1030w, https://elbilen.se/wp-content/uploads/2020/07/1-44-300x195.jpg 300w, https://elbilen.se/wp-content/uploads/2020/07/1-44-768x500.jpg 768w, https://elbilen.se/wp-content/uploads/2020/07/1-44.jpg 1270w" sizes="(max-width: 1030px) 100vw, 1030px" /><figcaption class="wp-element-caption">Vid topphastigheten förbrukade bilen 6kWh/mil.</figcaption></figure>
</div>
</div>



<p>Av tillverkare angiven laddeffekt, eller laddtid gäller alltid bästa möjliga scenario. Men verkligheten är sällan den bästa möjliga. Laddtider påverkas av batteriernas laddprocent, deras skick, omgivningstemperaturen, hur många andra som laddar på samma station och, som det verkar, månens fas. För någon annan anledning till dåliga fjutten i Middelfart kan vi inte komma på.</p>



<p>Men hur snabbt skulle vi kunnat åkt i en Voltairansk bästa värld av alla tänkbara världar? Tesla Model 3 kan ju laddas med 250 kW på de Supercharger V3 stationer som nu har börjat byggas i USA. Den skulle ha laddat på drygt 10 minuter per laddstopp istället för våra 37 minuter. I teorin i alla fall.</p>



<p>Det var inte bara vätgasbilen som var hindrad av sin infrastruktur. Så var faktiskt även elbilen. Men sådan är verkligheten: den blir aldrig lika bra som teorin.</p>



<p>Nu vann elbilen med en timme. Skulle vätgasbilen kunnat köra som i teorin skulle de vunnit med minst lika mycket. Skulle elbilen kunnat köra som i teorin skulle skillnaden blivit mycket mindre, kanske rent av försumbar. Det enda som vi lärt oss av resan är dock att det blir aldrig som i teorin.</p>



<figure class="wp-block-image size-large"><img decoding="async" width="856" height="650" src="https://elbilen.se/wp-content/uploads/2020/07/1-45.jpg" alt="" class="wp-image-16101" srcset="https://elbilen.se/wp-content/uploads/2020/07/1-45.jpg 856w, https://elbilen.se/wp-content/uploads/2020/07/1-45-300x228.jpg 300w, https://elbilen.se/wp-content/uploads/2020/07/1-45-768x583.jpg 768w" sizes="(max-width: 856px) 100vw, 856px" /><figcaption class="wp-element-caption">Som avkoppling&nbsp;medan vi laddade&nbsp;körde vi lite bilspel.<br></figcaption></figure>



<figure class="wp-block-image size-large"><img decoding="async" width="1030" height="527" src="https://elbilen.se/wp-content/uploads/2020/07/1-47-1030x527.jpg" alt="" class="wp-image-16104" srcset="https://elbilen.se/wp-content/uploads/2020/07/1-47-1030x527.jpg 1030w, https://elbilen.se/wp-content/uploads/2020/07/1-47-300x154.jpg 300w, https://elbilen.se/wp-content/uploads/2020/07/1-47-768x393.jpg 768w, https://elbilen.se/wp-content/uploads/2020/07/1-47.jpg 1270w" sizes="(max-width: 1030px) 100vw, 1030px" /><figcaption class="wp-element-caption">Äntligen i mål! Får vi gå och sova nu?</figcaption></figure>



<h2 class="wp-block-heading">Kolding–Frankfurt, 78,5 mil tog 1h&nbsp;och 17 minuter längre tid för Teslan</h2>



<p class="has-drop-cap"><strong>P</strong>å grund av strul med tankningen i Danmark, och vätgasbilens tur via Mariestad istället för rakt ner på E4:an blev testet inte helt jämförbart. Men sträckan mellan Kolding och Frankurt skedde utan svårigheter. Det är 78,5 mil mellan de två platserna.&nbsp;</p>



<p>Vätgasbilen fick tanka på två ställen och Teslan, som var tämligen nyladdad behövde tre laddstopp.&nbsp;Vätgasbilen Nexo passerade Kolding klockan 20.55 och var i mål klockan 03.48. Det ger 6 timmar och 53 minuters körning. Delar av sträckan skedde dock på Autobahn.&nbsp;</p>



<p>Teslan passerade Kolding klockan 18.40 och var i mål klockan 02.50. Det ger en kör- och laddtid på 8h 10 minuter.&nbsp;</p>



<p>Det ger 1h och 17 minuter längre körtid för Teslan på en sträcka på närmare 80 mil med mycket Autobahn. Då ska vi tillägga att vi som körde vätgasbil inte tog några som helst pauser på vägen, vilket är möjligt. Teslaföraren tvingas till lite längre pauser. Samtidigt är det inte ett normalt scenario att köra så här långt utan att ta längre pauser med mat som intas vid ett bord och inte i förarstolen.</p>



<figure class="wp-block-image size-large"><img decoding="async" width="1030" height="654" src="https://elbilen.se/wp-content/uploads/2020/07/1-48-1030x654.jpg" alt="" class="wp-image-16105" srcset="https://elbilen.se/wp-content/uploads/2020/07/1-48-1030x654.jpg 1030w, https://elbilen.se/wp-content/uploads/2020/07/1-48-300x191.jpg 300w, https://elbilen.se/wp-content/uploads/2020/07/1-48-768x488.jpg 768w, https://elbilen.se/wp-content/uploads/2020/07/1-48-1536x975.jpg 1536w, https://elbilen.se/wp-content/uploads/2020/07/1-48.jpg 1600w" sizes="(max-width: 1030px) 100vw, 1030px" /><figcaption class="wp-element-caption">Framme vid hotellet i Frankfurt och årets stora bilmässa. Teslan hann före, men båda bilarna vann i mot i stort sett alla andra på vägarna. De tog sig fossilfritt hela vägen från Stockholm. Från vänster, Johan Stenvall, Fredrik Sandberg och Tibor Blomhäll.</figcaption></figure>



<div class="wp-block-cover is-light"><span aria-hidden="true" class="wp-block-cover__background has-very-dark-gray-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">
<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p>Kommentar</p>
</blockquote>



<h2 class="wp-block-heading">Det här gör att vi väljer laddbart</h2>



<p>I teorin skulle vätgasbilen ha vunnit över elbilen på grund av dess snabba tankning mot elbilens långsammare laddning. Nu var det dock inte i teorin utan i verklighetens 2019 bilarna åkte mot sina mål.&nbsp;</p>



<p>Teslan nådde inte upp till sina teoretiska laddhastigheter på alla laddstationer och Vätgasbilen fick slita för att få igång tankstationerna i Danmark.&nbsp;</p>



<p>Men visst kommer det att gå snabbare att köra vätgasbil när stationerna är på plats. Även om den här tiden kommer att krympa när nästa generations snabbladdning är på plats, med laddning upp till 250 kW för Tesla Model 3 och 200 kW för Tesla Model S (endast på V3 supercharger) och bilar med 800 Voltssystem som kan ladda på Ionitys laddstationer.&nbsp;</p>



<p>Nuvarande siffror kan nog avskräcka ett fåtal som faktiskt inte vill stå en halvtimme på en supercharger, utan vill blåsa vidare och gärna köra minst 50 mil innan de tankar. För de flesta gör en dryg timmars skillnad på en 80-milaresa ingen större skillnad. Då finns ju tid för att äta och ta en rast.&nbsp;</p>



<p>Vi som körde vätgasbilen hade aldrig kört på det sätt vi nu brände på om vi inte hade jagat en Tesla. Då hade välbehövliga raster intagits.&nbsp;</p>



<p>Men de stora skillnaderna handlar om kostnader och förbrukning. Det kostar dubbelt så mycket att köra vätgasbil på långkörning. I alla fall om man utgår från Teslas priser. Det spelar kanske mindre roll om långkörningen sker ett par gånger per år. Men när väl Teslan är hemma minskar förbrukningskostnaden rejält, då pluggar man in i sin laddare och kör på ett par tre kronor per mil. När vätgasbilen har kommit hem, tvingas den till pumpstationen för att fortsätta att tanka för samma kostnad som på långturen, alltså kring 10 kronor per mil. Lika dyrt som en vanlig dieselbil med andra ord.&nbsp;</p>



<p>Dessutom ser vi att det krävdes 1 190 kWh, alltså 1,19 MWh att köra en omväg till Frankfurt, medan Teslan endast förbrukade 364 kWh. Ca tre gånger så mycket energi går alltså åt för att köra vätgas istället för att ladda batterierna. Då vill det till att det finns mycket grön energi att tillgå. Om detta spörsmål, läs mer på sid 52.&nbsp;</p>



<p>De här faktorerna gör att vi faktiskt är eniga om att vi väljer den laddbara bilen framför vätgastekniken. Även om vätgas går fort att tanka, står förbättrad laddningskapacitet runt hörnet och kostnaderna är lägre, betydligt lägre för batteribilen i den dagliga användningen. Energiåtgången vid körning av vätgas är också ett hinder, det vill till att produktionen blir grön, som i Mariestad. Den tankstationen är ett föredöme. För vem bryr sig om ökad energiåtgång om det är solpaneler på plats som producerar bränslet?</p>
</div></div>



<figure class="wp-block-image size-large"><img decoding="async" width="471" height="1030" src="https://elbilen.se/wp-content/uploads/2020/07/1-49-471x1030.jpg" alt="" class="wp-image-16106" srcset="https://elbilen.se/wp-content/uploads/2020/07/1-49-471x1030.jpg 471w, https://elbilen.se/wp-content/uploads/2020/07/1-49-137x300.jpg 137w, https://elbilen.se/wp-content/uploads/2020/07/1-49-702x1536.jpg 702w, https://elbilen.se/wp-content/uploads/2020/07/1-49.jpg 731w" sizes="(max-width: 471px) 100vw, 471px" /></figure>



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



<h2 class="wp-block-heading has-text-align-center">Betyg Nexo</h2>



<p>Köregenskaper: Nexo är en mycket trevlig bil att köra. Den känns ganska nätt i stadstrafik trots sin storlek. Det som drar ner köregenskaperna framförallt i jämförelse med andra piggare elbilar är de rätt svaga elmotorerna. Accelerationen är långt ifrån blixtrande även om det fungerar bra i stadstrafik. Den dåliga omkörningsprestandan är en klar Akilleshäl. För att inte tala om att försöka kasta sig ut i omkörningsfilen på autobahn. Bilen trivs klart bäst på lite mindre landsvägar.</p>



<p>Betyg: 3&nbsp;&nbsp;</p>



<p>Komfort: Sällan har vi suttit så bra i en bil på långfärd. Det kändes nästan direkt, vi satt riktigt bra hela resan. Ratten hade kunnat få vara lite mer justerbar i längdled men det är verkligen en kommentar i marginalen. Att sätena också var ventilerade för behaglig kylning är också ett plus. Att Nexo ändå inte får 5 av 5 beror på ljudet i kupén. I låga farter var det behagligt men i motorvägsfart så blev däckljudet klart påtagligt på ett sätt som inte känns premium.&nbsp;</p>



<p>Betyg:&nbsp; 4</p>



<p>Säkerhet: Nexo har alla de moderna säkerhetssystem som kan förväntas av en bil som ska vara i framkant. Autobroms för många olika situationer, kollisionsvarning, döda­vinkelnvarning, och trötthetsvarnare finns. Men det är inga system som revolutionerar på något sätt utan är mer i linje med vad som kan förväntas. Den passiva säkerheten är också mycket bra utifrån de tester som gjorts av Euro NCAP, Nexo fick utmärkelse för att vara en av de bästa i sin klass vid testerna.&nbsp;</p>



<p>Belysningen var dock inte alls så bra. Både hel och halvljus verkade lida av det futuristiska utseendet på lamporna, vilket drar ner betyget.</p>



<p>Betyg: 4&nbsp;&nbsp;</p>



<p>Miljö: En vätgasbil är självklart ett bra miljöval. Vätgasen som fyller tankarna ger endast vatten som restprodukt när den omvandlas till ström i bränslecellen. Det är fascinerande att tanka vid en pump som den i Mariestad och veta att bränslet producerats på plats av de solceller som står på åkern bredvid. Att kunna lagra mycket energi lokalt vid källan där den produceras är en spännande teknik. Att bilen också kan göras lite lättare än en elbil med stort batteri är också en miljöfördel.&nbsp;</p>



<p>Men det stora problemet är energiförlusterna i den långa kedjan av omvandlingar. Av el ska vätgas framställas som ska kylas för att kunna tankas snabbt och sen omvandlas till el igen i bilen. Där är den konventionella elbilen överlägsen.</p>



<p>Betyg: 4&nbsp;</p>



<p>Autonomi: Nexo har en väl fungerande körfältsassistans. Den känns trygg och håller bilen bra i sin fil utan att svaja mellan linjerna som vissa sämre system kan göra. Men varför är den så svår att slå på? Det ska ju kunna göras med en enkel knapptryckning så att båda händerna under en kort stund kan användas för att till exempel öppna en vattenflaska. I Nexo kräver det ett navigerande i menyer för att klicka i systemet. Då blir den alltid aktiverad tillsammans med farthållaren och för att avaktiveras så behöver föraren igen gå in i menyerna igen. Märkligt.&nbsp;</p>



<p>Betyg:&nbsp; 4</p>



<p>Utrustning: Det är en välutrustad bil. Det är inga moderna funktioner som saknas. Allt manövreras med en uppsjö av knappar på den stora mittkonsolen. Ja förutom den nämnda körfältsassistansen. Att använda knappar istället för val i en tryckkänslig skärmlösning kan ha fördelar. Här är dock knapparna förvillande lika och det behövs samma fokus av föraren för att hitta rätt knapp som att navigera på en skärm. Bilen har två stora tydliga skärmar men grafiken känns lite daterad.&nbsp;</p>



<p>En märklig brist var avsaknaden av regnsensor för vindrutetorkaren.&nbsp;</p>



<p>En trevlig detalj är kameror i sidobakspeglarna vars bild visas i skärmen framför föraren när blinkersen slås på. Det funkar jättebra och är en funktion man snabbt vänjer sig vid.</p>



<p>Betyg:&nbsp; 4</p>



<p>Utrymmen: Kupéutrymmena är utmärkta. Det finns gott om plats i baksätet även bakom en lång förare. Att sitta tre i baksätet fungerar också bra. Lastutrymmet lider dock lite av gastankar och batteri under bagageutrymmet. Lastgolvet är högt men i övrigt är det ganska djupt och brett, 461 liter last rymmer det vilket är helt ok. Fälls baksätena får man nästan 1500 liter.&nbsp;</p>



<p>Betyg:&nbsp; 4</p>



<p>Ekonomi: En dyr bil drar ner ekonomibetyget. Andrahands värdet är också väldigt osäkert. Bränslecellen håller bara 16000 mil. Men ekonomibetyget dras också ner av att det är så mycket dyrare att köra på vätgas än på el laddad direkt i ett batteri. Vätgasföraren får betala för all el som förloras i vätgaskjedjan också.&nbsp;</p>



<p>Betyg:&nbsp; 3</p>



<p>Räckvidd: Det här är Nexos paradgren. Räckvidden känns fantastisk. Vi hade inga problem men att nå 60 mil utan att spara på gasen och mycket motorvägskörning. Skulle det gå långsammare så skulle säkert 70–80 mil kunna nås om hastigheten hölls vid 80–90 km/h. Det är imponerande. .&nbsp;</p>



<p>Betyg:&nbsp; 5</p>



<p>Laddning: Ja tankning är det ju i detta fall. Det blir toppbetyg här också, det går snabbt att tanka gas och det upplevs precis som att tanka en fosilbil.&nbsp;</p>



<p>Betyg:&nbsp; 5</p>



<p>Utseende: Vi föll för Nexos utseende. Den ser mycket bra ut i den matta lacken blandat med blänkande kromdetaljer. Riktigt snyggt är också ljusarrangemanget fram, det ger bilen en futuristisk framtoning i mörker.</p>



<h2 class="wp-block-heading has-text-align-center has-text-color" style="color:#20bdc4">Totalt:&nbsp; 40 av 50&nbsp; poäng</h2>



<p>SUMMA SUMMARUM</p>



<p>Nexo är en utmärkt bil. Bekväm, lång räckvidd, lagom praktisk och stor. Den är också riktigt snygg. Om man bortser från att vätgasinfrastrukturen inte finns i Sverige utan tänker sig att den var väl fungerande som i Tyskland så är det helt klart en väl fungerande lösning. Men ändå, en bil för vem?</p>



<div class="wp-block-media-text alignwide is-stacked-on-mobile"><figure class="wp-block-media-text__media"><img decoding="async" width="1030" height="698" src="https://elbilen.se/wp-content/uploads/2020/07/1-50-1030x698.jpg" alt="" class="wp-image-16107 size-full" srcset="https://elbilen.se/wp-content/uploads/2020/07/1-50-1030x698.jpg 1030w, https://elbilen.se/wp-content/uploads/2020/07/1-50-300x203.jpg 300w, https://elbilen.se/wp-content/uploads/2020/07/1-50-768x520.jpg 768w, https://elbilen.se/wp-content/uploads/2020/07/1-50.jpg 1063w" sizes="(max-width: 1030px) 100vw, 1030px" /></figure><div class="wp-block-media-text__content">
<p>Här tankar vi vätgas i Tyskland. Alla tankstopp vi gjorde i Tyskland fungerade prickfritt. Full tank på under fem minuter. De låg dock inte alltid jättebra till, utan krävde sina små omvägar mellan varven.&nbsp;</p>



<p>Förbrukning och räckvidd:</p>



<p>Temperatur: 18–20 grader vid förbrukningstestet.&nbsp;</p>



<p>Officiell räckvidd: 660 km WLTP.</p>



<p>Räckvidd på långa provkörningen: 600 km i motorvägsfart.</p>



<p>Av Elbilen i Sverige uppmätt förbrukning, jämn fart, plan mark,</p>



<p>18 C: 100 km/h: 1 kg/100 km – ger 60 mils räckvidd. 150–160 km/h: 2,4 kg/100 km – ger 29 mils räckvidd.</p>
</div></div>



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



<figure class="wp-block-table is-style-stripes"><table><tbody><tr><td><strong>Pris:</strong></td><td>849 900 kr</td></tr><tr><td><strong>Deklarerad räckvidd:</strong></td><td>660 km (WLTP)</td></tr><tr><td><strong>Tankvolym:</strong></td><td>156,6 liter/6,3 kg vätgas</td></tr><tr><td><strong>Drivning:</strong></td><td>fram</td></tr><tr><td><strong>Motoreffekt:</strong></td><td>120 kW</td></tr><tr><td><strong>Vridmoment:</strong></td><td>395 Nm</td></tr><tr><td><strong>Acceleration 0-100 km/h:</strong></td><td>9,2 sek</td></tr><tr><td><strong>Toppfart:</strong></td><td>179 km/h</td></tr><tr><td><strong>Antal sittplatser:</strong></td><td>5</td></tr><tr><td><strong>Yttermått LxBxH:</strong></td><td>4670 x 1860 x 1640 mm</td></tr><tr><td><strong>Tjänstevikt:</strong></td><td>1873 kg</td></tr><tr><td><strong>Bagageutrymme:</strong></td><td>461 l</td></tr><tr><td><strong>Dragvikt:</strong></td><td>Ej dragkrok</td></tr></tbody></table></figure>



<figure class="wp-block-image size-large"><img decoding="async" width="512" height="311" src="https://elbilen.se/wp-content/uploads/2020/07/unnamed-21.jpg" alt="" class="wp-image-16108" srcset="https://elbilen.se/wp-content/uploads/2020/07/unnamed-21.jpg 512w, https://elbilen.se/wp-content/uploads/2020/07/unnamed-21-300x182.jpg 300w" sizes="(max-width: 512px) 100vw, 512px" /><figcaption class="wp-element-caption">Hjulbas: 2 700 mm<br>Totallängd: 4 490 mm<br>Bredd: 1 788mm<br>Höjd: 1 545 mm</figcaption></figure>



<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">
<figure class="wp-block-image size-large"><img decoding="async" width="437" height="354" src="https://elbilen.se/wp-content/uploads/2020/07/unnamed-22.jpg" alt="" class="wp-image-16109" srcset="https://elbilen.se/wp-content/uploads/2020/07/unnamed-22.jpg 437w, https://elbilen.se/wp-content/uploads/2020/07/unnamed-22-300x243.jpg 300w" sizes="(max-width: 437px) 100vw, 437px" /><figcaption class="wp-element-caption">BAGAGE.<br>Trots biffiga vätgastankar är utrymmet för lastning tämligen bra, ägen om golvet är aningen högt.&nbsp;<br></figcaption></figure>



<figure class="wp-block-image size-large"><img decoding="async" width="414" height="512" src="https://elbilen.se/wp-content/uploads/2020/07/unnamed-24.jpg" alt="" class="wp-image-16111" srcset="https://elbilen.se/wp-content/uploads/2020/07/unnamed-24.jpg 414w, https://elbilen.se/wp-content/uploads/2020/07/unnamed-24-243x300.jpg 243w" sizes="(max-width: 414px) 100vw, 414px" /><figcaption class="wp-element-caption">Maffig mittkontroll.<br>En gigantisk panel för att sköta bilens kontroller och underhållning. Kanske onödigt<br></figcaption></figure>
</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="437" height="413" src="https://elbilen.se/wp-content/uploads/2020/07/unnamed-23.jpg" alt="" class="wp-image-16110" srcset="https://elbilen.se/wp-content/uploads/2020/07/unnamed-23.jpg 437w, https://elbilen.se/wp-content/uploads/2020/07/unnamed-23-300x284.jpg 300w" sizes="(max-width: 437px) 100vw, 437px" /><figcaption class="wp-element-caption">baksäte.<br>Riktigt sköna baksäten med gott om utrymme. &nbsp;<br></figcaption></figure>



<figure class="wp-block-image size-large"><img decoding="async" width="437" height="386" src="https://elbilen.se/wp-content/uploads/2020/07/unnamed-25.jpg" alt="" class="wp-image-16112" srcset="https://elbilen.se/wp-content/uploads/2020/07/unnamed-25.jpg 437w, https://elbilen.se/wp-content/uploads/2020/07/unnamed-25-300x265.jpg 300w" sizes="(max-width: 437px) 100vw, 437px" /><figcaption class="wp-element-caption">komfort. Nexo är väldigt komfortabel på långtur och har små finesser som utfällbar mugghållare.</figcaption></figure>
</div>
</div>



<h2 class="wp-block-heading has-text-align-center has-very-dark-gray-color has-text-color">BETYG MODEL S</h2>



<p>Telsa Motors Clubs ordförande sätter betyg på omgörningen.</p>



<p>Det märks inte på utsidan, bilen ser exakt likadan ut som förut. Den har inte fått någon ny modellbeteckning, ingen ny dekal på bakluckan. Det är inte ens en ny årsmodell – Tesla har ju inga årsmodeller. De bara införde ”lite förbättringar” på bilarna på produktionslinan i somras. Nu har resultatet kommit till Sverige: en Tesla Model S som känns mer sofistikerad än någonsin.</p>



<p>I avsaknad av nytt namn eller modellbeteckning kallar Tesla-kännare de nya bilarna efter projektets läckta interna namn ”Raven”. Det pratas mest om nya främre motorn som nu är samma sorts permanentmagnetassisterad reluktansmotor som finns i Tesla Model 3. Den motortypen är extremt energieffektiv vilket har gett bilen ökad räckvidd trots oförändrad batteripack. Men det är inte motorbytet du märker när du kör bilen, den accelererar precis lika kvickt som förut. Utan det man framför allt märker är nya luftfjädringen som förutom åkhöjd nu även kan justera stötdämparnas karakteristik, få till mjukare eller hårdare fjädring. Vilket har gjort under för väghållningen och fjädringskomforten.</p>



<p>Vägens ojämnheter sväljs och bilen liksom svävar fram – men utan den där ”amerikanska” lite svampiga känslan Tesla förut hade. En mjuk fjädring som ändå ger bilen närvaro är en mycket svår konst, fjädringen känns nu mycket mer ”europeisk”. Svårt att beskriva med ord men det märks på en gång ute på vägarna. ”Värdigt” var ordet som poppade upp i mitt huvud när jag körde. Nya fjädringen i kombination med förbättrad ljudisolering ger en mycket tystare kabin utan störande väg- och vindljud i höga farter.</p>



<p>Även resten av bilen verkar ha fått en genomgång. Dörren stängs nu med en ”thump”, inte ”klonk” som förut. Nya Tesla Model S känns mycket mer sofistikerad än förut.</p>



<p>Köregenskaper: Nya fjädringen har gjort mirakel med bilens vägegenskaper. Svampigheten är borta. Accelerationen lämnar ingen oberörd.</p>



<p>Betyg: 5&nbsp;</p>



<p>Komfort: Kupén har blivit mycket tystare än förut. Inget vindbrus eller däckljud som förstör premiumkänslan längre. Materialvalet så bra det kan bli med vegan-inredning.</p>



<p>Betyg:&nbsp; 5</p>



<p>Säkerhet: 5 stjärnor i alla krockprover på alla kontinenter.</p>



<p>Betyg:&nbsp; 5</p>



<p>Miljö – förbrukning: Nya motorn har gjort mirakel med förbrukningen och därmed räckvidden. Att en så stor elbil kan ha 1.6 kWh/mil förbrukning och 61 mil WLTP räckvidd gör konkurrenterna gröna – av avund.</p>



<p>Betyg:&nbsp; 5</p>



<p>Autonomi: Inte nog med att autopiloten är överlägsen andra tillverkares liknande system, den blir dessutom bara bättre och bättre för varje ny programversion som skickas ut trådlöst.</p>



<p>Betyg:&nbsp; 5</p>



<p>Utrustning: Teslas enda bilmodell som inte kan fås med dragkrok.</p>



<p>Betyg:&nbsp; 4</p>



<p>Utrymmen: Gigantiskt bagageutrymme plus en frunk under huven framme också.</p>



<p>Betyg: 5</p>



<p>Ekonomi: Inte billigaste elbilen på marknaden (inte dyraste heller) men definitivt prisvärd. Skulle inte Model 3 funnits skulle det blivit fullpott även här.</p>



<p>Betyg:&nbsp; 4</p>



<p>Räckvidd: Tesla leder räckviddsligan: med 61 mil WLTP räckvidd kommer den dubbelt så långt som flera andra elbilar &#8211; eller lika långt som BMW M5 bensintank räcker…</p>



<p>Betyg:&nbsp; 5</p>



<p>Laddning: Upp till 150 kW laddning på Supercharger, 200 kW på Supercharger V3, och 16 kW trefas hemmaladdning.</p>



<p>Betyg:&nbsp; 5</p>



<p>Utseende: Tesla Model S är en tidlös, klassisk om än kanske lite anonym skönhet.</p>



<h2 class="wp-block-heading has-text-align-center has-text-color" style="color:#20bdc4">Totalt:&nbsp;48 av 50&nbsp;poäng</h2>



<p>SUMMA SUMMARUM</p>



<p>Förut var Tesla Model S en premiumbil… av ”amerikansk” snitt. Nu har den blivit en premiumbil även med europeiska mått mätt.</p>



<p><strong>En andra åsikt</strong></p>



<figure class="wp-block-image size-large"><img decoding="async" width="295" height="295" src="https://elbilen.se/wp-content/uploads/2020/07/1-51.jpg" alt="" class="wp-image-16113" srcset="https://elbilen.se/wp-content/uploads/2020/07/1-51.jpg 295w, https://elbilen.se/wp-content/uploads/2020/07/1-51-80x80.jpg 80w" sizes="(max-width: 295px) 100vw, 295px" /></figure>



<p>Fredrik Sandberg</p>



<p>Vi lät Telsa Motors Clubs ordförande sätta betyg på nya Model S. Hur tycker han att den har förbättrats? Hans betyg här vid sidan kan då folk tycka är ren propaganda från sektledaren själv. Men det är inte svårt att hålla med honom. Nya Model S har faktiskt blivit en bättre bil än tidigare. Kommer då Tesla upp till tyskarnas eller Volvos nivå av kvalitetskänsla?&nbsp;</p>



<p>Ja och nej. Fjädringen är bättre och jag tycker att stolarna har fått ett lyft.&nbsp;</p>



<p>Men i jämförelse med en tysk kärra från exempelvis BMW, ta nya 745 Le Xdrive (läs om den i nästa nummer), når de inte fram till den där känslan av att vilja bosätta sig i bilen. Trots ny isolering låter den mer. Sätena är inte i samma klass och kvalitetskänslan är inte riktigt där i materialval och smådetaljer som kupéljus och annat. Den saknar dessutom trådlös laddning av mobilen – ett tecken på att den har åldrats. Men till skillnad från i stort sett alla de europeiska premiumbyggare går den bara på el och har motorer som är effektivare än alla andra. Och så har den ju karaoke., Och Netflix. Och spel. Och mjukvaruuppdateringar. Och en prestanda som den är ensam om i den här klassen. Den står sig kort och gott som no1.</p>



<div class="wp-block-media-text alignwide is-stacked-on-mobile"><figure class="wp-block-media-text__media"><img decoding="async" width="1030" height="678" src="https://elbilen.se/wp-content/uploads/2020/07/1-52-1030x678.jpg" alt="" class="wp-image-16114 size-full" srcset="https://elbilen.se/wp-content/uploads/2020/07/1-52-1030x678.jpg 1030w, https://elbilen.se/wp-content/uploads/2020/07/1-52-300x197.jpg 300w, https://elbilen.se/wp-content/uploads/2020/07/1-52-768x506.jpg 768w, https://elbilen.se/wp-content/uploads/2020/07/1-52.jpg 1106w" sizes="(max-width: 1030px) 100vw, 1030px" /></figure><div class="wp-block-media-text__content">
<p>Max laddhastighet kan uppnås mellan 10 och 50 procent</p>



<p>batteriladdnivå. I teorin. Vid våra laddningar kom vi aldrig över 140 kW. Vid högre laddnivåer avtar laddhastigheten.&nbsp;</p>



<p>Förbrukning och räckvidd: Temperatur: 13 till 16 grader vid förbrukningstestet.&nbsp;Officiell räckvidd: 610 km WLTP. Räckvidd vid vår provkörning på svensk motorväg: 485 km</p>
</div></div>



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



<figure class="wp-block-table is-style-stripes"><table><tbody><tr><td><strong>Pris:</strong></td><td>946 080 kr</td></tr><tr><td><strong>Batterikapacitet:</strong></td><td>100 kWh</td></tr><tr><td><strong>Deklarerad räckvidd:</strong></td><td>610 km (WLTP)</td></tr><tr><td><strong>Snabbladdning</strong>:</td><td>200 kW</td></tr><tr><td><strong>Ombordladdare:</strong></td><td>16,5 kW</td></tr><tr><td><strong>Drivning:</strong></td><td>fyrhjulsdrift</td></tr><tr><td><strong>Motoreffekt:</strong></td><td>Okänd</td></tr><tr><td><strong>Max uteffekt batteri:</strong></td><td>311 kW</td></tr><tr><td><strong>Vridmoment:</strong></td><td>660 Nm</td></tr><tr><td><strong>Acceleration 0-100 km/h:</strong></td><td>3,8 sek</td></tr><tr><td><strong>Toppfart:</strong></td><td>250 km/h</td></tr><tr><td><strong>Antal sittplatser:</strong></td><td>5</td></tr><tr><td><strong>Yttermått LxBxH:</strong></td><td>4979 x 2187 x 1440 mm</td></tr><tr><td><strong>Tjänstevikt:</strong></td><td>2 200 kg</td></tr><tr><td><strong>Bagageutrymme:</strong></td><td>894 l</td></tr><tr><td><strong>Dragvikt:</strong></td><td>Ej dragkrok</td></tr></tbody></table></figure>



<figure class="wp-block-image size-large"><img decoding="async" width="1030" height="554" src="https://elbilen.se/wp-content/uploads/2020/07/1-53-1030x554.jpg" alt="" class="wp-image-16115" srcset="https://elbilen.se/wp-content/uploads/2020/07/1-53-1030x554.jpg 1030w, https://elbilen.se/wp-content/uploads/2020/07/1-53-300x161.jpg 300w, https://elbilen.se/wp-content/uploads/2020/07/1-53-768x413.jpg 768w, https://elbilen.se/wp-content/uploads/2020/07/1-53-1536x825.jpg 1536w, https://elbilen.se/wp-content/uploads/2020/07/1-53.jpg 1565w" sizes="(max-width: 1030px) 100vw, 1030px" /><figcaption class="wp-element-caption">Hjulbas: 2 960 mm<br>Totallängd: 4 979 mm<br>Höjd: 1 440 mm<br>Bredd: 2 187 mm<br></figcaption></figure>



<figure class="wp-block-image size-large"><img decoding="async" width="438" height="308" src="https://elbilen.se/wp-content/uploads/2020/07/unnamed-26.jpg" alt="" class="wp-image-16116" srcset="https://elbilen.se/wp-content/uploads/2020/07/unnamed-26.jpg 438w, https://elbilen.se/wp-content/uploads/2020/07/unnamed-26-300x211.jpg 300w" sizes="(max-width: 438px) 100vw, 438px" /><figcaption class="wp-element-caption">Under lastgolvet till enorma bakre bagageutrymmet döljer sig ett gigantiskt extra utrymme. Räcker inte det finns det ännu mer utrymme i frunken under framhuven.</figcaption></figure>



<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"><img decoding="async" width="437" height="354" src="https://elbilen.se/wp-content/uploads/2020/07/unnamed-27.jpg" alt="" class="wp-image-16117" srcset="https://elbilen.se/wp-content/uploads/2020/07/unnamed-27.jpg 437w, https://elbilen.se/wp-content/uploads/2020/07/unnamed-27-300x243.jpg 300w" sizes="(max-width: 437px) 100vw, 437px" /><figcaption class="wp-element-caption">Tesla Model S har vegan-inredning i svart, vit eller krämfärgad konstläder. 17 tums mittskärm. HEPA luftfilter med Bioweapon Defense mode.</figcaption></figure>
</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="437" height="378" src="https://elbilen.se/wp-content/uploads/2020/07/unnamed-28.jpg" alt="" class="wp-image-16118" srcset="https://elbilen.se/wp-content/uploads/2020/07/unnamed-28.jpg 437w, https://elbilen.se/wp-content/uploads/2020/07/unnamed-28-300x259.jpg 300w" sizes="(max-width: 437px) 100vw, 437px" /><figcaption class="wp-element-caption">Det går att åka tre vuxna i baksätet men långväxta kan få problem med låga taket. Ny utformning av ryggstödet gör dock att man slår inte huvudet i bakrutans balk längre.<br></figcaption></figure>



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



<figure class="wp-block-image size-large"><img decoding="async" width="438" height="295" src="https://elbilen.se/wp-content/uploads/2020/07/1-54.jpg" alt="" class="wp-image-16119" srcset="https://elbilen.se/wp-content/uploads/2020/07/1-54.jpg 438w, https://elbilen.se/wp-content/uploads/2020/07/1-54-300x202.jpg 300w" sizes="(max-width: 438px) 100vw, 438px" /><figcaption class="wp-element-caption">appen.<br>Kopplar upp sig snabbt och pålitligt till bilen och kan kontrollera mycket av bilens funktioner.<br></figcaption></figure>



<div class="wp-block-media-text alignwide is-stacked-on-mobile"><figure class="wp-block-media-text__media"><img decoding="async" width="295" height="201" src="https://elbilen.se/wp-content/uploads/2020/07/unnamed-29.jpg" alt="" class="wp-image-16120 size-full"/></figure><div class="wp-block-media-text__content">
<p>Batteriet är exakt samma 100 kWh batteripack som i tidigare Tesla Model S.</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>Motor 1 Främre motorn är bytt till PMA reluktansmotor för att få ner förbrukningen</p>
</div><figure class="wp-block-media-text__media"><img decoding="async" width="295" height="201" src="https://elbilen.se/wp-content/uploads/2020/07/unnamed-30.jpg" alt="" class="wp-image-16121 size-full"/></figure></div>



<div class="wp-block-media-text alignwide is-stacked-on-mobile"><figure class="wp-block-media-text__media"><img decoding="async" width="295" height="201" src="https://elbilen.se/wp-content/uploads/2020/07/unnamed-31.jpg" alt="" class="wp-image-16122 size-full"/></figure><div class="wp-block-media-text__content">
<p>Motor 2 Bakre motorn är dock samma asynkrona motor som förut, för att behålla bilens extrema acceleration.&nbsp;</p>
</div></div>



<h2 class="wp-block-heading">Vätgas – hot eller löfte</h2>



<p><strong>Vi samlade ihop invändningarna mot vätgas och ställde två aktörer mot väggen för att få svar på hur man ska se på tekniken.</strong></p>



<pre class="wp-block-preformatted">Text: Fredrik Sandberg</pre>



<figure class="wp-block-image size-large"><img decoding="async" width="512" height="292" src="https://elbilen.se/wp-content/uploads/2020/07/unnamed-32.jpg" alt="" class="wp-image-16123" srcset="https://elbilen.se/wp-content/uploads/2020/07/unnamed-32.jpg 512w, https://elbilen.se/wp-content/uploads/2020/07/unnamed-32-300x171.jpg 300w" sizes="(max-width: 512px) 100vw, 512px" /><figcaption class="wp-element-caption">Antalet vätgasstationer i norra Europa just nu.&nbsp;<br></figcaption></figure>



<p class="has-drop-cap"><strong>D</strong>en som befinner sig på Twitter eller andra debattforum och skriver om vätgas har nog sett invändningarna. I stort sett alla elbilssajters kommentatorsfält är fulla av resonemang kring hur energieffektiviteten är usel i vätgasbilar och att det är en teknologi som aldrig kommer att slå igenom.&nbsp;</p>



<p>I vintras besökte vi Sandviken och AGAs stora elektrolysör för att gräva djupar i teknikens möjligheter. Efter den artikeln fick vi en mängd mejl med upprörda röster som tycker att vätgas har så många brister att vi inte borde skriva om det. Jag har lugnande besked. Batteribilar kommer inte att försvinna i takt med bränslecellernas intåg på marknaden om några år. I alla fall inte om man ser på prognoserna i dag, och hur väl batteritekniken börjar fungera. Men det tillverkas närmare 80 miljoner bilar per år i världen och batteribrist är en realitet redan i dag. Kan man inte ge vätgasen en chans, som ett komplement och se det som ytterligare en teknik för nollemissionsbilism? Här finns ju uppenbara fördelar, som storskaliga lagringsmöjligheter och snabb tankning för stora tunga fordon.&nbsp;</p>



<p>I samband med den här körningen har vi samlat ihop era invändningar och frågor och vänt oss till svenska företaget Cellimpact och Vätgas Sverige för att försöka räta ut frågetecknen.&nbsp;</p>



<p>Cell Impact är ett företag som tillverkar flödesplattor och produktionsteknologi till tillverkare av bränsleceller. De är alltså underleverantörer till bränslecellstillverkare. Inte oväntat är han väldigt optimistisk och positiv till vätgasens möjligheter.&nbsp;</p>



<p>Som vi såg i körningen till Frankfurt gick det åt tre gånger så mycket ström att köra vätgasbilen som elbilen. Hur ser Cell Impact på det?</p>



<p>– Det finns mängder av el som går till spillo, i gröna energisystem men även på ställen som kring ekvatorn. Där kan man spjälka vätgas genom solenergi direkt. Där lyser solen hela tiden. Med solceller och vätgas kan du dra en pipeline därifrån. Att det då är energiförluster, det är så mycket sol så det gör ingenting, säger Peter Fagerberg, marknadschef på Cell Impact.&nbsp;</p>



<p>– Eller se på Island, de har ett överdåd av geometrisk energi, som kan användas till vätgasframställning. Men även Sverige och Norge kommer att bli storproducenter av vätgas. Med grön energi blir det möjligt i stor skala. Ta 50 liter havsvatten, spjälka det till 5 kg vätgas, så kan du köra 50 mil, och det enda som kommer ur avgasröret är 50 liter vatten.&nbsp;</p>



<p>– Vätgas gör det även möjligt för alla att bli drivmedelsproducenter. Få kan ju starta ett oljeraffinaderi. Men med en solcellsanläggning och elektrolysörer kan du starta mack och sälja vätgas efter&nbsp;</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p>“För vätgas till fordon är det rimligare med mindre enheter, vilket enklare tillgodoses med elektrolys. ”</p>
</blockquote>



<p>vägarna. Och du slipper investera i oljeplattformar för miljarder.&nbsp;</p>



<p>Peter Fagerberg ser ett stort intresse från bilindustrin för vätgas just nu. Han kan inte avslöja vilka som de har kontakt med för att sälja sina supertunna flödesplattor de har utvecklat, men mycket är på gång.&nbsp;</p>



<p>– Det är ett jättestort intresse från många fordonstillverkare globalt sett.&nbsp; Men det är ingen kamp mellan bränsleceller och batterier. Båda är elbilar och båda är framtiden.&nbsp;&nbsp;</p>



<p>En svensk aktör som jobbar för att sprida kunskap och underlätta för vätgasens etablering är Vätgas Sverige. De fick uppgiften att svara på fler frågor om vätgasens väl och ve.&nbsp;&nbsp;</p>



<p><strong>Effektförlusterna är stora vid vätgasframställning. Cirka 30 procent av elen från exempelvis en vindkraftspark är kvar till bilen när man kör den. Laddar man ett batteri direkt blir siffran över 80 procent. Är inte vätgas därmed ett oerhört slöseri med grön el?</strong></p>



<p>&nbsp;– Vi har en hel del solenergi och vindkraft som vi inte kan ta tillvara på alls idag, så om den sparas genom vätgas så blir det genast en ren vinst. Mellan 42–50 procent av energin är kvar till bilen. Vätgas kommer att få en stark roll just som energilagring och då är inte verkningsgraden det avgörande utan att man har energi när man behöver den.</p>



<p><strong>&nbsp;95 procent av världens vätgastillverkning kommer från fossila bränslen. Utsläppen av CO2 som kommer från tillverkning av vätgas är i dag större än de samlade utsläppen från Storbritannien och Indonesien tillsammans, visar en studie från IEA (830 miljoner ton). Varför skulle det här förändras?</strong></p>



<p>– Dagens produktion av vätgas går mestadels till industrin och man har subventionerat tillverkningen från fossila bränslen. Även Sverige hade subventioner av dessa processer fram till 2018. Nu inser allt fler länder att man vill ha så kallad grön vätgas med ett förnybart ursprung, så vi kommer att se en övergång mot alltmer elektrolysframställd vätgas från förnybara energikällor. Den absoluta merparten av vätgasen som tillverkas idag används på plats vid exempelvis ammoniakframställning eller i raffinaderier i stora anläggningar, för vätgas till fordon är det rimligare med mindre enheter som ligger mer geografiskt utspridda, vilket enklare tillgodoses med elektrolys.</p>



<p><strong>Är inte vätgas greenwashing? Det vill säga, de traditionella bolagen vill sälja olja och gas med grön vätgasstämpel.</strong></p>



<p>– Nej, vätgas med fossilt ursprung kallas aldrig grön vätgas. Det finns klara definitioner för vad som får kallas för grön, blå och grå vätgas. De traditionella bränslebolagen kommer sannolikt över tid att sälja även vätgas eftersom de har affärsmodeller för drivmedel. För samhället och klimatet är det en bra utveckling.&nbsp;</p>



<p><strong>Enligt många är vätgas endast ett asiatisk projekt, eftersom de där kan reformera billig gas från bland annat Ryssland. Hur ser ni på det?</strong></p>



<p>– I Japan gjordes nu dagarna en deklaration som 30 länder ställer sig bakom om att satsa på 10 000 tankstationer. I Europa är det Tyskland som nu går före och ska ha 100 tankstationer på plats innan året är slut. Kalifornien antog 2018 en ambitiös plan om 1000 tankstationer och 1 miljon bilar, så det är inte en enbart asiatisk företeelse. Den största anledningen till att man väljer vätgas är att man vill få bukt med luftkvaliteten i städerna. Naturgasen som importeras till Japan har dessutom bland de högsta priserna i världen, eftersom den importeras i flytande form.&nbsp;</p>



<p><strong>Det kommer alltid att vara billigare att göra vätgas från naturgas än att tillverka den via elektrolys därmed är miljöaspekten borta. Stämmer det? Eller är priserna för elektrolys konkurrenskraftiga i dag?</strong></p>



<p>– Det kommer inte att vara så när subventionerna för att tillverka vätgas från naturgas försvinner, då får de miljömässigt bättre alternativen en riktig chans. Det går redan idag att köpa grön vätgas till samma pris som den grå vätgasen. Elektrolysörerna har varit dyra och anpassade för annan processindustri, men nu sker en kraftig teknikutveckling på dem och konkurrensen ökar så vi kommer att se klara steg med lägre kostnader för tekniken.</p>



<p><strong>Kommer verkligen kostnaderna på bränsleceller och tillhörande teknik som vätgastankar att komma ner så mycket i pris att de blir lämpliga för massproduktion i bilindustrin?</strong></p>



<p>– Så säger flera biltillverkare att det kommer att bli. Toyota menar till exempel att man kommer kunna minska kostnaderna för bränslecellerna betydlig mer än batterierna: Kostnaden för en bränslecell består av ca 20–30 procent material och 70–80 procent arbetskostnad.&nbsp;</p>



<p>För ett batteri gäller det motsatta förhållandet. Arbetskostnaden kan man lättare rationalisera genom automatisering så därför är det rimligt att anta att det går att nå en betydligt lägre kostnad för bränslecellerna.&nbsp;</p>



<p>Allt fler leverantörer av tankar kliver nu fram så konkurrens kommer att öka,&nbsp;vilket i sin tur bidrar till att reducera priserna på tankarna.</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p>&#8221;Från europeisk nivå ser man gärna att vi bygger vätgas, el och biodrivmedel på samma station.”</p>
</blockquote>



<p><strong>Tankstationer för vätgas är oerhört dyra att producera och installera, är det ens rimligt att tänka sig att man kan bygga ut infrastrukturen för detta om inte tillräckligt många vätgasbilar rullar på vägarna? För innan man köper en vätgasbil vill man väl att tankinfrastrukturen är på plats?&nbsp;</strong></p>



<p>– Tesla anger på sin svenska hemsida att man avsätter ca 20 000 kr av bilens inköpspris till laddinfrastruktur. Om man jämför det med hur många bränslecellsbilar som kan tanka på en vätgastankstation så blir den siffran ca 10 000 kr/bil. Man behöver bygga ut infrastrukturen på ett smart sätt så att den matchar de fordon som efterfrågas och det krävs samarbete mellan de som erbjuder fordon och de som ska bygga tankstationerna. Det är inte heller bara personbilar som man är beroende av, då det nu kommer både bussar och lastbilar som kan dela på tankstationerna.</p>



<p><strong>Är det inte bättre att satsa på elvägar och snabbladdarstationer än vätgasmackar?</strong></p>



<p>– För att klara klimatutmaningen kommer vi behöva all miljövänlig teknik som står att finna, vi kommer behöva både elektrifiering med både batterier och med bränsleceller. EU har redan skapat ett stödprogram där man uppmanar medlemsstaterna att bygga multi-fuel-stationer. Från europeisk nivå ser man gärna att vi bygger vätgas, el och biodrivmedel på samma station och det finns investeringsstöd till denna lösning.</p>



<p><strong>Hur ser ni på ointresset från svenska politiker när det kommer till vätas? Vad är deras felresonemang enligt er?</strong></p>



<p>– Under valet 2018 var det sex av åtta partier som talade om satsningar på vätgas. Hybrit-projektet inom stålindustrin lyfter vätgas på den svenska agendan och när man väl förstått att vätgas har en roll i energisystem, industri, byggnader och transportsektor så kommer fler politiker att driva området.</p>



<p><strong>Många menar att vätgas är så komplicerat och en omväg mot en omställning och ett sätt för bilföretag och andra att skjuta på omställningen. Vätgas kommer alltid att vara framtidens teknologi.&nbsp;</strong></p>



<p>– Det är faktiskt inte så komplicerat. Omställningen håller redan på att ske och vi ser många pågående projekt och lösningar. Globalt sker stora satsningar på vätgas och bränsleceller. Ser man i KPMGs undersökning från 2018 med frågor till världens största bilföretag så är budskapet klart: Bränslecellstekniken är den viktigast för en klimatomställning.</p>



<p><strong>Vi upplevde flera problem med tankningen i Sverige och Danmark, hur är det med mognadsgraden egentligen?&nbsp;</strong></p>



<p>– Det är något som branschen får jobba på. Det finns pågående globala samarbeten då det redan är globala standards för tankstationerna och man driver flera tekniska frågor gemensamt för att säkra standards, kvalitet och tillförlitlighet. Sedan behövs det snabbt redundans av stationer på orterna, så att man har alternativ om det görs service eller blir en störning på en station.&nbsp;</p>



<p><strong>Kan man tänka sig att priserna på elektrolys, lagring och bränsleceller blir så låga att det blir lönsamt för villaägare att bygga ett självförsörjande hus som så att husägaren säga kan ”klippa kabeln”. I så fall när tror ni?&nbsp;&nbsp;</strong></p>



<p>– Det kommer vi absolut att se, men det är svårt att säga exakt när på grund av olika styrmedel och vad man ger sig själv för rimlig tid för att få igen investeringen. Sedan är frågan om vi ska klippa kabeln eller om det kan vara smart att få sälja sitt eventuella överskott av egentillverkade energi. Detta är i mångt och mycket en kalkyl som styrs av politiska incitament såsom energiskatt. Om det finns en politisk vilja att det ska genomföras så kommer det att gå och om den viljan inte finns kommer det gå att göra det olönsamt.&nbsp;</p>



<p><strong>I NÄSTA NUMMER</strong></p>



<p>tar vi en titt på det där med vätgasens möjligheter som energilager till små som stora anläggningar.</p>



<div class="wp-block-cover is-light"><span aria-hidden="true" class="wp-block-cover__background has-very-dark-gray-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">
<h2 class="wp-block-heading">Faktaruta</h2>



<p><strong>Så funkar vätgastekniken</strong></p>



<p>Genom att med el dela vatten kan man få ut väte och syre.&nbsp;</p>



<p>Vätet kan sedan lagras och användas som bränsle i bilar och i andra applikationer.&nbsp;</p>



<p>Vätgasen komprimeras då till 700 bar i bilens tank. Därefter transporteras den till en bränslecell där den reagerar med syre. I och med det alstras elektricitet som sedan kan driva bilen framåt. Det som kommer ur avgasröret är vatten.&nbsp;</p>



<p>Vätgas kan dock tillverkas ur naturgas, och då får man utsläpp av koldioxid. 95 procent av all vätgastillverkning sker i dag i den processen.</p>



<p></p>



<figure class="wp-block-image size-large"><img decoding="async" width="650" height="886" src="https://elbilen.se/wp-content/uploads/2020/07/1-55.jpg" alt="" class="wp-image-16124" srcset="https://elbilen.se/wp-content/uploads/2020/07/1-55.jpg 650w, https://elbilen.se/wp-content/uploads/2020/07/1-55-220x300.jpg 220w" sizes="(max-width: 650px) 100vw, 650px" /></figure>



<p>En tankstation i Tyskland som fungerade prickfritt. Alla de fem stationerna vi testade i Tyskland fungerade precis som tänkt. Danska stationerna fungerade dock sämre. Än återstår mycket för att tekniken ska fungera och tankstationera blir tillräckligt många för att vätgasbilen ska bli ett alternativ för många.</p>
</div></div>



<p></p>
