Bygga ännu en ECU till en VW CR-dieselmotor

[Sunne]

Testade idag när jag hade ett ärende på lunchen. hittade bara "Deviation" för varje spridare, tror inte det säger så mycket men jag sparade ner turen i vart fall.
Undrar vad som styr det?

[Janson1]

Deviationen borde vara hur länge mer eller mindre spridaren behöver vara öppen för att till sist få exakt samma mängd per cylinder och insprutningstillfälle. Jag har förberett detta i mitt program men det står på noll då jag inte haft någon anledning att finjustera per spridare...

[Janson1]

Länge sedan sist... NU på jobbet har vi fått in en Passat 2,0 TDI Blue Motion 2015, men den är röd. Krockad, undanställd nåt halvår eller så? När vi fick in den så startade den men stannade direkt en gång för att aldrig mera starta. Vid OBD avläsning så var det ca 200 fel här och var och P060 från motorstyrdonet vilket betyder i princip tvärdöd PCU, ingen kommunikation helt enkelt... Mina elever lokaliserade burken och tog ur den, sen hjälpes vi åt att bänna och skära isär den. Vi hittade ett par vattenskador som vi tog bort och gjorde sen rent och ihop igen. Nu går motorn precis som den skall och bör! Med detta så har jag en fungerande CR-dieselmotor att göra mätningar på!
Det jag tänkte mäta är dels vevaxelgivaren i förhållande till en spridare och dels högtrycksregleringens ventil och även mängdregleringsventilen, hur och när den börjar verka. Bilder däremot glömde jag totalt men kan reparera skadan i dag...

[Janson1]

Bilder ja. Först motorn när huven och skyddslocket är borta.


Sen en oscilloskopsbild på en av spridarnas spolar vid tomgång.

Man kan se att den öppnar för insprutning 3 gånger per tillfälle. Nästa steg blir att utröna NÄR på varvet den öppnar.
Då det är elever som får göra "grovjobbet" så blir det myrsteg, men det blir i alla fall nåt...

[Janson1]

I går blev det ytterligare lite till gjort.

Här har jag kopplat på mig på vevaxelgivarens utsignal och en spridare igen. Den här motorn har en hallgivare på veven som ger 5 volt signal, man kan se hemläget som en liten förändring av pulslängden varje halvvarv. Den ger 29 pulser per halvt varv och insprutningen börjar på ca tand 22 och sprutar in tre gånger totalt. Jag har för mig att jag mätte in för länge sedan att tand 22 är övre dödpunkt och det stämmer ganska bra med när insprutningen bör ske vid tomgång, kanske i senaste laget?

Nästa bild är högtrycksventilens signal från motorstyrdonet. Den är aktivt on neråt så man kan se att den är på kanske 15-20 % av tiden. Detta stämmer också väldigt bra mot vad jag själv kommit fram till under mina försök.


Edit: liten fin korrigering...
edit 2: Det är 29 tänder och en tandlucka per halvt varv på vevaxelgivaren.

[magloman]

Man ska ju veta hur en CR diesel funkar. Bränslet sprutas ju direkt in i cylindern efter att luften komprimerats. Därav att den är så sen med bränslet.

Borde vara ungefär lika som på en fsi motor

[Janson1]

Ok. Nästa grej som jag tror jag behöver lösa allra först är att detektera ut luckan som inte är någon bra lucka längre...

[Towil]

Mät pulstiden. När den blir dubblet så lång har du luckan.

[Janson1]

Ja, jag har sniffat på detta redan lite... På en syntetisk puls och vid jämnt och fint varvtal är det inga problem men när pulståget ser ut som ett dragspel så blir det lite svårare! Som första grej blir det att bygga om min simulator till att lämna så lika som möjligt.

[Towil]

Behöver ju bara kolla mot föregående puls. Vinklehastigheten tidigare på varvet är ju ointressant.

[jpd]

En lösning på det där är att bygga en PLL som låser på frekvensen.
Då kommer luckan att dyka upp på återkopplingssignalen.

Edit: Med bygga menar jag att skriva en PLL i kod.

[Janson1]

Jag vet väl i och för sig vad en PLL är (Phase locked Loop, eller nåt sånt) Men utan att tjuvtitta på nån färdig kod så har jag dålig idé på hur jag skall lösa det... I alla fall så laddar jag lite för att komma igång igen med lite programmering och experimentlusta!
Livets alla måsten har varit i vägen nu alldeles för länge! Är det något mera som behöver mätas på i den här Passat TDI:n?
Edit: Jag hittade koden som jag filade på för nåt år sedan eller så:

