Bygga egen styrning (ECU) till en pumpdyse-dieselmotor

[konso1985]

På volvo trucks så har pumpedyseinjektoren brukt å ha 80-90V spenning til styring av dem.

Sent fra min SM-G950F via Tapatalk

[Janson1]

Det är kanske dags att presentera den senaste skapelsen(ja, den är i ständig förändring). En tilltänkt funktionsbeskrivning behövs väl också? Men först sketchen:

Kod: Markera allt

    #include <PureAtmega328.h>
   
            // här är 13 olika justerbara parametrar som påverkar enligt följande:
    const int tryckminskn = 60;       // turbotrycket ställs in här, högre tal = mindre tryck (60)
    const int lagstavarv = 580;       // tomgångsvarvet 580 uS motsvarar ca 800 Rpm (580)
    const byte hogstavarv = 90;       // fullgasvarvet 100 uS motsvarar ca 4200 RPM  (100)
    const byte aggrfaktorlag = 8;     // hur mycket spridar PWM skall öka vid belastning mellanvarv (8)
    const byte aggrfaktorhog = 12;    // hur mycket spridar PWM skall öka vid belastning högvarv (12)
    const int minfart = 3300;         // lägsta startvarv för spridarfunktion (3300 uS = 152 RPM)(3300)
    const byte startmangd = 5;        // avgör max startmängd 5 = 0,75 vevaxelpulser = 4,5 grader ontid (5)
    const float maxdeltalag = 6.0;    // max insprutningstid mellanvarv mdutation * 6.0 ger 3 vevaxelpulser = 18 gr ontid (6.0)
    const float maxdeltahog = 8.0;    // max insprutningstid högvarv mdutation * 8.0 ger 4 vevaxelpulser = 24 gr ontid (8.0)
    const byte lagmangd = 2;          // max lågvarvsmängd 2 =  1 vevaxelpuls = 6 grader ontid (under tomgångsvarv)(2)
    const byte turbostartregl = 150;  // när tubotrycket börjar avläsas och bli aktivt (150 = uS mduration ca 3200RPM)(150)
    const float senasteinspr = 8.0;   // senaste insprutningstid (8.0 = 4 vevaxelpulser = 24 grader delaytid =6 grader FÖDP) (8.0)
    const float tidigasteinspr = 60;  // kortaste insprutningsfördröjning (60)
                                      // 60 motsvarar tand 19 = 24 grader FÖDP
                                      // 30 motsvarar tand 20 = 18 grader FÖDP
                                     
    int debuggpin = 4;                // debuggpin startar Serial.printfunktionen vid behov
    int kampin = 3;                   // kamaxelgivarens ingång, (aktivt låg).
    int vevpin = 2;                   // pulsingång vevaxelgivare, (aktivt låg).
    int pulsutpin = 7;                // pulsutgång 2 pulser per varv (kontrollutgång för övervakningen).
    int sprpins [] ={8,9,10,11};      // till spridarna (blir aktivt höga)
    int disable = 12;                 // aktivt hög stoppar utsignalerna till spridarna
    int sprControl = 13;              // (kontrollutgång för spridare till övervakningen).
    int turbokorr, turbovalue;        // felkorrigeringsvärde turbo och turbovärde
    int turboAirTemp, engineTemp;     // turbo in temp och motortemp.
    unsigned int delvalue;            // delvärde av pulstid i uS.
    unsigned int ondelay;             // tillslagsfördröjning spridare i uS.
    long puls, priv, delta;           // senaste, föregående,total och finkorrigeringstid i uS,
    float error;                      // error = varvfelet i decimalform
    float starttandf, finKorr;        // starttand i decimalform för att få startfördröjningstid.
    float  mduration, bduration;      // varvfelet = motorduration/börduration i decimalform
    byte x = 0;                       // vevpin2 räknare 0 till 28, i alla fall till 26
    byte  gas, turbo, pekare;         // gas 0-255, turbo 0-127, pekare för att välja rätt spridarutgång
    byte kamtand = 0;                 // Kamtand för att sluta detektera kamaxelgivaren efter några tänder
    int atmpress;                     // atmosfärstrycket i mBar
   
    void setup()                     
  {
 
   pinAsInput(vevpin);               // satt vevpin som ingång                           
   pinAsInputPullUp(kampin);         // satt kampin som ingång
   pinAsOutput(sprpins[pekare]);     // 8,9,10,11 satta som utgångsarrey
   pinAsOutput(sprControl);          // en spridarutgång som blir hög varje gång en spridare öppnas.
   pinAsInputPullUp (disable);       // ECU väljare Hög = on, Låg = off.
   pinAsOutput(pulsutpin);           // satt pulsutpin som utgång (2 pulser per varv).
   pinAsInputPullUp (debuggpin);     // debuggpin väljer serial.printfunktionen Låg = on.
   Serial.begin(250000);             // bra att ha.
  }
    //______________________________________________________________________
    void loop()
 {
       
                                    //Det får plats ca 1700 klockcykler mellan varje x tal(case) (1 till 17)
                                    //Det tar lite mer än 100 mikrosek att läsa av en analogingång,
                                    //så ingen analogRead här, skall vara i case 19!
                                   
                                 
     if (digitalRead(disable)==LOW) //Disable låg stänger av ECU:n och gör den passiv
      { 
      puls = 0;                     //Genom att pulstiderna förblir 0.
      pinAsInput(sprpins[pekare]);  //Gör om spridarutgångarna till ingångar för att ej belasta
      pinAsInput(sprControl);       //Gör om spridarcontrollen till ingång för att ej belasta
      }
     
     else
      {
      pinAsOutput(sprpins[pekare]); //Vid aktiv igen så gäller spridarutgångarna som utgångar igen.
      pinAsOutput(sprControl);      //Vid aktiv så gäller spridarcontrollen som utgång igen
      }                             //*Detta är normalläget, samma som i setup*
       
        x  ++ ;                     //räkna upp ett steg för varje ny puls, kommer via pulseIn()funkt.
       
      if (kamtand <= 50)            // när tand 51 är räknad slutar den detektera kampin.
       {
        if (digitalRead(kampin)== LOW)//varje gång kamaxelns hempuls detekteras så resetas 4 räknaren
         {
          pekare = 0;                 //resetas till 0. Denna funktion läses utanför switch.
          kamtand ++;                 // räknar upp kamtandräknaren vid varje kampin låg.
         }
       }
       
     switch (x)                     // här startar switch och case, x räknaren stegar fram per tand
  {
     case 1:                        // Vid första vevpinpuls Gör:
        delvalue = priv;            // Första pulstid läggs in som deltid 1
     break;
     
     case 2:                        // Vid andra vevpinpuls Gör:
        delvalue = priv + delvalue; // föregående pulstid + föregående deltid läggs ihop
     break;
       
     case 3:                        // Vid tredje vevinpuls Gör: osv
                 // turbotrycket ställer ner motorns PWM signal til spridarna vid måltrycket
        turbokorr = map(turbo, 0, 127, 0, tryckminskn); // tryckminskningen ställs högst upp
        delvalue = priv + delvalue; // föregående pulstid + föregående deltid läggs ihop
     break;
       
     
     case 4:     // motorns börvärde från gaspoten blir lägsta varvtal och högsta varvtal         
        bduration =map(gas,0, 255, lagstavarv, hogstavarv); // ställs in högst upp
        delvalue = priv + delvalue; // föregående pulstid + föregående deltid läggs ihop
     break;                         // (660 - 115 uS = ca 800 till 4200 rpm)
       
     case 5:
           delvalue = priv + delvalue; // föregående pulstid + föregående deltid läggs ihop
     break;
     
     
     case 6:
           delvalue = priv + delvalue; //föregående pulstid + föregående deltid läggs ihop
     break;         
       
     case 7:
           delvalue = priv + delvalue; // föregående pulstid + föregående deltid läggs ihop
     break;
       
     case 8:
           delvalue = priv + delvalue; // föregående pulstid + föregående deltid läggs ihop
     break;
       
     case 9:
           mduration = delvalue/12;   //motorns totala pulstid i mikrosek dividerat med 12 (6x2).
           if(mduration >= minfart)   // motorn måste upp i x varv för att få bränsle, ställs högst upp
           {
            mduration = 0;
           }
     break;  //ger motorns verkliga fart baserat på dom 8 första tänderna. 660 - 115 uS vid normalvarv ca 800 till 4200 rpm.
     
     case 10:
          error = (mduration / bduration)-1; // räknar ut skillnaden mellan är och börvärde - 1 = error
       if (error <=0.)                 // om error under noll
        {
         error = 0.;                  // för att ej få minusvärden
        }
     break; // felet i uS mellan är och börvärde för motorns fart baserat på pulslängderna över 9 tänder
     
     
     case 11:
          // finKorr = finKorr - ;                // som exempel men nu ledigt
     break;
     
     case 12:
          // ledigt
     break;                         
   
     case 13:
       starttandf = mduration /tidigasteinspr;// insprutningsfördröjning i gånger, ställs högst upp
       // starttandf, ett flyttal = motorns duration/ x som är minsta duration/max RPM. ställs högst upp
       if (starttandf >= senasteinspr)         // om över målvärdet (som ställs in högst upp)
        {
         starttandf = senasteinspr;            // blir det målvärdet ändå
        }
     
     break;
 
     case 14:
        ondelay = mduration * starttandf;// tillslagsfördröjning = motorns duration * starttandsfördröjning (decimaltal)       
     break;                              //       Ondelay     uS = mduration uS     * starttandf i decimalform (från case 13)
                                                               
                                                               
     case 15:                            //en ev. finjustering av spridarnas tillslagstid med hänsyn till
     // ondelay = ondelay +-*/ engineTemp +-*/ turboTemp +-/* turboKorr;//ledig. än så länge...
     break;                              //motorn temp, turboluftens temp och turbotrycket, ev atm trycket.
     
     case 16:
     if (mduration >=151)
      {
       delta = mduration * error * aggrfaktorlag; // Felkorrigeringsvärde som ger spridaröppningstid i uS (mS)
        if (delta >= maxdeltalag * mduration)      // om delta är mer än max tillåten delta x mduration
         {
          delta = maxdeltalag * mduration;         // förblir delta max tillåten
         }                     // detta är inställningen för absolut senaste avstängningstid
      }
     if (mduration <= 150)
      {
       delta = mduration * error * aggrfaktorhog;
        if (delta >= maxdeltahog * mduration)
         {
          delta = maxdeltahog * mduration; 
         }
      }
     break;

     case 17:
     if (mduration <= turbostartregl)        // här bestämms varvtalet när turbon skall börja regleras ner
   
      {                                      // ställs högst upp
       delta = delta - turbokorr;            //korrigering för måltryck genom att minska öppningstiden i uS
       if (delta <=0)
        {
         delta = 0;
        }
      }
     if (mduration >= 700)                   // för att få mjukstart vid motorstart.
      {
       delta = lagmangd * mduration;          // mjukstarten justeras via lågmängd högst upp             
      }
     break;
     
     case 18:                                 // När puls 18 är räknad, gå in i "spridar-on-off-mode"
     if (ondelay >=14000)                     // Om ondelay är mer än 14000 uS. ( < 250RPM )
       {                                      // går tiden över från uS till mS.
        ondelay = ondelay/1000;               // Ondelay uS blir mS.
        delta = delta/1000;                   // Delta uS blir mS.
       if (delta >= startmangd)               // här ställs startmängden in (högst upp)
        {
         delta = startmangd;                  // så det blir rätt startmängd/slag
        }
        delay(ondelay);                       //Fördröjer starttiden x antal mS beroende på varvtalet (mdurationen)
        digitalWrite (sprpins[pekare],HIGH);  //Spridarpinne hög,insprutning börjar. sprpins [pekare 8,9,10 eller 11].
        digitalWrite(sprControl, HIGH);       //Kontrollpinne som går hög vid varje insprutningstillfälle.
        delay(delta);                         //Här läggs insprutningstiden in som sen fördröjer processorn i delta mS
        digitalWrite (sprpins[pekare],LOW);   //Spridarpinne låg,insprutning avslutad sprpins [pekare 8,9,10 eller 11].
        digitalWrite (sprControl, LOW);       //Kontrollpinne som går låg efter varje insprutningstillfälle.
       }                                      //Detta paket används vid låga farter såsom start/lågvarv
     
     else                                     //Eller om delay är mindre än 14000 uS. (> 250 RPM)
       {
        delayMicroseconds(ondelay);           //Fördröjer starttiden i ondelay uS beroende på varvtalet (mdurationen)
        digitalWrite (sprpins[pekare],HIGH);  //Spridarpinne hög,insprutning börjar. sprpins [pekare 8,9,10 eller 11].
        digitalWrite(sprControl, HIGH);       //Kontrollpinne som går hög vid varje insprutningstillfälle.
        delayMicroseconds(delta);             //Här läggs insprutningstiden in som sen fördröjer processorn i delta uS
        digitalWrite (sprpins[pekare],LOW);   //Spridarpinne låg,insprutning avslutad sprpins [pekare 8,9,10 eller 11].
        digitalWrite (sprControl, LOW);       //Kontrollpinne som går låg efter varje insprutningstillfälle.
       }                                      //Detta paket används vid varv (250 -> RPM)
     break;                         //Dessa paket tar 1 till 6 pulser att genomföra beroende på varvtal och belastning
       
       
     case 19:                                 // x är mellan 19 och 24
        gas = analogRead(A1)>>2;              // analogingång för gasreglage 0 till 255( skiftad 2 gånger)
        turbo = analogRead(A0)>>3;            // analogingång för turbotryck 0 till 127 (skiftad 3 gånger)
        engineTemp = 10 * analogRead(A2)>>1;  // 0 till 512 0,1 Volt/10 grad använder LM-35 tempgivare
        turboAirTemp = 10 * analogRead(A3)>>1;// 0 till 512 0,1 Volt/10 grad använder LM-35 tempgivare
        atmpress = analogRead(A4)>>3;         // analogingång för lufttrycket
     break;   // dessa fem analalogRead tar ca 600 uS att läsa = 3-4 tänder vid fullvarv
                           
                                     
 
     case 20:                                 // x är mellan 20 och 28
    if (digitalRead(debuggpin) == LOW)        // detta case 20 fungerar bara på låga varvtal!!
     {                                        // aktiveras via debuggpin (aktivt låg)
      Serial.print("ondelay ");               // Isprutningsfördröjning i uS
      Serial.print(ondelay);                  // hämtar ondelay-värdet och skriver ut
      Serial.print(" = ");                    // =
      Serial.print(mduration);                //  hämtar Motorns duration per tand i us och skriver ut
      Serial.print(" * ");                    // *
      Serial.println(starttandf);             // hämtar aktuell Multiplikationsfaktor för insprutningsfördröjning
      Serial.print(" starttandfin ");         // skriver ut "starttand fin"
      Serial.print(delta);                    // hämtar Insprutningslängd i uS eller mS
      Serial.println(" uS/mS");               // skriver ut " milli eller mikrosekunder"
     }
     else                                     // om debuggerpin hög så skrivs inget ut
     {           // detta är normalläget då hela serieprintfunktionen tar kapacitet från resten
     }
     break;                                 
  }
     //______________________________________________________________________________________________________   
        priv = puls;                          // lägger in den förra pulstiden i värdet "priv" (uS)
       
        puls = pulseIn(vevpin, HIGH, 30000);  // Ett färdigt kommando som väntar in nästa puls.
                                              // vid stillastående motor blir det en timeout
                                              // efter 30000 uS vilket motsvarar < 30 RPM.
                       
      if  (puls > priv + 300 )                // jämför om ny pulstid i uS är större än föregående + 300 uS.
       {
        digitalWrite (pulsutpin, HIGH);       // utpin blir hög när pulsluckan återgår till pulser
         
         x = 0;         // resetar 0 till 28 räknaren som bara har hunnit räkna mellan 22 och 27 pulser
         
         pekare = pekare + 1;                 // räknar upp spridarpinpekräknare
         
         if (pekare > 3)                      // när fjärde pinnen är nådd börjar den om igen
          {
          pekare = 0;                         // spridarpinne 1 är igång igen
          }
       }
                     
       if  (puls < priv - 300)                // jämför on ny pulstid är mindre än förgående - 300 uS.     
         {   
         digitalWrite (pulsutpin, LOW);           // utpin blir låg igen nästa uppgång i pulståget.
         }
 }       
       
                                              // end void loop()
 

