Test – Mazda MX30


<p class="wp-block-paragraph">Prisvärd – för kortare resor<div id="elbilen_panorama-1"></div><script>lwhb.cmd.push(function() {lwhb.loadAd({tagId: "elbilen_panorama-1"});});</script><div id="elbilen_mobil-1"></div><script>lwhb.cmd.push(function() {lwhb.loadAd({tagId: "elbilen_mobil-1"});});</script></p>



<p class="wp-block-paragraph">Rätt person – med rätt behovsprofil – kan få mycket elbil för pengarna i Mazda MX-30. Men räkna inte med några längre turer, särskilt inte när det är kallt ute. Vi har testat Mazdas el-crossover som vardagsbil på vintern.</p>



<p class="wp-block-paragraph"><em>Text: Lotta Hedin | Foto: Peter Gunnars.</em></p>



<p class="has-drop-cap wp-block-paragraph">Låt oss gå rakt på sak: om du inte kör längre sträckor än cirka tio mil på vintern, om du framför allt planerar att långsamladda hemma, och om du inte heller behöver skjutsa personer i baksätet särskilt ofta som snabbt ska kunna släppas av och plockas upp här och var – då kan Mazdas el-crossover MX-30 vara ett riktigt bra och prisvärt alternativ. </p>



<p class="wp-block-paragraph">Beskrivningen ovan kan låta snäv men stämmer troligen in på många: de flesta kör inte så långa sträckor i vardagen, de flesta åker oftast själva och laddar mest hemma. Däremot vill många ändå ha alla möjligheter, och kunna åka långt även på vintern, och få plats med hela familjen och halva bohaget. Många vill helt enkelt ha en bil som funkar för allt, även om de oftast inte behöver det. Men någon sådan bil är inte Mazda MX-30.&nbsp;</p>



<p class="wp-block-paragraph">Första gången Elbilen körde den var i somras, en av sommarens varmaste dagar, då vi tog en kortare provtur i ett visningsexemplar. När vi nu ska testa den lite grundligare är förhållandena betydligt kärvare: temperaturen rör sig mellan fem och tio minus och det är snöigt med ömsom moddiga, ömsom hala väglag.&nbsp;</p>



<p class="wp-block-paragraph">Körmässigt klarar sig MX-30 riktigt bra: den håller stadig kurs genom moddsträngarna, den känns distinkt och ger bra gensvar. Framsätet är rymligt, stolarna och fjädringen bekväm och jag gillar inredningen. Korkdetaljerna som Mazda gjort ett stort nummer av (Mazda började som korkfabrik) är riktigt trevliga. Jag känner mig också snabbt hemma i infotainmentsystemet och det är lätt att hitta det man letar efter. Bilen är också välutrustad från början, med funktioner som adaptiv farthållare, helljus med automatisk avbländning och head-up-display.</p>



<p class="wp-block-paragraph">Det finns bara ett körläge att välja på. Med rattpaddlar kan man dock anpassa hur kraftfull regenerering man vill ha, något som enligt instruktionsboken också ska påverka accelerationen: hög grad av regenerering (kraftig motorbroms) ska ge svagare acceleration, och låg grad snabbare. Det är lite underligt att koppla ihop det så, kan jag tycka, och i ärlighetens namn känner jag ingen större skillnad på accelerationsbiten. Graden av regenerering blir det dock stora skillnader på, vilket är bra. Med en prislapp som startar på 349 000 kronor (bonus ej inräknad) känns det såhär långt som att man får mycket för pengarna.&nbsp;</p>



<p class="wp-block-paragraph">Men kylan och vinterväglaget tar hårt på räckvidden. Batteripacket rymmer bara 36 kWh till att börja med, något som ska ge 20 mils räckvidd enligt WLTP. Men minusgraderna höjer snittförbrukningen till runt 22 kWh/100 km, och räckvidden hamnar på cirka tolv mil.&nbsp;</p>



<p class="wp-block-paragraph">Mycket tyder på att Mazda har en hel del att jobba på när det gäller värmningen av batteriet. Enligt uppgift från Mazda sköts den genom en elektrisk värmeslinga i en matta i anslutning till batteriet. Vid kalla starter varnar bilen för att temperaturen i högspänningsbatteriet är låg, och att accelerationen därför är begränsad. Efter en hel timmas körning tvärs igenom Stockholm i rusningstrafik fortsätter varningsmeddelandet att komma, och enligt mätaren är temperaturen fortfarande nere på blått.</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow"><p>”Körmässigt klarar sig MX-30 riktigt bra. den håller stadig kurs genom moddsträngarna, den känns distinkt och ger bra gensvar.”</p></blockquote>