Kod: Markera allt

  // Nu helt ny med Interrupt på vevpin (2) och 26-2 tänder på vevtandhjulet.                                                               
    // Tändlägesjustering verkar ua ochså.                                                              Fungerar
    // Nu läser den av alla analogread i följd om 2 och 2                                               Fungerar
    // Batterispänningens inverkan grovjusterad                                                         Fungerar
    // En individuell möjlig iför injustering per spridare finns med.                                   Fungerar
    // Ändrad i gasen så analogvärde 20 är tomgång och analogvärde 210 är fullfart                      Fungerar
    // Mjukstarten är förbättrad och går in vid ca 200 RPM och varar till ca 450 RPM                    Fungerar
    // Några fler constanter har kommit till bla. gaspotmin, gaspotmax, utanvärde,                      Fungerar
    // En dubbel förtändning har kommit till, en för start och en för drift.                            Fungerar
    // En ny regleringsmetod inlaggd                                                                    Fungerar
    // En ny delta2 har tillkommit för ökad mängd mellan 200 till 450 rpm                               Fungerar
    // Fasttidsfunktionen är förbättrad, funkar nu på alla 4 grundtider    NYTT                         Fungerar
    // senasteinsprdrift = 8.5; Detta är ändrat från 8.0 pga lite knack vid belastning låga varv.       Fungerar
    // Ändrat: senaste insprutning från 2.0 till 3.0 (start)faktor 1100 till 2000 för att få tidigare/mer gasrespons låga varv. skall testas
   
    // Pga av interrupt så måste alla durationstider inom tandräkning dubbleras, eller halveras beroende på hur och var dom står