Och nu, förklaringen, jag hoppas jag fattat hela funktionen, annars får ni fylla i/rätta!
Det första som händer när strömmen slås på är Setupen, den initierar ingångar, utgångar mm. Den tar info från översta delen när så behövs. Sedan börjar programmet arbeta i Loopen, den tuggar igenom hela alltet tills kommandot pulseIn(). Om motorn står still blir det en timeout och processorn kör hela harangen igen. När motorn väl börjar snurra börjar pulseIn() ge tider som motsvarar halva tiden per tand på vevaxelns tandhjul och vevaxelns tandlucka detekteras, vi är vid första tanden, vid varje ny tand räknar tandräknaren upp ett steg. (Jag har gjort om tandnummer till Case) För varje tand (Case-nummer) så anmodar jag processorn att göra vissa saker, tex läsa av gasläge, läsa av turbotryck, räkna pulstid i mikrosekunder, räkna på gasläge, räkna på tubotryck, räkna startfördröjningstid med hänsyn till varvtal, räkna ut spridare på-tid, sista acceptabla av tid mm. den tar Constanta värden högst upp i sketchen när så det behövs. När alla beräkningar är gjorda kommer vi till case 18 som är själva insprutningsmodulen.(För att den överhuvudtaget skall börja insprutningen måste motorn över 152 RPM i startvarv) Där sker först en fördröjning (ondelay) med hänsyn till beräkningar innan, om under ett visst varv blir det millisekunder, över blir det mikrosekunder. Sedan görs en av utgångarna 8 till 11 hög enligt ett mönster från kampin. och som driver transistorn till spridare x att öppna. Sedan efter en stund uträknat innan via delta så blir spridare x låg igen, samtidigt finns en extra pinne som blir hög/låg samtidigt som någon av spridarna aktiveras/avaktiveras. När spridaren har stängt så har processorn "missat" en eller flera tänder (pulser) från vevaxeln så när case 19 börjar är vi på 19 eller ända fram till 24... Detta beror på varvtal och belastning. Sedan ny inläsning av gasläge, turbotryck, turbo temp, atmosfärs temp (atmosfärstryck senare) . Om tid finnes (detta beror på vilken tand vi är på i verkligheten) så skriver vi ut lite aktuella värden via seriemonitorn, om debuggpin är aktiverad låg. Längst ner i sketchen är dels PulseIn() funktionen och dels pulsutpin som dels styr och letar upp motorns "hemläge" och dels matar ECU-monitor för varvtalsbestämning mm. Vidare finns en pekare som med hjälp av kamaxelns hallgivare detekterar motorns exakta cykel-läge som för övrigt börjar självgå efter puls 51. (Bra om kamaxelgivaren skulle ge upp i antingen hög eller lågläge eller nåt där emellan).
När alla uträkningar är klara så hoppar den ner till PulseIn() igen och väntar på en ny vevaxelpuls för en ny omgång. Så, processorn går i fas med motorns varvtal så alla tider ändrar sig med varvtalet. För att hålla styr på allt kombinerar jag millisekunder (riktigt låga varvtal) mikrosekunder och tänder från vevaxelns givare, soppan skall ju bli förståelig...
edit: konso1985: Jag har förstått att 12 volt är i lägsta laget, om jag får gissa så är det runt 25-30 volt i denna app.
edit 2: Ny sketch&senaste versionen