<p class="wp-block-paragraph">– Gränsen för låg temperatur-varningen är tyvärr satt lite väl lågt. I realiteten så reduceras motoreffekten och accelerationen ytterst marginellt när temperaturen är strax under noll grader, men trots det är bilen inställd på att informera föraren om att så är fallet, svarar Mazdas pr- och prukduktansvarige Johan Lagerström.</p>



<p class="wp-block-paragraph">Problem med batterivärmningen kan också förklara den häpnadsväckande dåliga effekt vi får när vi försöker snabbladda. Efter elva mils blandad körning rullar jag in till Ionitys laddstation med fem procent kvar i batteriet och åtta kilometers återstående räckvidd. Det är minus sju grader ute. Laddeffekten börjar okej på 34 kW, men när batteriet börjar fyllas på och effekten borde börja stiga, så dalar den istället. När vi når 40 procent får vi 19 kW. När batteriet efter 50 minuter krupit upp till 60 procents laddning är effekten nere på 14 kW och det står två bilar och köar. Då ger jag upp.&nbsp;</p>



<p class="wp-block-paragraph">Jag gör ett nytt försök några dagar senare. Det börjar återigen ganska bra med 36 kW laddeffekt, men dalar sedan direkt till 6 kW, där det ligger kvar tills jag ger upp 40 minuter senare.</p>



<p class="wp-block-paragraph">– Max snabbladdning är inställd för att skydda batteriet när temperaturen är låg. Vi har uppmärksammat problemet och jobbar på att försöka få till en bättre styrning av batterivärmaren, för att passa vårt kalla vinterklimat på ett bättre sätt, säger Johan Lagerström.</p>



<p class="wp-block-paragraph">Mazda MX-30 har plats för fem, men baksätet bjuder inte på särskilt mycket benutrymme. Även tioåriga dottern med kompis tycker att det är lite trångt, men mysigt – tillägger de. Precis som hos BMW:s elbilsklassiker i3 har MX-30 skippat b-stolparna, och valt bakhängda så kallade självmordsdörrar som öppnas åt ”fel” håll bak. Jag skulle gärna vilja säga något positivt om dem, för jag gillar dem i teorin. Men i praktiken… Nej. Problemen börjar när jag ska hämta upp barnen på skolans parkering. Det står bilar bredvid mig i angränsande rutor och det finns inte tillräckligt mycket utrymme för att mina passagerare ska komma in – man måste ju öppna både fram- och bakdörren samtidigt för att komma in i baksätet. Jag får backa ut ur fickan, stanna bilen, och själv gå ut för att de ska komma in. Sedan blir det samma procedur när jag ska släppa av dem vid deras eftermiddagsaktivitet. Inte smidigt.</p>



<p class="wp-block-paragraph">Men som sagt, det behöver ju inte vara ett problem för alla, beroende på hur man använder bilen. Visst har Mazda MX-30 har en hel del att erbjuda för pengarna, men den har inte allt.</p>



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



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



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



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-24.jpg" alt="" class="wp-image-18740"/><figcaption>Baklyktorna flirtar med 50-talets raggarestitik.<br></figcaption></figure>



<h2 class="wp-block-heading">Testfakta &#8211; MAZDA MX30 </h2>



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



<p class="wp-block-paragraph">Köregenskaper: MX-30 är riktigt trevlig att köra och känns distinkt och responsiv. Den spelar inte i högsta ligan accelerationsmässigt, men är helt okej. </p>



<p class="wp-block-paragraph">Bara ett körläge men möjlighet att anpassa regenerering med rattpaddlar. Föraren sitter högt och har god sikt, förutom i döda vinkeln – där man är glad att varningssystemet är med och håller uppsikt.&nbsp;</p>



<p class="wp-block-paragraph">Betyg: 4</p>



<p class="wp-block-paragraph">Komfort: Bekväma stolar och fjädring gör färden komfortabel, i alla fall i framsätet. I baksätet är det trångt om benutrymme och det känns lite instängt med de pyttesmå fönstren. </p>



<p class="wp-block-paragraph">I infotainmentsystemet med sina olika skärmar är det lätt att hitta och få överblick – plus i kanten för det.&nbsp;&nbsp;&nbsp;&nbsp;</p>



<p class="wp-block-paragraph">Betyg: 4</p>



<p class="wp-block-paragraph">Säkerhet: Mazdas MX-30 har fått fem stjärnor av Euro-Ncap.    </p>



<p class="wp-block-paragraph">Betyg: 5</p>