//-------------------------------Här börjar programmet---------------------------------------------------------------------------------------------------------------------------------   
            // här är olika justerbara parametrar (Konstanter) som påverkar enligt följande:
    const byte totaltid = 6;            // totaltid för case 15
    const int minfart = 7600;           // lägsta startvarv för spridarfunktion (7600 = 131 RPM)
    const byte startmangd = 6;         // avgör max startmängd 32  ca 19 grader ontid (32) mellan 131 till 200 RPM (absolut första början)32
    const int effektfaktor = 1500;      // hur mycket effektökning skall gälla vid gaspådrag.(1500)
    const int lagmangd = 2;             // max lågvarvsmängd 4 = 2 vevaxelpuls = 12 grader ontid (under tomgångsvarv)(4) 200 till 300 RPM (mjukstartsmängd)max 5 pga 16383 uS!!!
    const int tid1 = 4800;              // tid 1 är för att hitta pulsluckan vid start/lågvarv < 300 RPM (4800)                           
    const int tid2 = 2500;              // tid 2 är för att hitta pulsluckan i mellanvarv 1100--> (2500)
    const int tid3 = 1600;              // tid 3 är för att hitta pulsluckan i alla andra förekommande varv 1100--> (1600)
    const int tid4 = 180;               // tid 4 är för att hitta pulsluckan på högsta varvtal (180)
    const float senasteinsprdrift = 4.6;// Vid tomgång/drift ges en ny "senasteinsprutningstid" som behålls sedan. (högre tal ger senare tändning)(4.6)
    const byte tidigasteinspr = 240;    // kortaste insprutningsfördröjning vid maxvarv, högre tal ger tidigare tändning(240)(max 255)
    const float korrfaktor = 1.3;       // korrektionsfaktor för att senare lägga insprutningsbörjan till högre varv
    const float minstaAggrFaktor = 1.8; // gasrespons, den minsta förekommande (2.5) (1.3)
    const int sprtroghet = 60;          // ett grundvärde för spridarnas påslagsfördröjning i uS (60)                     
    const int sprdiff1 = 20;            // en ev tidigareläggning av spridare 1 om den avviker i startfördröjning (20 uS)
    const int sprdiff2 = 20;            // en ev tidigareläggning av spridare 2 om den avviker i startfördröjning (20 uS)
    const int sprdiff3 = 20;            // en ev tidigareläggning av spridare 3 om den avviker i startfördröjning (20 uS)
    const int sprdiff4 = 20;            // en ev tidigareläggning av spridare 4 om den avviker i startfördröjning (20 uS) 
    const int pumpdelay = 500;          // avstängsfördröjning för elpump i millisekunder                     
    const int omslagstartdrift = 3000;  // Bestämmer när mjukstarten går ur (omslagspunkt) (1800 = brytvarv 450 RPM) skall vara 3000!!2400
    const int omslagmillimicro= 4000;   // omslag från milli till micro i case 16 (vid startvarv ca 200 RPM, baseras på mduration i us)(4000)
    const byte utanvarde = 60;          // om delta är under ett visst värde utanvärde, nollas delta (60)
    const byte gaspotmin = 20;          // gaspotens minsta tillåtna värde (20)
    const byte gaspotmax = 210;         // gaspotens största tillåtna värde (210)
    const int lagstavarv = 1140;        // tomgångsvarvet 1000 uS motsvarar ca 800 Rpm (1140)
    const byte hogstavarv = 210;        // fullgasvarvet 180 uS motsvarar ca 4000 RPM  (210)
    const byte mintryck = 55;           // lägsta bränsletryck i railen (10)
    const byte maxtryck = 150;          // högsta bränsletryck i railen (250) max 255!!
    //const byte minstaPilotdelta =0;   // här ställs den minsta pilotinsprutningstiden, vid låga varv
    //const byte mestaPilotdelta = 0;   // här ställs den högsta pilotinsprutningstiden, vid högre varv
    const int treglerb = 2000;          // TryckReglerBörjan, bestämmer vid vilket varvtal trycket skall börja stiga
                // dom olika variablerna
    float senasteinspr = 2.0;         // senaste insprutningstid (vid start upp till tomgång)(6.0 = 3 vevaxelpulser = 18 grader delaytid(2.0) Tomgångsförtändning.
    int fasttid = 180;                // Fasttid = börjar alltid på 180 för att sedan ställa in mer rätt (tid1 till tid4)
    byte tand = 0;                    // vevaxelräknarpulser räknare 0 till 27.
    unsigned long tand2 = 0;          // vevaxelräknarpulser för senareläggare av start för HPFV
    byte spridare = 0 ;               // spridare för att välja rätt spridarutgång, startar på 0
    float aggrfaktor;                 // ett uträknat decimalvärde
    unsigned long delvalue;           // delvärde av pulstid i uS.
    unsigned int ondelay;             // tillslagsfördröjning spridare i uS/mS (mS inne i case 16)
    long puls, priv;                  // pulstid, föregående pulstid
    unsigned int delta, delta2;       // delta (totalöppningstid) i uS(mS) och en delta2 vid start
    float error;                      // error = varvtalsfelet i decimalform
    float starttandf;                 // starttand i decimalform för att få startfördröjningstid och finkorrigering av öppninstiden +-.
    float  mduration, bduration;      // varvfelet = motorduration/börduration i decimalform
    int fmduration;                   // en Förändrad Motor Duration
    byte gas;                         // gas 0-255
    byte analogval;                   // En switch/case till analogread
    int sprtroghetklar;               // korrektion för den inbyggda påslagströgheten i spridarna
    int spridardiff;                  // en ev. individuell spridartid korrigering (uS)
    int sprstartkorr;
    int battVolt;
    volatile unsigned long VEVTAND_langd; // nuvarande tandlängd
    volatile unsigned long VEVTAND_start; // tandstart
    unsigned long prev_langd;             // föregående tandlängd
    unsigned long pumpvakt1_ul32;         // en timer inlaggd för att bevaka elbränslepumpen
    unsigned long pumpvakt2_ul32;         // så den stannar vid motorstopp/misslyckad start
    unsigned long nytid_ul32;             // nytid läses varje halvvarv
    unsigned long datid_ul32;             // och jämföres med dåtid förra halvvarvet
    unsigned long totaltid_ul32;          // summa tiden per halvvarv i uS
    volatile int caseRead;                // om case x är läst eller ej
    byte ftryck;                          // bränsletryck
   // int pilotinspr;                       // en uträknad pilotstråleinsprutningstid
    int HPFS;                             // avläst värde från bränlsehögtryckssensorn (High Pressure Fuel Sender)
   // int pilotdelta;                       // ett förinsprutningstidsvärde
    byte pftryck;                         // PumpFörTryck till elbränslepumpen
   
                 // Dom olika I/O anslutningarna
    int vevSignal = 2;                // pulsingång vevaxelgivare, (aktivt låg).2
    int kamSignal = 3;                // kamaxelgivarens ingång, (aktivt hög).3
    int pulsutpin = 4;                // pulsutgång 2 pulser per varv (kontrollutgång för övervakningen).4
    int sprpins [] ={7,8,9,12};       // till spridarna (blir aktivt höga)7,8,9,12
    int Disable = 18;                 // aktivt låg stoppar utsignalerna till spridarna 18
    int tidute = 17;                  // kontrollutgång som blir aktiv när elpumpen är aktivt avstängd 19
    int sprControl = 13;              // kontrollutgång för spridare till övervakningen 13
    int elpump = 11;                  // PWM-utgång till motorns Elbränslepump 11
    int HPFV = 10;                    // PWM-utgång till motorns bränslehögtrycksreglerventil  (High Pressure Fuel Valve) 10
    int fardig = 19;                  // kontrollutgång som indikerar färdig/drift
   
 void setup()                         // körs bara en gång vid uppstart/reset                   
 {               // här ges alla I/O dess funktion   
   pinMode(vevSignal, INPUT_PULLUP);  // satt vevaxelsignal som ingång (2)
   attachInterrupt(digitalPinToInterrupt(vevSignal), VEV_pulse, FALLING);      // här blir vevpin (2) interruptstyrd                     
   pinMode(kamSignal, INPUT);         // satt kamaxelsignal som ingång (3)
   pinMode(sprpins[spridare], OUTPUT);// spridarutgångar satta som arrey (7,8,9,12)
   pinMode(sprControl, OUTPUT);       // en spridarkontrollutgång som blir hög varje gång en spridare öppnas (13)(Övervakningen)
   pinMode(Disable, INPUT_PULLUP);    // ECU väljare Hög = on, Låg = off (18)
   pinMode(tidute, OUTPUT);           // satt tidute som utgång (19)
   pinMode(pulsutpin, OUTPUT);        // satt pulsutpin som utgång (2 pulser per varv)(4)(övervakningen)
   pinMode(elpump, OUTPUT);           // elbränslepump satt som utgång (11)
   pinMode(HPFV, OUTPUT);             // bränslehögtrycksreglerventil satt som utgång (10)
   pinMode(fardig, OUTPUT);           // satt färdig som utgång
   //Serial.begin(250000);              // bra att ha...
   digitalWrite(elpump, HIGH);        // elpumpen startar i setup
   delay(1500);                       // elpumpen går i 1,5 sekunder
   digitalWrite(elpump, LOW);         // elpumpen stannar igen, motor redo för start.
   digitalWrite(fardig, HIGH);        // sätter färdigutgången hög inför start.
 }