[Janson1]

Jag har nu testat lite hur lång tid det tar att läsa av analog värden i Arduino med 16 MHz klocka.
1 aktiverad ingång = ca 150 uS
2 aktiverade ingångar ca 260 uS
8 aktiverade ingångar tar däremot lite kortare tid totalt sett, man kan läsa alla 8 på ca 1000 uS.
Mao: Om man har tidsnöd är det totalt bättre att läsa av så många ingångar som möjligt i ett streck.
edit: skall väl tillägga att det även tar tid att starta/stoppa skrivfunktionen, den tar hela 350 uS så ev blir detta helfel...
då jag tänkte fel från början

[Ulf]

Här är ett ypperligt tillfälle att använda interrupt!
Ja,jag tjatar, men det blr så mycket tid "över".

[Janson1]

Denna ECU sketch kommer inte att få interrupt, om inte du Ulf eller någon annan gör om den till en fungerande ECU med interrupt förstås...
När man (jag i alla fall) grottar ner sig i en sån här stor grej så tar den upp väldigt mycket tid i hjärnan, det blir en röd tråd på hur saker och ting kan se ut för att få önskad funktion och det är ju just funktionen som jag vill ha. Nu har jag lyckats med den trots PulsIn() och utan interupt, ECU:n gör precis så som jag tänker mig att den skall göra vid av alla för mig testade olika kombinationer av varvtal, effektlägen mm. Ja så långt man kan komma utan att köra på riktigt. Men nu är det faktiskt dags att testa på riktigt. Jag har funnit en gammal passat som ev är rätt modell för 4000 spänn.