<p class="wp-block-paragraph">Miljö: Ett mindre batteripack som hos MX-30 ger mindre miljöpåverkan än ett stort. MX-30 är dock inte så energieffektiv när det är kallt och det går åt en del ström.   </p>



<p class="wp-block-paragraph">Betyg: 5</p>



<p class="wp-block-paragraph">Autonomi: Systemet för filhållning fungerar bra, liksom adaptiv farthållare, autobroms och backkamera.  </p>



<p class="wp-block-paragraph">Betyg: 3</p>



<p class="wp-block-paragraph">Utrustning: Mycket kommer med från början, även i de First Edition-bilar som ännu finns att beställa. I ordinarie modellversioner finns även 220-voltsuttag och rattvärme. </p>



<p class="wp-block-paragraph">Mazda MX-30 kommer också med app, där du kan styra laddning och föruppvärma bilen. Utöver detta hade vi gärna sett att mer krut lagts på batterivärmning.&nbsp;&nbsp;&nbsp;&nbsp;</p>



<p class="wp-block-paragraph">Betyg: 4</p>



<p class="wp-block-paragraph">Utrymmen: XC-30 har plats för fem, men baksätet är trångt och bjussar inte på mycket benutrymme. Fram finns det dock gott om plats. I bagageutrymmet ryms 366 liter – inga jättevolymer alltså. Inget lastutrymme under motorhuven, trots att där är luftigt värre och det borde finnas plats för en frunk.  </p>



<p class="wp-block-paragraph">Betyg: 3</p>



<p class="wp-block-paragraph">Ekonomi:&nbsp;</p>



<p class="wp-block-paragraph">Mx-30 startar på 349 000 kronor för introduktionsmodellen First Edition, vilket är ett bra pris (för en köpare med matchande behov). Enligt Mazda finns det när denna artikel skrivs 180 bilar kvar av introduktionsmodellen. Ordinarie versioner startar på 369 000 kronor.  </p>



<p class="wp-block-paragraph">Betyg: 4</p>



<p class="wp-block-paragraph">Räckvidd:&nbsp;</p>



<p class="wp-block-paragraph">Under vårt test, då utomhustemperaturen låg mellan -5 och -10 grader, kom vi cirka 12 mil. Den deklarerade räckvidden enligt WLTP är 200 km vid blandad körning.&nbsp;&nbsp;&nbsp;&nbsp;</p>



<p class="wp-block-paragraph">Betyg: 2</p>



<p class="wp-block-paragraph">Laddning: Under vår kalla testvecka funkade snabbladdningen rent utsagt uselt (se laddkurva).  MX-30 är ganska blygsamt utrustad från början när det gäller laddning, med 6,6 kW ombordladdare och en snabbladdningskapacitet på max 50 kWh – på papperet. Men vi kom inte upp i den snabbladdningseffekten på långa vägar. Några minusgrader räcker inte som ursäkt.  </p>



<p class="wp-block-paragraph">Betyg: 2</p>



<p class="wp-block-paragraph">Utseende: Fina former och en trevlig interiör.  Korkdetaljerna gör mycket till och gör insidan både fräsch och ombonad på samma gång.</p>



<p class="wp-block-paragraph">SUMMA SUMMARUM</p>



<p class="wp-block-paragraph">En bil med trevliga köregenskaper och bra system för förarstöd.  Lämpar sig för den som inte har behov av att köra långt, men ändå prioriterar komfort och körglädje. Problem med batterivärmning ger  extremt långa laddtider i kyla. Hemmaladdning rekommenderas. Har du familj? Testa i- och utstigning i baksätet innan köp. </p>



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



<figure class="wp-block-table is-style-stripes"><table><tbody><tr><td>Pris:</td><td>349 000 kr.</td></tr><tr><td>Batterikap:</td><td>35,5 kWh.</td></tr><tr><td>Deklarerad räckvidd:</td><td>200 km.</td></tr><tr><td>Snabbladdn.:</td><td>CCS 50 kW.</td></tr><tr><td>Ombordl.:</td><td>Enfas 6,6.</td></tr><tr><td>Drivning:</td><td>Framhjulsdrift.</td></tr><tr><td>Max motoreffekt, <br>Vridmoment:</td><td>105 kW, 265 Nm.</td></tr><tr><td>Acceleration 0–100 km/h:</td><td>9,7 sek.</td></tr><tr><td>Topphastigh:</td><td>140 km/h.</td></tr><tr><td>Antal platser:</td><td>5.</td></tr><tr><td>Yttermått, LxBxH:</td><td>440x204x157 cm.</td></tr><tr><td>Bagagevolym:</td><td>366/ 802 liter.</td></tr><tr><td>Nybilsgaranti:</td><td>3 år.</td></tr><tr><td>Batterigaranti:</td><td>8 år/16 000 mil.</td></tr></tbody></table></figure>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-25-1030x732.jpg" alt="" class="wp-image-18741"/><figcaption>MX-30 klarar inte att snabbladda i kyla. Vid 60 % avbröt vi, för att fortsätta fortsätta en annan dag – med samma dalande resultat.</figcaption></figure>