//----------------------------------------Här börjar själva programloopen, denna körs hela tiden------------------------------------------------------------------------------------------
    void loop()
 {
     
                                    // Det får plats ca 1700 klockcykler mellan varje x tal(case) (0 till 17 & 30 till 46)
                                    // Det tar lite mer än 100 mikrosek att läsa av en analogingång,
                                    // så ingen analogRead här, skall vara i case 26/56!
 
     if (digitalRead(Disable)==LOW)     // Disable låg stänger av ECU:ns utgångar och gör den passiv
      { 
      delta = 0;                        // Genom att delta (insprutningstid) förblir 0.
      pinMode(sprpins[spridare], INPUT);// Gör om spridarutgångarna till ingångar för att ej belasta
      pinMode(sprControl, INPUT);       // Gör om spridarcontrollen till ingång för att ej belasta
      pinMode(elpump, INPUT);           // gör om elbränslepumpen till ingång för att ej belasta
      pinMode(HPFV, INPUT);             // gör om bränsletrycksventilutgång till ingång för att ej belasta
      pinMode(fardig, INPUT);           // sätter "färdig" låg
      }
     
     else //*
      {
      pinMode(sprpins[spridare],OUTPUT);// Vid aktiv så gäller spridarutgångarna som utgångar igen.
      pinMode(sprControl, OUTPUT);      // Vid aktiv så gäller spridarcontrollen som utgång igen
      pinMode(elpump, OUTPUT);          // Vid aktiv så gäller elbränslepumpen som utgång igen
      pinMode(HPFV, OUTPUT);            // Vid aktiv så gäller bränsletrycksventilutgång som utgång igen
      pinMode(fardig,OUTPUT);           // Vid aktiv så gäller färdig som utgång igen
      digitalWrite(fardig, HIGH);       // Vid aktiv så sätts "färdig" hög
      }                            //*Detta är normalläget, samma som i setup*
     
     pumpvakt2_ul32 = millis();                // här läggs en tid in från millisräknaren precis innan case x skall läsas
     if(pumpvakt2_ul32 - pumpvakt1_ul32 >=pumpdelay) // här jämförs tiderna, blir det ingen läsning av case x pga att motorn
      {                                        // står stilla så blir det "tidute"
       digitalWrite(elpump, LOW);              // elbränslepumpen stängs av
       digitalWrite(tidute, HIGH);             // utgången "tidute" går hög
      }
      else
      {
        digitalWrite(tidute, LOW);             // normalfall dvs motorn går.
      }
     
     if(caseRead == 1)                        // är case´t läst?
      {
       caseRead = 0;                          // case´t läst = 0
      pumpvakt1_ul32 = millis();              // här läggs en tid in från millisräknaren precis efter identifiering av: läs av case x
       
    switch (tand)            // här startar switch och case, tandräknaren stegar fram ett steg (case)
   {
     case 0:                                         // lägger in rätt spridare till rätt spridardiff 
                             
          if (spridare == 0)                         // om spridarpekaren pekar på 0 (ben D7)
           {
           spridardiff = sprdiff4;                   // skall det individuella värdet för spridare 4 hämtas
           }

          if (spridare == 1)                         // om spridarpekaren pekar på 1 (ben D8)
           {
           spridardiff = sprdiff2;                   // skall det individuella värdet för spridare 2 hämtas
           }

          if (spridare == 2)                         // om osv... upp till 3 (fjärde spridaren)
           {
           spridardiff = sprdiff1;                   // ben D9
           }
 
          if (spridare == 3)
           {
           spridardiff = sprdiff3;                 // ben D12
           }
     break;
     
     case 1:               // Detta case ger elbränslepumpens fart (PWM)
          pftryck = map(mduration,8000,210, 150, 255); // elbränslepumpens effekt ställs här
          pftryck = constrain(pftryck,150,255);        // om effekten hamnar utanför så ställs PWM att vara 120-255 ändå.
     break;
     
     
     case 2:              // Detta case startar elpumpsstyrningen
         if(mduration <15200)                 // motorn måste gå i startvarv eller mer
          {
           digitalWrite(elpump, HIGH); //analogWrite(elpump, pftryck);    // för att elpumpen skall starta
          }
     break;
     
       
     case 3:             // Detta case tomt
          sprstartkorr =map(battVolt, 150, 700, 200, 0);  // batterispänningen blir spridartidskorrigering
          sprstartkorr = constrain(sprstartkorr,200,20); // för att hålla färdigvärdet inom 400-200 uS
     break;
       
                                     
     case 4:             // Detta case ger bränslehögtrycksreglering och fördröjd start
          fmduration = constrain(mduration,hogstavarv,treglerb);     // En ny variabel FörändradMotorDuration
          ftryck = map(fmduration,treglerb,hogstavarv, mintryck,maxtryck);// här mapas bränsletrycket om för att följa varvtalet
          ftryck = constrain(ftryck,mintryck,maxtryck);          // här begränsas min-maxvärde för PWM hpfv 10-255
          if(tand2 > 87)                                         // fördröjer starten 1,5 vevaxelvarv
          {
          if(digitalRead(HPFV == LOW))                           // om högtrycksventilen är öppen (opåverkad)
          {
          digitalWrite(HPFV, HIGH);                              // så stängs den först 100%
          }
          analogWrite(HPFV, ftryck);                             // sen styrs den ut via PWM 0-255
          }
     break; 
                             
       
     case 5:             // Detta case ger motorns duration per halvvarv
          totaltid_ul32 = nytid_ul32 - datid_ul32; // här jämförs ny tid med gammal tid och det blir en summa tid i uS
          datid_ul32 = nytid_ul32;              // den nya tiden läggs i föregående tid (dåtid)
          mduration = totaltid_ul32/28;              // summatiden divideras med 28 för att passa övriga tider (uS)
         /* Serial.print("mduration");
          Serial.print(mduration);
          Serial.print("VEVTAND_langd");
          Serial.println(VEVTAND_langd);
    */ break;
                   
     case 6:            // Detta case ger motorns börvärde från gaspoten som blir lägsta och högsta varvta
           gas = constrain(gas,gaspotmin, gaspotmax);                          // först skall invärdet vara mellan min och max oavsett gaspotens verkliga värde (om utanför)       
           bduration = map (gas,gaspotmin, gaspotmax, lagstavarv, hogstavarv); // gör om gas analogvärde till lägsta/högsta uS värde
     break;
             
       
     case 7:             // Detta case ger error, motorns över/undervarv i förhållande till börvarvet.
        error = (mduration / bduration)-1;     // felet
        if (error <=0.)                        // om error hamnar under noll
        {
           error = 0.;                         // förblir error 0 för att ej få minusvärden
        }        // felet i uS mellan ärvärde och börvärde för motorns duration (varvtal)
       
                 // här testas fasttid ut genom att gämföra vilken mduration som passar bäst.
        fasttid = (VEVTAND_langd < 1000) ? tid4 : (( VEVTAND_langd < 2400) ? tid3 : (( VEVTAND_langd < 3600 ) ? tid2 : tid1)); 
     break;
     
     case 8: 
          // tomt
     break;
   
       
     case 9:            // Detta case detekterar kamaxelns hemposition     
         if (digitalRead(kamSignal)== HIGH)   // varje gång kamaxelns hempuls detekteras så resetas 4 räknaren (aktivt låg)
          {
          spridare = 3;                      // resetas till 3. dvs cylinder 2 blir aktiv.
          }
         if (digitalRead(kamSignal)== LOW)  // ingen hempuls?
          {
          //gör ingenting
          }
     break;
     
       
     case 10:          // Detta case räknar ut tidsdiff per spridare
         sprtroghetklar = sprtroghet + spridardiff - sprstartkorr;          // spridartröghet klart värde räknas ut här
     break;         
                       
   
     case 11:        // Detta case för insprutningsfördröjning i gånger, ställs högst upp
                     // Detta case ger förtändningen
           
       starttandf = (mduration * korrfaktor) /tidigasteinspr;            // starttandf, ett flyt-tal = motorns duration x korrektionstal/ minsta duration.
       if (starttandf >= senasteinspr)                                   // om fördröjning över målvärdet, som vid tex startvarv
        {                 
         starttandf = senasteinspr;                                      // blir det målvärdet ändå
        }
     
        ondelay = (mduration * starttandf);                                 // tillslagsfördröjning = motorns duration * starttandsfördröjning (decimaltal)
                                                                            // Ondelay uS = mduration uS * starttandf i decimalform
      /* if((mduration > omslagstartdrift) && (mduration < omslagmillimicro)) // om motorns duration ligger mellan 4000 us och 3000 uS
         {
          delta2 = lagmangd * mduration;                                    // så skall extra insprutningstid läggas till (delta2)                                                                       
         }
       else
         {
          delta2 = 0;                                                      // annars ej delta2
         }
     */break;       
     
     case 12:               // Här räknas effektregleringen ut genom hela registret från 450 rpm och uppåt
                            // även förinsprutningens uträkning skall vara här (pilotinjection)
     if(mduration <=omslagstartdrift)                                      // Om/när motorn går över 450 rpm
     {
      aggrfaktor = effektfaktor/mduration;                                 // Här räknas aggresionsfaktorn ut med hänsyn av en gångerfaktor/ motorns duration. (varvtal)
      if(aggrfaktor < minstaAggrFaktor)                                    // om aggresionsfaktorn blir mindre än minsta aggresionsfaktor
      {
        aggrfaktor = minstaAggrFaktor;                                     // så blir ändå aggresionsfaktorn den förutbestämda agresionsfaktorn.                                             
      }
      delta = aggrfaktor * mduration * error;                              // Här räknas delta ut med hänsyn till agresinsfaktorn, motorns duration och gasreglägets värde
    //  pilotdelta = delta/5;                                                // Pilotinsprutningstid blir här en 5del av total tid
     // pilotdelta = constrain(pilotdelta,minstaPilotdelta, mestaPilotdelta);        // Pilotinsprutningstid ställs in att bli mellan minsta pilotdelta och mesta pilotdelta uS
     }       
     break;

     case 13:            // Detta case ger mjukstarten
     
      if (mduration >= omslagstartdrift)                                    // Vid lite över startfart  mellan 200 RPM till ca 450 RPM
      {
       delta = lagmangd * mduration;                                        // blir det mjukstart som justeras via lågmängd             
      }
               // och absolut längsta insprutningstid
     if (delta + ondelay >= totaltid * mduration)                           // om delta och ondelay i uS blir mer än totaltid
      {       // så justeras endast delta ner
       delta = (totaltid * mduration)-ondelay;                              // Absolut max insprutningstid (delta),
      }       // denna justering gäller för max insprutnings-"fönster"
     break;

     case 14:   // Detta case ger olika förtändning för start och drift
     
         if (mduration < omslagstartdrift)                                  // går motorn över driftfart?
          {
           senasteinspr = senasteinsprdrift;                                // i så fall läggs förtändning drift (normalfallet)
          }
        else
         {
          // gör ingenting                                                                  // Annars förtändning start                                       
         }
     break;
 //------------------------------------------------------------------------------------- case 15, insprutningsfasen-----------------------------------------------------------------   
     case 17:    // Detta case är insprutningsfasen "spridar-on-off-mode"
      if (mduration >=omslagmillimicro)       // Om motorns duration är mer än xx uS. (från 131 till 203 RPM räknas alla spridarvärden i mS) 5000 = 203 RPM
       {                                      // går tiden över från uS till mS.
       ondelay = ondelay/1000;               // Ondelay uS blir mS.
       delta = delta/1000;                   // Delta uS blir mS.

                // avgör om tillräcklig fart är uppnådd för motorstart                   
       if(mduration >= minfart)                // motorn måste upp i x fart för att få bränsle, (minfart i uS)
        {                         
        delta = 0;                             // vid underfart, delta(insprutningstid)nollas
        }
                // och startmängden vid motorstart
          if ((delta * 4)>= startmangd)          // här ställs startmängden in 
           {                                                                      //  32
           delta = startmangd;                   // så det blir rätt startmängd/slag (5 = 0,75 tänder = 4,5 vevgrader)
           }
           delay(ondelay);                       // Fördröjer starttiden x antal mS beroende på varvtalet (mdurationen)
           digitalWrite (sprpins[spridare],HIGH);// Spridarpinne hög,insprutning börjar. spridare x strömsätts [visare 8,9,10 eller 11].
           digitalWrite(sprControl, HIGH);       // Kontrollpinne som blir 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[spridare],LOW); // Spridarpinne låg,insprutning avslutad spridare x stängs av  [visare 8,9,10 eller 11].
           digitalWrite (sprControl, LOW);       // Kontrollpinne som går tillbaka till låg efter varje insprutningstillfälle.
           ondelay = ondelay*1000;               // Ondelay mS blir uS igen.
           delta = delta*1000;                   // delta mS blir uS igen.
       }         // Detta paket används vid låga farter såsom start/lågvarv < 203 RPM
     //---------------------------------------------------------------------------------------------------------------------------- 
    else        // Eller om mduration är mindre än 4000 uS. (> 203 RPM)
       {
         if (delta > utanvarde)                 // Delta under utanvärde uS har inget värde
          {
           delta = delta + sprtroghetklar;      // Delta blir  delta + trögheten i spridaren (ca 80 uS)som tröghetskompensation
          // pilotdelta = pilotdelta;             // och en förinsprutningstid läggs till
          }
          ondelay = ondelay - sprtroghetklar;   // tidigarelägger insprutningstart med hänsyn till spridartrögheten
          delayMicroseconds(ondelay);           // Fördröjer starttiden i ondelay uS beroende på varvtalet (mdurationen)
          digitalWrite(sprpins[spridare],HIGH); // Insprutning börjar. spridare x strömsätts.
          digitalWrite(sprControl, HIGH);       // Kontrollpinne som blir hög vid varje insprutningstillfälle.
        //  delayMicroseconds(pilotdelta);        // Pilotinsprutningstid på mellan 100 och 200 uS
         // digitalWrite(sprpins[spridare],LOW);  // Sen stängs spridaren av igen, beredningstid och tändning av bränslet inleds
        //  delayMicroseconds(50);                // Här ges tiden för just beredning och tändning av bränslet
         // digitalWrite(sprpins[spridare],HIGH); // Den stora insprutningen startar här
          delayMicroseconds(delta);             // Här läggs den stora insprutningstiden in vid drift (normalfallet)
         // delayMicroseconds(delta2);            // Här läggs en extra insprutningstid in som bara gäller mellan 203-450 rpm (mellan 4000-3000 uS)
          digitalWrite (sprpins[spridare],LOW); // Spridarpinne låg,insprutning avslutad spridare x stängs av 
          digitalWrite (sprControl, LOW);       // Kontrollpinne som går tillbaka till låg efter varje insprutningstillfälle.
       }                                //Detta paket används vid varv (203 -> RPM = nästan alltid, förutom vid motorstart)
       spridare ++;                             // här räknas spridarutgången upp ett steg
     if (spridare > 3)                          // när fjärde spridarutgången är nådd börjar den om igen
      {
      spridare = 0;                          // spridarutgång 0 är igång igen (0 = D7)
      }
     break;      // Detta paket tar 1 till 6 tänder att genomföra beroende på varvtal och belastning
//-------------------------------------------------------------------- case 16, insprutningsfasen avslutad-------------------------------------------------------------------------


               // Här läses alla analoga signaler max 2 per gång av max 8 st totalt (A0 till A7)
     case 23:                               // är mellan  tand 17 och 23
     
          switch (analogval)
     {
        case 0:   
           gas = analogRead(A0)>>2;           // analogingång för gasreglage 0 till 255( skiftad 2 gånger)
           // tom
        break; 

        case 1:
           HPFS = analogRead(A1);             // analogingång som läser av bränslehögtrycket
           battVolt = analogRead(A7);
        break;

        case 2:
           gas = analogRead(A0)>>2;           // analogingång för gasreglage 0 till 255( skiftad 2 gånger)
           // tom                             
        break;
       
        case 3:
           //  tom
           //  tom
        break;

        case 4:
           gas = analogRead(A0)>>2;             // analogingång för gasreglage 0 till 255( skiftad 2 gånger)
           // tom
        break;

        case 5:
           // tom
           // tom
        break;                               
     }
     
     analogval ++;                              // räkna upp analogval 1 steg   
       if (analogval > 5)                       // när analogval har blivit 5 så
        {
         analogval = 0;                         // resettas analogval till 0 igen
        }   
    break;     // analalogRead tar ca 120 uS att läsa = 1-2 tänder vid fullvarv
  }                                            // nu är alla switch-case lästa
 }
 }
 //-------------------------------------- Nedan är för att leta upp tandluckan, räkna upp tandräknaren,reseta tandräknaren, bestämma motorns duration (varvtal)--------------------------
 //---------------------------------------Hela denna del är interruptstyrd och anropas vid varje ny puls från vevaxelgivaren-----------------------         
     


  void VEV_pulse()                              // När en ny vevaxelpuls är detekterad så går denna loop igång
{                                               // Den:
  unsigned long thisLength = micros();          // tar ett ögonblicksvärde på microsekunderräknaren
  caseRead = 1;                                 // sätter en flagga till case read
  prev_langd = VEVTAND_langd;                   // nuvarande vevtands längd läggs in som föregående vevtandslängd (döper om)
 
  VEVTAND_langd = thisLength-VEVTAND_start;     // Längden på nuvarande lucka hamnar i variabeln VEVTAND_langd
  VEVTAND_start = thisLength;                   // Börja mätning av lucka
   tand++;                                      // tandräknaren räknar upp en tand
   tand2++;                                     // tandräknare 2 räknar upp en tand
   if(VEVTAND_langd > prev_langd + fasttid)     // OM nyaste vevtands längd är längre än föregåendes + fasttid
    {                                           // då är luckan hittad
    digitalWrite(pulsutpin, HIGH);              // Då går utpin hög
     nytid_ul32 = micros();                    // En tid från microräknaren läggs in
    tand = 0;                                   // och tandräknaren resetas till 0 (början på tandräkningen)
   
                  // Denna if-sats är bara sann varje halv-varv vid luckan
    }
  if(VEVTAND_langd < prev_langd - fasttid)      // OM nyaste vevtands längd är kortare än föregående -fasttid
   {                                            // då är luckan slut
   digitalWrite(pulsutpin, LOW);                // och utpin blir låg igen.
   }

}
 //--------------------------------------------Här slutar den Interruptstyrda delen------------------------------------------------------------------------------------------
       