[Ulf]

Tyvärr har jag inte någon ork just nu för att sätta mig in i koden och än mindre skriva om (frbnnde värk).
Men som jag minns detdär med adomvandling i arduinon så tar väl första omvandlingen efter ett kanalbyte lite längre tid. Jag kan blanda ihop med annat iofs. Men kolla upp det.

[igelkottar]

Ja Ulf, värk suger .

[Towil]

Kanske kolla på att göra ADC i avr. Och skippa arduino på den delen.

sid 237

13 - 260µs Conversion Time

[Ulf]

Det är väl själva omvandlingstiden, lite overhead tillkommer, men det är väldigt lite i jämförelse. Det sks ju inte gå att starta en konvertering medans en annan pågår.
Fast det går ju att göra den så att adkonv går hela tiden och en isr sparar värdet på rätt ställe, tex en array. Då har du värdet på senaste i arrayen. Då behöver du inte vänta, utan det är bara att ta värdet i arrayen, det är alltid det senaste, dock för max 260x8 us sedan.

[Janson1]

Ja Ulf, det låter inte bra med värk. Hoppas på en bättring. Ang analogRead så är det för mig inget problem än och kommer förmodligen inte bli det heller då maxvarvet är så pass lågt. Men det är bra att veta att det är nära. Jag tittade i manualen från sid 237 och några sidor framåt, jag vet inte om jag blev så värst mycket klokare... Men, jag tror jag måste få ett konkret problem först innan det blir något fördjupande inom analogRead.