<p class="wp-block-paragraph">Förbrukning och räckvidd: -5 till -10 grader grader under testet.&nbsp;</p>



<p class="wp-block-paragraph">WLTP-räckvidd: 200–265 km. Räckvidd på provkörningen: Cirka 120 km. Snittförbrukning: 2,2 kW/mil. </p>



<div class="wp-block-media-text alignwide is-stacked-on-mobile"><figure class="wp-block-media-text__media"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-26-1030x579.jpg" alt="" class="wp-image-18742"/></figure><div class="wp-block-media-text__content">
<p class="has-large-font-size wp-block-paragraph">BATTERIER. MX-30 är utrustad med ett batteripack på 35,5 kWh &#8211; jämförelsevis litet med dagens mått mätt. Under motorhuven finns plats för en räckviddsförlängande bensindriven Wankelmotor Modeller med en sådan (den går inte att eftermontera) ska komma i sutet av året enligt Mazda.</p>
</div></div>



<div class="wp-block-media-text alignwide has-media-on-the-right is-stacked-on-mobile"><figure class="wp-block-media-text__media"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-27.jpg" alt="" class="wp-image-18743"/></figure><div class="wp-block-media-text__content">
<p class="has-large-font-size wp-block-paragraph">baksäte. Det är ganska trångt i baksätet. Både framdörr och bakdörr måste öppnas för att passagerare ska ta sig in och ut. Inte så smidigt på trånga parkeringsplatser. </p>
</div></div>



<div class="wp-block-media-text alignwide is-stacked-on-mobile"><figure class="wp-block-media-text__media"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-28.jpg" alt="" class="wp-image-18744"/></figure><div class="wp-block-media-text__content">
<p class="wp-block-paragraph">Korkdetaljer. Mazda har ett förflutet som korktillverkare. Detaljerna i kupén höjer känslan.</p>
</div></div>



<div class="wp-block-media-text alignwide has-media-on-the-right is-stacked-on-mobile"><figure class="wp-block-media-text__media"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-29.jpg" alt="" class="wp-image-18745"/></figure><div class="wp-block-media-text__content">
<p class="wp-block-paragraph">Rattmanövrerat. Det är lätt att hitta i infotainmentsystemet, som manövreras med en ratt.</p>
</div></div>



<div class="wp-block-media-text alignwide is-stacked-on-mobile"><figure class="wp-block-media-text__media"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-30.jpg" alt="" class="wp-image-18746"/></figure><div class="wp-block-media-text__content">
<p class="wp-block-paragraph">Förbrukning. Kyla och vinterväglag sätter spår i energiförbrukningen. Skärmen visar historiken.</p>
</div></div>



<div class="wp-block-media-text alignwide has-media-on-the-right is-stacked-on-mobile"><figure class="wp-block-media-text__media"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-31.jpg" alt="" class="wp-image-18747"/></figure><div class="wp-block-media-text__content">
<p class="wp-block-paragraph">Bagageutrymme. Skuffen rymmer 366 liter. Lucka i golvet med fack. Väska för laddsladden medföljer, kan hängas på väggen</p>
</div></div>



<div class="wp-block-media-text alignwide is-stacked-on-mobile"><figure class="wp-block-media-text__media"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-32.jpg" alt="" class="wp-image-18748"/></figure><div class="wp-block-media-text__content">
<p class="wp-block-paragraph">Laddlucka BAK. Bilen kan ta AC laddning upp till 6,6 kW. Snabbladdning upp till 50 kW – på pappret.</p>
</div></div>



<div class="wp-block-media-text alignwide has-media-on-the-right is-stacked-on-mobile"><figure class="wp-block-media-text__media"><img src="https://elbilen.se/wp-content/uploads/2021/04/Elbilen_2_2021-33.jpg" alt="" class="wp-image-18749"/></figure><div class="wp-block-media-text__content">
<p class="wp-block-paragraph">Elmotor. E-skyactive är Mazdas namna på motorn i den helelektriska MX-30.</p>
</div></div>



<p class="wp-block-paragraph"></p>