//-------------------------------------------------slut loop-----------------------------------------------------------------------------------------------------------------------       
                                               

Då det var ett tag sedan så har jag glömt en bra del men det är väl bara att läsa på igen...

[Janson1]

Ja, ev så blir det lite tid för programmering av sista tillskottet, CR-diesel´n. Jag undrar om den är startbar nu några år senare, ev så har dieseln i pump och rail blivit dålig? Men, jag har tänkt om lite ang hur man skall styra den. Det behövs två delar i styrningen, när motorn är kall så skall trycket regleras via högtrycksventilen. Man PWM styr den så trycket blir lagom. (Om man tex styr ut PWM 40% ontid så orkar ventilen hålla trycket tills det når tex 800 bar, sen börjar bränslet sippra ut ur ventilen och rinna tillbaka till tanken.) Samtidigt styr man ontiderna på spridarna så det blir rätt varvtal i förhållande till satt varvtal. När motorn sen blir varm (>45 grader?) så börjar man reglera på pumpens mängdventil istället, samtidigt stänger man högtrycksventilen (80-90% PWM och då läcker den bara om något går fel på riktigt) och kör spridarna mer en fast öppningtid och sen reglerar man via pumpens reglerventil. Denna ventil är kopplad på högtryckspumpens "sugsida" och begränsar inkommande bränslemängd per slag så då blir det en förbestämmd bränslemängd varje gång som berörd spridare portionerar ut per insprutningstillfälle. Den här mängdreglerventilen fungerar tvärtemot. Vid 0% PWm så begränsar den noll, dvs full fart. På 100% begränsar den så mycket den kan. Man borde kunna styra farten/effekten på motorn enbart med denna ventil och sen ha fast öppningstid per spridare. ( + - dess inbyggda tröghet per exemplar.) Sen Sunne: Vad jag kan utläsa på din mätvärden från VCDS så sprutas soppan in 3,5 grader efter övre dödpunkten. (3,5 g ATDC) och railtrycket ligger på 288 bar. Allt detta stämmer inom limit med vad jag kan se på mina oscilloskopsmätningar med. Så jag tror jag skall damma av dels motorn och dels mina minnen av vad jag gjorde sist och vad jag körde fast på sist...