[Janson1]

Är det någon som vet vilken/vilka bilar man skall titta efter som har PD-diesel? Märken, modeller, årtal.

[Baron3D]

Kan detta vara till hjälp ?
https://en.wikipedia.org/wiki/List_of_Volkswagen_Group_diesel_engines

[Janson1]

Ja, det tror jag. Om jag väljer för ny så är det piezostyrda spridare och det tror jag inte passar mig, dom har betydligt högre öppningspänning än vanliga spridare och skall väl egentligen öppnas flera gånger per cykel. Så nu är det bara att leta upp en lagom gammal PD-diesel enligt Baron3D1:s förslag om wikipedia.

[Janson1]

Den här egenheten med att spridaren aktiveras en kort tid fast dom egentligen inte skall aktiveras alls, den tiden är mellan 12 och 15 mikrosekunder (det går 1 miljon mikrosekunder på en sekund). Det retar mig lite att det blir så men jag tror fortfarande inte det spelar någon roll för spridarna, dom kan väl inte hinna med att ens försöka stänga käglan i ventilhuset?

[Janson1]

En liten fortsättning av funktionerna i sketchen: Allra överst ligger alla konstanter som styr till och fråntider, max tider mm som skall vara lätta att ändra vid skarp motorkörning (detta är minst dom jag tror jag behöver ändra mycket på?) Sedan så finns det olika "case" dvs. när första tanden räknas hoppar processorn till case 1: Där tar den första pulstiden (den tiden som det tar för en tand i microsekunder att fara förbi vevaxelgivaren) och lägger på minnet. Case 2: Där tar den andra pulstiden plus den första och lägger ihop dom (delvalue) case 3: den tar tredje pulstiden plus dom förra tiderna och lägger ihop dom (delvalue). Vidare räknar den ut turbokorregeringsvärdet enligt ett kommando MAP och lägger det på minnet.(själva turbovärdet läses in i Case 19) case 4: Förutom nytt delvärde (delvalue) så räknas motorns börvärde ut, hur fort motorn skall gå via MAP kommandot (värdena i mikrosekunder) (själva potentiometerns värde läses in i Case 19). case 5, 6, 7 och 8: Den tar ny pulstid och plussar på den på den gamla. (här finns plats för mer uträkningar om det behövs) case 9: Här divideras alla ingående pulstidsvärden (delvalue) med 12 och vi får ett medeltal över dom 8 första tänderna plus en bra del av pulsluckan??vilket ger motorns medelfart per halvvarv i mikrosekunder. Sedan en if-sats som stänger av systemet om motorn går för sakta (under 152 RPM). case 10: Här räknas ERROR ut, alltså feltalet mellan inställt motorvarv och verkligt motorvarv. om motorn går exakt rätt varv blir error 0.0 (går motorn för sakta blir det error upp till ca 8.0) om error vill bli under 0 så förblir error 0 via if-satsen. case 11: för framtida bruk. case 12: likaså. case 13: Här räknas insprutningsfördröjningen ut (förtändningen). Med hjälp av motorns fart/ maxfart får jag ett tal(starttandf) mellan 0.0 och 8.0-10.0 någonting som jag sedan begränsar till tex. 8.0 via if-satsen vilket ger ca 6 grader FÖDP vid start/lågvarv/tomgång. case 14: Ger insprutningsfördröjningen i mikrosekunder (ondelay) genom att multiplicera motorns pulstid (uS) med starttandf (0.0-8.0). case 15: för framtida bruk.
case 16: Beroende på om motorn går i mellanvarv (normal fart) eller på fullvarv, (detta bestäms av if-satserna via motorns pulstid (mduration)). Så reagerar effektökningen olika vilket behövs då en propeller går lätt ända upp till i närheten av sitt arbetsvarv för att sen gå väldigt tungt vidare till max. case 17: Här bestäms när turbotrycket skall börja läsas av/användas och sedan skall ökat tryck minska pulsbrädden på spridarna. (om pulsbrädden råkar bli minus så förblir den 0 via if-satsen)
Nästa if-sats är till "mjukstarten" den dels hindrar spridaren att vara öppen för länge vid start och pytsar på lagom vid startning av motorn. Cas 18: Själva insprutningsmodulen, fortsättning följ
edit: felstavat.