[Janson1]

En liten resumé /avdammning... Det första jag gjorde var att programmera om motorsimulatorn så den lämnar rätt antal pulser och med rätt polaritet.
Sen letade jag upp nya ECU:n, ett slags universalkort med bara plats för en NANO eller liknande med samma fotprint.(den bör vara 5 volt) Sen har jag nu lusläst (och fortsätter) koden till själva ECU:n och försöka förstå vad som händer när det händer fel, för nåt fel händer ibland! Egentligen är denna kod ganska lika mitt första helt fungerande alster, PD-dieseln med några undantag. Öppnngstiderna för spridarna är mycket kortare rent generellt, det har tillkommit en elpump som är PWM styrd och en en tryckreglerventil som också är PWM styrd och dessa två PWM utgångar fungerar, så långt bra. Det är spridarutgångarna som ibland är lite kaiko... Där är jag nu. Nu är det skola i dag och i morgon onsdag och torsdag skall jag på kurs om CAN-buss system, jag hoppas det blir intressant. Inför kursen så skickades det ut en rad frågor till alla deltagare om dess förkunskaper. Av frågorna att döma så blir det nog en avancerad nivå på kursen vilket jag hoppas!

[Janson1]

Nu fanns det tid för att köra skapelsen på kammaren. Efter en del omprogrammeringar så funkar allt så som jag önskar att det skall funka! Om det är rätt för motorn vet jag däremot inte... Jag var ute i ett av mina många förråd i går kväll och har i alla fall lokaliserat motorn. Alla kablar och slangar sitter kvar. Men elpumpen satt på en annan motor just nu, startmotorn likaså. Som tur är så sitter ingående bränsleslang ihop med utgående så det bör inte gått in nån skit i alla fall och den lilla dieseln jag kunde se såg iordning ut. Tyvärr så har jag åkt på en förkylning så humöret och motivationen för att göra nåt vettigt ligger inte på topp, får se om jag orkar i helgen. Jag blev med ett garage (4,20x 8,40, knappt 3 meter högt) till nu förra helgen som har stått nermonterat på mina ägor. Som sagt, förra helgen monterade vi ihop det så nu har jag ett tak att fixa till också. Jag funderar på att inreda innersta biten till en ny experimentverkstad då min yngsta son verkar ha parkerat sig för gott i stora verkstaden... Jag behöver nog ha en plats för att köra motorn när det är dags så jag får försöka få till ett litet "laboratorium" snart... Jag kommer nog inte så mycket längre med programmeringen och torrkörningen! Nu lär det väl bli ett hopp i tiden innan det händer nåt på riktigt.