En Grålle införskaffad för utprovning av VW Dieselmotor

[ac tc]

Nån skrev att en P regulator inte kan ge 100% ut, det stämmer inte men den måste ha en liten avvikelse som den kan styra mot.
- ex 1 % avv och en förstärkning på 100 så ger P delen full utstyrning, ett ganska ovanligt fall i regler världen men det förekommer.
I många fall så tar man till parameterstyrning, dvs man låter regulatorn ha olika parametrar beroende på vart i området den ligger eller på hur avvikelsen ser ut.
D delen är ofta inte ansluten direkt i en regulator utan man får själv koppla in den signal eller kombination av signaler som man vill att den ska reagera på.
Typiska signaler är delta bör/ är, förutsebara påverkare ( ex vis i detta fall gaspedalens förrändring ), annan yttre störning ( typ dragkraft i redskapsfäste på en traktor) osv.
- PID regulatorn är ingen hokus-pokus pryl utan den sanna arbetshästen inom reglervärlden, 99.9% av reglering sker med PID´dar.
Det viktigaste för att kunna köra med hög förstärkning är att få snabba svar från processen ( i detta fal motorn och dess varvtal ), brusfri signal och snabba cykeltider för uppdatering.

[Janson1]

Nu går jag i valet/kvalet vilken tråd jag skall fortsätta i, traktortråden eller i ECU, programmeringstråden? Jag väljer nog att fortsätta här... Jag har en idé om interrupt som jag nu försöker plantera in i befintligt ECU-program. Då jag har mycket annat just nu så tar det nog sin lilla tid men jag vill försöka själv tills jag antingen lyckas eller kör i botten... Tanken är att först byta ut pulseIn() mot Micros() en tidsmarkör på en tallinje. Nästa nöt blir insprutningens början, varaktighet och slut, där har jag också en idé om att byta ut alla delaymillis&delaymicros mot en liknande Micros() tidsmarkör på samma tallinje.
Jag får nog klura på detta, jag har som sagt en flyktig tanke där, gäller bara att få ner den i datorn...

[Janson1]

Nu har jag tagit bort pulseIn() och ersatt det med en interruptdriven funktion rakt av i gammal befintlig kod och det funkar... Rent tekniskt så borde det inte fungera med att ha delay miilsekunder och delay mikrosekunder kvar men det gör det?

Kod: Markera allt

    // Nu helt ny med Interrupt på vevpin (2) 2019-05-13 och ej inlagd                                                                 
    // 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
    // Ändrad till att starta insprutningsmodulen på tand 16 (case 16)                                  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
    // En styrning för yttre kylfläkt fixad, styrs nu av gasens börvärde   NYTT                         Fungerar
    // En aktiv/passiv funktion för elfläkten inlaggd, följer ECU aktiv/passiv                          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
    // Funnit ut att det är totaltid som begränsar, ändrat från 11 till 12...
    // Pga av interrupt så måste alla durationstider inom tandräkning dubbleras, eller??
//-------------------------------Här börjar programmet---------------------------------------------------------------------------------------------------------------------------------   
            // här är olika justerbara parametrar (Konstanter) som påverkar enligt följande:
    const byte totaltid =12;            // totaltid för case 15: x * motorns duration * 2 (10)tand 15-22 = max 14 totalt
    const int minfart = 3800;           // lägsta startvarv för spridarfunktion (3800 = 131 RPM)
    const byte startmangd = 26;         // avgör max startmängd 16  ca 19 grader ontid (16) mellan 131 till 200 RPM (absolut första början)
    const int faktor = 2000;            // en hur mycket effektökning skall gälla vid gaspådrag.(1100)ändrad till 1400 till 2000
    const int lagmangd = 5;             // max lågvarvsmängd 2 = 1 vevaxelpuls = 6 grader ontid (under tomgångsvarv)(2) 200 till 450 RPM (mjukstartsmängd)max 5 pga 16383 uS!!!
    const int tid1 = 5000;              // tid 1 är för att hitta pulsluckan vid start/lågvarv < 300 RPM (2500)                           
    const int tid2 = 3000;              // tid 2 är för att hitta pulsluckan i mellanvarv 1100--> (1500)
    const int tid3 = 1600;              // tid 3 är för att hitta pulsluckan i alla andra förekommande varv 1100--> (900)
    const int tid4 = 180;               // tid 4 är för att hitta pulsluckan på högsta varvtal (90)
    const float senasteinsprdrift = 8.5;// Vid tomgång/drift ges en ny "senasteinsprutningstid" som behålls sedan. (högre tal ger senare tändning)
    const byte tidigasteinspr = 80;     // kortaste insprutningsfördröjning vid maxvarv, högre tal ger tidigare tändning(110)(max 255)
    const float korrfaktor = 1.3;       // korrektionsfaktor för att senare lägga insprutningsbörjan till högre varv
    const float minstaAggrFaktor = 2.5; // gasrespons, den minsta förekommande (2.5)
    const int sprtroghet = 400;         // ett grundvärde för spridarnas påslagsfördröjning i uS (400)                     
    const int sprdiff1 = 0;             // en ev tidigareläggning av spridare 1 om den avviker i startfördröjning (uS)
    const int sprdiff2 = 0;             // en ev tidigareläggning av spridare 2 om den avviker i startfördröjning (uS)
    const int sprdiff3 = 0;             // en ev tidigareläggning av spridare 3 om den avviker i startfördröjning (uS)
    const int sprdiff4 = 0;             // en ev tidigareläggning av spridare 4 om den avviker i startfördröjning (uS)                                 
    const int omslagstartdrift = 1200;  // Bestämmer när mjukstarten går ur (omslagspunkt) (900 = brytvarv 450 RPM) skall vara 1200!!
    const int omslagmillimicro= 2500;   // omslag från milli till micro i case 16 (vid startvarv ca 200 RPM, baseras på mduration i us)2500
    const byte utanvarde = 25;          // om delta under vist värde utanvärde, nollas
    const byte gaspotmin = 20;          // gaspotens minsta tillåtna värde
    const byte gaspotmax = 210;         // gaspotens största tillåtna värde
    const int lagstavarv = 545;         // tomgångsvarvet 500 uS motsvarar ca 800 Rpm (545)(550)
    const byte hogstavarv = 110;         // fullgasvarvet 90 uS motsvarar ca 4000 RPM  (90) (112)

                // dom olika variablerna
    float senasteinspr = 2.5;         // senaste insprutningstid (vid start upp till tomgång)(6.0 = 3 vevaxelpulser = 18 grader delaytid(2.0) Tomgångsförtändning.
    int fasttid = 100;                // Fasttid = börjar alltid på 300 för att sedan ställa in mer rätt (tid1 till tid4)
    int battVolt = 400;               // mäter systemspänning till spridare grundsatt till 400 för att snabba på start
    int sprstartkorr = 400;           // spridarstartkorregering i uS, spänningsberoende grundsatt till 400 för att snabba på start
    byte tand = 0;                    // vevpin räknare 0 till 28, i alla fall till 26
    byte visare = 0 ;                 // pekare för att välja rätt spridarutgång, startar på 0
    byte grundfart = 50;              // Elfläktens lägsta fart
    int flaktfart = 255;              // max  elfläktsfart (max 255!!)
    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, delta, delta2;   // senaste, föregående och delta (totalöppningstid) i uS(mS) och en delta2 vd 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
    byte gas;                         // gas 0-255
    int fart_flakt;                   // gas för elfläkten
    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)
    volatile unsigned long VEVTAND_langd;
    volatile unsigned long VEVTAND_start;
    unsigned long prev_langd;
    volatile int caseRead;
   
                 // Dom olika I/O anslutningarna
    int vevpin = 2;                   // pulsingång vevaxelgivare, (aktivt låg).
    int kampin = 3;                   // kamaxelgivarens ingång, (aktivt hög).
    int pulsutpin = 7;                // pulsutgång 2 pulser per varv (kontrollutgång för övervakningen).
    int sprpins [] ={11,10,9,8};      // 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 elflakt = 6;                  // PWM-utgång till motorns elkylfläkt (måste ha ett tildetecken)
   
 void setup()                         // körs bara en gång vid uppstart/reset                   
 {               // här ges alla I/O dess funktion   
   pinMode(vevpin, INPUT_PULLUP);     // satt vevpin som ingång (2)
   attachInterrupt(digitalPinToInterrupt(vevpin), VEV_pulse, RISING);      // här blir inpin interruptstyrd                     
   pinMode(kampin, INPUT);            // satt kampin som ingång (3)
   pinMode(sprpins[visare], OUTPUT);  // spridarutgångar satta som arrey (11,10,9,8)
   pinMode(sprControl, OUTPUT);       // en spridarutgå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 (12)
   pinMode(pulsutpin, OUTPUT);        // satt pulsutpin som utgång (2 pulser per varv)(7)(övervakningen)
   pinMode(elflakt, OUTPUT);          // satt som utgång
   //Serial.begin(250000);            // bra att ha...
 }

//----------------------------------------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) (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 16!
                                   
                                 
     if (digitalRead(Disable)==LOW)     // Disable låg stänger av ECU:n och gör den passiv
      { 
      delta = 0;                        // Genom att delta (insprutningstid) förblir 0.
      pinMode(sprpins[visare], 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(elflakt, INPUT);          // gör om elfläktsutgången till ingång för att ej belasta
      }
     
     else //*
      {
      pinMode(sprpins[visare], 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(elflakt, OUTPUT);         // Vid aktiv så gäller elfläksutgången som utgång igen
      }                            //*Detta är normalläget, samma som i setup*
     

 
     if (digitalRead(kampin)== HIGH)   // varje gång kamaxelns hempuls detekteras så resetas 4 räknaren
      {
      visare = 0;                      // resetas till 0. dvs cylinder 4 blir aktiv
      }

     // Serial.print(bduration);
     // Serial.print("  ");
     // Serial.println(mduration);
     
      if(caseRead == 1)
  {
    caseRead = 0;
    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 (visare == 0)                           // om spridarpekaren pekar på 0 (ben D11)
           {
           spridardiff = sprdiff4;                   // skall det individuella värdet för spridare 4 hämtas
           }

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

          if (visare == 2)                           // om osv... upp till 3 (fjärde spridaren)
           {
           spridardiff = sprdiff1;                   // ben D9
           }

          if (visare == 3)
           {
           spridardiff = sprdiff3;                 // ben D8
           }
     break;
     
     case 1:               // Detta case ger första pulstid
          delvalue = VEVTAND_langd;            // Första pulstid läggs in som deltid 1
     break;
     
     
     case 2:              // Detta case ger andra pulstid + batterispänningskontroll
          delvalue = VEVTAND_langd + delvalue;                     // föregående pulstid + föregående deltid läggs ihop
          sprstartkorr =map(battVolt, 150, 700, 400, 0);  // batterispänningen blir spridartidskorrigering
          sprstartkorr = constrain(sprstartkorr,400,200); // för att hålla färdigvärdet inom 400-200 uS
     break;
     
       
     case 3:             // Detta case ger tredje pulstid
          delvalue = VEVTAND_langd + delvalue;                    // föregående pulstid + föregående deltid läggs ihop
     break;
       
                                     
     case 4:             // Detta case ger fjärde pulstid
          delvalue = VEVTAND_langd + delvalue;                    // föregående pulstid + föregående deltid läggs ihop
     break; 
                             
       
     case 5:             // Detta case ger femte pulstid
          delvalue = VEVTAND_langd + delvalue;                   // föregående pulstid + föregående deltid läggs ihop
     break;
     
     
     case 6:              // Detta case ger sexte pulstid
           delvalue = VEVTAND_langd + delvalue;                   // föregående pulstid + föregående deltid läggs ihop
     break;
             
       
     case 7:             // Detta case ger sjunde pulstid     
           delvalue = VEVTAND_langd + delvalue;                   // föregående pulstid + föregående deltid läggs ihop
     break;
     
       
     case 8:             // Detta case ger motorns börvärde från gaspoten som blir lägsta och högsta varvtal
                         // och åttonde pulstid
           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
           delvalue = VEVTAND_langd + delvalue;                  // föregående pulstid + föregående deltid läggs ihop
     break;
   
       
     case 9:            // Detta case ger nionde pulstid
           delvalue = VEVTAND_langd + delvalue;                 // föregående pulstid + föregående deltid läggs ihop
     break;
     
       
     case 10:          // Detta case räknar ut tidsdiff per spridare plus systemspänningsdiff
       sprtroghetklar = sprtroghet + spridardiff - sprstartkorr;          // spridartröghet klart värde räknas ut här
                       // och ger motorns verkliga fart baserat på dom 11 första tänderna
       delvalue = VEVTAND_langd + delvalue;                                        // föregående pulstid + föregående deltid läggs ihop           
       mduration = delvalue/12;                                           // Motorns totala pulstid i mikrosek dividerat med 14 ger motorns duration vid drift (12 nu på prov)     
                      // och räknar ut skillnaden mellan är och börvärde - 1 = error
          error = (mduration / bduration)-1;
       if (error <=0.)                                                    // om error hamnar under noll
        {
         error = 0.;                                                      // förblir error 0 för att ej få minusvärden
        }
                 // här testas fasttid ut genom att gämföra vilken mduration som passar bäst.
          fasttid = (mduration < 1000) ? tid4 : (( mduration < 2400) ? tid3 : (( mduration < 3600 ) ? tid2 : tid1));  // nu dubblerat
     break;          // felet i uS mellan är och börvärde för motorns duration (varvtal)
                       
   
     case 11:        // Detta case för insprutningsfördröjning i gånger, ställs högst upp               
       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å
        }
     break;
     
 
     case 12:       // Detta case ger förtändningen
        ondelay = (mduration * starttandf);                                 // tillslagsfördröjning = motorns duration * starttandsfördröjning (decimaltal)
                                                                            // Ondelay uS = mduration uS * starttandf i decimalform
       if((mduration > omslagstartdrift) && (mduration < omslagmillimicro)) // delta2 skall vara aktiv mellan 2500 us ner till 1200 uS
         {
          delta2 = lagmangd * mduration;                                                                             
         }
       else
         {
          delta2 = 0;
         } 
     break;       
     
     case 13:               // Här räknas effektregleringen ut genom hela registret från 450 rpm och uppåt
     if(mduration <=omslagstartdrift)                                      // Om/när motorn går över 450 rpm
     {
      aggrfaktor = faktor/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
     }       
     break;

     case 14:            // 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 15:   // 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
         {
         // Annars förtändning start                                        // läser av A1 motortemp
         }
     break;
 //------------------------------------------------------------------------------------- case 16, insprutningsfasen-----------------------------------------------------------------   
     case 16:    // 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) 2500 = 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 
           {
           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[visare],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[visare],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.
       }         // Detta paket används vid låga farter såsom start/lågvarv < 203 RPM
     //---------------------------------------------------------------------------------------------------------------------------- 
    else        // Eller om mduration är mindre än 2500 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 200-500 uS)som tröghetskompensation
          }
          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[visare],HIGH);  // Insprutning börjar. spridare x strömsätts [visare 11,10,9 eller 8].
          digitalWrite(sprControl, HIGH);       // Kontrollpinne som blir hög vid varje insprutningstillfälle.
          delayMicroseconds(delta);             // Här läggs insprutningstiden in som sen fördröjer processorn i delta uS
          delayMicroseconds(delta2);            // Här läggs en extra insprutningstid in som bara gäller mellan 203-450 rpm
          digitalWrite (sprpins[visare],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.
       }                                //Detta paket används vid varv (203 -> RPM = nästan alltid, förutom vid motorstart)
     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 26:                                 // ä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:
           battVolt = analogRead(A7);         // analogingång som läser ECU:ns systemspänning
           // tom
        break;

        case 2:
           gas = analogRead(A0)>>2;           // analogingång för gasreglage 0 till 255( skiftad 2 gånger)
           // tom                             
        break;
       
        case 3:
            fart_flakt = analogRead(A0)>>2;    // analogingång för gasreglagefläkt 0 till 255( skiftad 2 gånger)
            fart_flakt = fart_flakt + grundfart;// Här läggs en grundfart till för att säkerställa fläktfunktion lågfart.
        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
     if(fart_flakt >= flaktfart)           // om gasfläktens fart ät mer än 255
         {
          fart_flakt = flaktfart;              // så förblir gasfläkt max 255
         }
         analogWrite(elflakt,fart_flakt );     // pulsbreddsmodulerar ut fläktfart mellan grundfart och maxfart (980 hz PWM)
  }
 //-------------------------------------- Nedan är för att leta upp tandluckan, räkna upp tandräknaren,reseta tandräknaren, bestämma motorns duration (varvtal)--------------------------
           
     
 }
  void VEV_pulse()                          //
 {
  long thisLength = micros();
  caseRead = 1;
  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
   //Serial.println(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
    tand = 0;                                   // och tandräknaren resetas till 0 (början på tandräkningen)
    visare ++;
     if (visare > 3)                            // när fjärde pinnen är nådd börjar den om igen
         {
         visare = 0;                            // spridarpinne 0 är igång igen (0 = D11)
         }         // 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-----------------------------------------------------------------------------------------------------------------------       
                                               

Ja, ni som kan programmering får nog kolla upp varför detta funkar överhuvudtaget...

[Towil]

interrup struntar i om MCU är i ett delay() den bryter där den är och kör koden i rutinen.

Även om det fungerar så har du av princip lite för mycket kod i intrerrupt delen.
Det du behöver är thisLength = micros(); och en flagga att nu har du en ny tid att beräkna ifrån. Resten av koden lägger du i huvudloopen.

[jpd]

@Towil: i det här fallet hade jag nog lagt lite mer i interruptrutinen. Så här:

I den vanliga koden: beräkna när spridare skall öppnas och stängas. Dvs vid vilken tandlucka och eventuellt var inom tandluckan. Här görs allt smart med kompenseringar för lufttryck, temperaturer och gud vet allt. Här finns inget tidskritiskt alls.

I interruptrutinen: 1) räkna upp tandräknaren och 2) om det är dags (rätt tand enligt ovan) att öppna eller stänga spridare faktiskt göra det.

Annars blir det svårt att få till precision i spridartiderna

[jpd]

@Jansson en snabb koll på koden får mig att TRO att det är så här:

Du har kvar all logik som bygger på att göra de olika beräkningarna i respektive tidslucka, samtidigt som du lagt till en interruptrutin. Det fungerar ändå eftersom din gamla logik fortfarande funkar trots tillagd interrupt.

Den stora vitsen med interrupt är att du kommer att kunna sluta bry dig om vevaxelns läge i huvudloopen. Dvs alla rader med "case + break" blir överflödiga.

[tortap]

Kolla in case 18:

Kod: Markera allt

    // Förändrad 2019-01-07 och ej inlagd
    // max ändrat till strax under 4000 rpm ua. Tändläget verkar ua ochså.
    // nu läser den av alla analogread i följd om 2 och 2 = fungerar
    // batterispänningens inverkan grovjusterad = 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.
   
            // här är olika justerbara parametrar som påverkar enligt följande:
    const byte totaltid =13;            // totaltid för case 15: x * motorns duration (10)
    const int lagstavarv = 480;         // tomgångsvarvet 500 uS motsvarar ca 800 Rpm (530)
    byte hogstavarv = 120;               // fullgasvarvet 100 uS motsvarar ca 4200 RPM  (90)
    const byte aggrfaktorlag = 3;       // hur mycket spridar PWM skall öka vid belastning mellanvarv (3)
    const byte aggrfaktorhog = 12;       // hur mycket spridar PWM skall öka vid belastning högvarv (7)
    const int minfart = 3800;           // lägsta startvarv för spridarfunktion (3800 = 131 RPM)
    const byte startmangd = 20;         // avgör max startmängd 16  ca 19 grader ontid (16) mellan 131 till 200 RPM (absolut första början)
    const float maxdeltalag = 3.0;      // max insprutningstid mellanvarv mdutation * 3.0 ger 1,5 vevaxelpulser = 9 gr ontid (3.0) max ontid vid 450 till 2000 RPM
    const byte lagmangd = 5;            // max lågvarvsmängd 2 = 1 vevaxelpuls = 6 grader ontid (under tomgångsvarv)(2) 200 till 450 RPM (mjukstartsmängd)
    const int tid1 = 2500;              // tid 1 är för att hitta pulsluckan vid start/lågvarv < 300 RPM (2500)                           
    const int tid2 = 1500;              // tid 2 är för att hitta pulsluckan i mellanvarv 1100--> (1500)
    const int tid3 = 800;              // tid 3 är för att hitta pulsluckan i alla andra förekommande varv 1100--> (1000)
    const int tid4 = 90;               // tid 4 är för att hitta pulsluckan på högsta varvtal (100)
    float senasteinspr = 9.0;           // senaste insprutningstid (vid start upp till tomgång)(6.0 = 3 vevaxelpulser = 18 grader delaytid(6.0) Tomgångsförtändning (högre tal ger senare tändning)
    const float senasteinsprdrift =10.5;// Vid tomgång/drift ges en ny "senasteinsprutningstid" som behålls sedan.
    const byte tidigasteinspr =110;     // kortaste insprutningsfördröjning vid maxvarv, högre tal ger tidigare tändning(110)(max 255)
    const int sprtroghet = 400;         // ett grundvärde för spridarnas påslagsfördröjning i uS. (400)                         
    const int omslagstartdrift = 900;   // Bestämmer när mjukstarten går ur (omslagspunkt) (900 = brytvarv 450 RPM)
    const int omslagmellanhogvarv = 160;// bestämmer omslaget när aggresionsfaktor mellan/hög växlar (ca 2000 RPM)
    const int omslagmillimicro= 13000;  // omslag från milli till micro i case 15 (vid startvarv ca 200 RPM, baseras på ondelay i us)
    const byte utanvarde = 25;          // om delta under vist värde utanvärde, nollas
    const byte gaspotmin = 20;          // gaspotens minsta tillåtna värde
    const byte gaspotmax = 210;         // gaspotens största tillåtna värde
   
    int vevpin = 2;                   // pulsingång vevaxelgivare.
    int kampin = 3;                   // kamaxelgivarens ingång.
    int pulsutpin = 7;                // pulsutgång 2 pulser per varv (kontrollutgång för övervakningen).
    int sprpins [] ={11,10,9,8};      // 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
    unsigned long delvalue;           // delvärde av pulstid i uS.
    unsigned int ondelay;             // tillslagsfördröjning spridare i uS/mS (mS inne i case 15)
    long puls, priv, delta;           // senaste, föregående och delta (totalöppningstid) i uS(mS)
    float error;                      // error = varvtalsfelet i decimalform
    float starttandf, finKorr;        // starttand i decimalform för att få startfördröjningstid och finkorrigering av öppninstiden +-.
    float  mduration, bduration;      // varvfelet = motorduration/börduration i decimalform
    byte tand = 0;                    // vevpin räknare 0 till 28, i alla fall till 26
    byte gas;                         // gas 0-255
    byte pekare = 0 ;                 // pekare för att välja rätt spridarutgång, startar på 0
    byte kamtand = 0;                 // Kamtand för att sluta detektera kamaxelgivaren efter x tänder (max 255), startar på 0
    int fasttid = 300;                // Fasttid = börjar alltid på 300 för att sedan ställa in mer rätt (tid1 till tid4)
    byte analogval;                   // En switch/case till analogread
    int battVolt = 400;               // mäter systemspänning till spridare grundsatt till 400 för att snabba på start
    int sprstartkorr = 400;           // spridarstartkorregering i uS, spänningsberoende grundsatt till 400 för att snabba på start
    int sprtroghetklar;               // korrektion för den inbyggda påslagströgheten i spridarna
    int spridardiff = 0;              // en ev. individuell spridartid korrigering (uS)
   

   
    void setup()                     
 {
   pinMode(vevpin, INPUT_PULLUP);     // satt vevpin som ingång (2) Testar nu med pullup...                       
   pinMode(kampin, INPUT);            // satt kampin som ingång (3)
   pinMode(sprpins[pekare], OUTPUT);  // spridarutgångar satta som arrey (11,10,9,8)
   pinMode(sprControl, OUTPUT);       // en spridarutgå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 (12)
   pinMode(pulsutpin, OUTPUT);        // satt pulsutpin som utgång (2 pulser per varv)(7)(övervakningen)
 }
    //______________________________________________________________________
    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 16!
                                   
                                 
     if (digitalRead(Disable)==LOW)     // Disable låg stänger av ECU:n och gör den passiv
      { 
      delta = 0;                        // Genom att delta (insprutningstid) förblir 0.
      pinMode(sprpins[pekare], 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
      }
     
     else
      {
      pinMode(sprpins[pekare], OUTPUT); // Vid aktiv igen så gäller spridarutgångarna som utgångar igen.
      pinMode(sprControl, OUTPUT);      // Vid aktiv så gäller spridarcontrollen som utgång igen
      }                            //*Detta är normalläget, samma som i setup*
     
        if (digitalRead(kampin)== HIGH)// 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 upp till max.
         }
       
     switch (tand)                    // här startar switch och case, tandräknaren stegar fram ett steg (case)
  {
     case 1:               // Detta case ger första pulstid
          delvalue = priv;            // Första pulstid läggs in som deltid 1
     break;
     
     case 2:              // Detta case ger andra pulstid + batterispänningskontroll
          delvalue = priv + delvalue; // föregående pulstid + föregående deltid läggs ihop
          sprstartkorr =map(battVolt, 150, 700, 0, 400); // batterispänningen blir spridartidskorrigering
          sprstartkorr = constrain(sprstartkorr,200,400);// för att hålla färdigvärdet inom 200-400
     break;
       
     case 3:             // Detta case ger tredje pulstid
          delvalue = priv + delvalue; // föregående pulstid + föregående deltid läggs ihop
     break;
       
                                     
     case 4:             // Detta case ger fjärde pulstid
          delvalue = priv + delvalue; // föregående pulstid + föregående deltid läggs ihop
     break;                         
       
     case 5:             // Detta case ger femte pulstid
          delvalue = priv + delvalue; // föregående pulstid + föregående deltid läggs ihop
     break;
     
     
     case 6:              // Detta case ger sexte pulstid
           delvalue = priv + delvalue; // föregående pulstid + föregående deltid läggs ihop
     break;         
       
     case 7:              // Detta case ger sjunde pulstid     
           delvalue = priv + delvalue; // föregående pulstid + föregående deltid läggs ihop
     break;
       
     case 8:             // Detta case ger motorns börvärde från gaspoten som blir lägsta och högsta varvtal
                         // och åttonde pulstid
           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
           delvalue = priv + delvalue;                           // föregående pulstid + föregående deltid läggs ihop
     break;
       
     case 9:            //Detta case ger nionde pulstid
           delvalue = priv + delvalue; // föregående pulstid + föregående deltid läggs ihop
     break;
     
     case 10:   // detta case räknar ut tidsdiff per spridare plus systemspänningsdiff
       sprtroghetklar = sprtroghet + spridardiff - sprstartkorr; // spridartröghet klart värde räknas ut här
                // och ger motorns verkliga fart baserat på dom 11 första tänderna
       delvalue = priv + delvalue; // föregående pulstid + föregående deltid läggs ihop           
       mduration = delvalue/13;   // Motorns totala pulstid i mikrosek dividerat med 13 ger motorns duration vid drift
     break;       

     case 11: // detta case räknar ut felet i uS mellan är och börvärde för motorns fart
               error = (mduration / bduration)-1;
       if (error <=0.)                       // om error under noll
        {
         error = 0.;                         // förblir error 0 för att ej få minusvärden
        }
     break;                   
   
     case 12:           // Detta case för insprutningsfördröjning i gånger, ställs högst upp               
       starttandf = mduration /tidigasteinspr; // starttandf, ett flyt-tal = motorns duration/ minsta duration/max RPM.
       if (starttandf >= senasteinspr)         // om fördröjning över målvärdet, som vid tex startvarv
        {                 
         starttandf = senasteinspr;            // blir det målvärdet ändå
        }
     break;

 
     case 13:                     // Detta case ger förtändningen
        ondelay = (mduration * starttandf);  // tillslagsfördröjning = motorns duration * starttandsfördröjning (decimaltal)       
     break;                                  // Ondelay uS = mduration uS * starttandf i decimalform
                                                               
     case 14:          // Detta case ger motorns karaktärstik på arbetsvarv       Mellan 160 uS och 900 uS
     if ((mduration >=omslagmellanhogvarv)||(mduration <=omslagstartdrift))  // från ca 450 RPM och upp till ca 2000 RPM (mer än 160 men mindre än 900
      {                                            // Felkorrigeringsvärde som ger spridaröppningstid i uS
       delta = mduration * error * aggrfaktorlag;  // aggrfaktor låg avgör hur mycket extra ontid spridarna får vid belastning lägre varv
        if (delta >= maxdeltalag * mduration)      // om delta är mer än max tillåten delta x mduration
         {
          delta = maxdeltalag * mduration;         // förblir delta max tillåten
         }                     
      }
     if (mduration < omslagmellanhogvarv)                        // "högvarv" 160 uS
      {
       delta = mduration * error * aggrfaktorhog; // Felkorrigeringsvärde som ger spridaröppningstid i uS
      }                                           // aggrfaktor hög avgör hur mycket extra on tid spridarna får vid belastning högre varv
     break;
     

     case 15:         // Detta case ger mjukstarten
   
     if (mduration >= omslagstartdrift)          // Vid lite över startfart  mellan 200 RPM till ca 450 RPM 900uS
      {
       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 bara på högvarv, hög belastning
     break;
     
     
     case 16:    // Detta case är insprutningsfasen "spridar-on-off-mode"
     if (ondelay >=omslagmillimicro)          // Om ondelay är mer än 13000 uS. (från 131 till 203 RPM räknas alla spridarvärden i mS)13000 = 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 
        {
         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[pekare],HIGH);  // Spridarpinne hög,insprutning börjar. spridare x strömsätts [pekare 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[pekare],LOW);   // Spridarpinne låg,insprutning avslutad spridare x stängs av  [pekare 8,9,10 eller 11].
        digitalWrite (sprControl, LOW);       // Kontrollpinne som går tillbaka till låg efter varje insprutningstillfälle.
       }                        // Detta paket används vid låga farter såsom start/lågvarv < 203 RPM
     
     else                                     // Eller om delay är mindre än 13000 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 200-500 uS)som tröghetskompensation
        }
        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[pekare],HIGH);  // Insprutning börjar. spridare x strömsätts [pekare 11,10,9 eller 8].
        digitalWrite(sprControl, HIGH);       // Kontrollpinne som blir 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 spridare x stängs av [pekare 8,9,10 eller 11]
        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)
     break;              //Dessa paket tar 1 till 6 tänder att genomföra beroende på varvtal och belastning

     case 17:
         if (mduration < omslagstartdrift)
          {
           senasteinspr = senasteinsprdrift;
          }
        else
        {
         
        }
     break;
       
     case 18:                       // ä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)
        break; 

        case 1:
           battVolt = analogRead(A7);          // skall vara A7!!
        break;

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

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

        case 5:
           // 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
  }
     //______________________________________________________________________________________________________   
        tand  ++ ;                                  // räkna upp ett steg för varje ny puls, kommer via pulseIn()funkt.
        priv = puls;                                // lägger in den förra pulstiden i värdet "priv" (uS)
       
      if (mduration >1800)                          // när motorn går på allra lägsta varv (start)
       {
        fasttid = tid1;                             // används tid1
       }
       
      if ((mduration > 1200)|| (mduration < 1800)) // om motorn går lite mer än startvarv
       {
        fasttid = tid2;                            // används tid2
       }
       
      if ((mduration > 500)||(mduration < 1200))  // Om motorn går under 1100 RPM
       {
       fasttid = tid3;                            // används tid3
       }
       
      if (mduration <500)                        // Om motorn går över 1100 RPM
       {
       fasttid = tid4;                           // används tid4 (dom flesta driftvarv)
       }
       
        puls = pulseIn(vevpin, LOW, 30000);   // Detta kommando väntar in nästa puls (tand = case).
                                              // vid stillastående motor blir det en timeout
                                              // efter 0,03 Sek
         
      if  (puls > priv + fasttid)             // jämför om ny pulstid i uS är större än föregående + fasttid.
       {
        digitalWrite (pulsutpin, HIGH);       // utpin blir hög när pulsluckan återgår till pulser
         
    tand = 0;         // resetar 0 till 28 räknaren som har hunnit räkna mellan 16 och 27 tänder

    pekare ++;                                //  och 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 (1 = D11)
    }         // Denna if-sats är bara sann varje halv-varv vid luckan
  }
                       
       if  (puls < priv - fasttid)            // jämför on ny pulstid är mindre än förgående - fasttid.     
         {   
         digitalWrite (pulsutpin, LOW);       // utpin blir låg igen nästa uppgång i pulståget.
         }
 }       
       
                                              // end void loop()
 

Det här kanske inte längre är aktuellt men varför behöver du flyttalen där?

float error; // error = varvtalsfelet i decimalform
float starttandf, finKorr; // starttand i decimalform för att få startfördröjningstid och finkorrigering av öppninstiden +-.
float mduration, bduration;

Skulle du istället kunna räkna med heltal * 1000 exempelvis? Eller vilken precision du nu behöver.

[Janson1]

tortap: Nu är detta den "gamla" filen utan interrut men med pulseIn() istället. Egentligen vill jag inte ändra något fundamentalt mer utan bara finjusteringar som görs längst upp i programmet. Sen är det väl inte case 18 som avses utan betydligt tidigare i koden.

[Janson1]

Ja nu är det testat med oscilloskopet och den går verkligen rätt. Men för att jag skulle få allting exakt lika i tider hit och dit vid insprutning har jag fått dubblera alla microsekunder som ligger inom bör-duration och motor-duration. Den här pulseIn() ger ju bara halva tiden per tand (från låg till hög eller tvärtom) medans interruptrutinen ger hela tandens tid (från låg till låg nästa gång, eller tvärt om). Jag tycker att hela pulståget är lite stabilare på speciellt dom högre varvtalen. Men den stora (största) fördelen blir ju att när jag får en motor med nya typen av tandhjul 60 tänder minus 2 då funkar denna koden vidare med bara lite förändringar och får jag tag på en 3 eller 5-6 cylindrig så kommer dennna kod att fixa detta med väldigt lite förändringar, nu kan jag lägga insprutningsmodelen (case 16) var jag vill och ändå fortsätta hålla reda på motorns exakta tandnummer. Nästa grej blir nu att testa på traktorn... I dag kör jag ju "död räkning" efter det att insprutningsmodulen är aktiverad och efter det så är ju tandräkningen fel och blir i ordning vid luckan igen. Nu blir det kul att se om min död räkning är lika som den nu blivande exakta räkningen av tänder. Sen om nu detta funkar så finns det väl egentligen ingen anledning att ta bort switch/case, detta är ju en för mig känd struktur. Likaså dom olika delayerna verkar inte helller störa?

[Janson1]

Marcus.bonde: i ditt inlägg #523 så gjorde du en mer effektiv och fungerande kod för att bestämma vilken referenstid ECU:n skall välja med hänsyn till varvtalet. Där har du med skrivit: ""Vilket inte blir exakt lika matematiskt, men det skiljer ju bara på ±1 i gränsvärdena så det kanske är godtagbart."" Jag tror det är nåt problem med just detta... Den tappar trigposition på några exakta varvtal, jag tror det hamnar lite mellan stolarna där men kan egentligen inte komma på vad som exakt går fel... Det konstigaste är att insprutningsläget påverkas inte av att referenssignalen saknas, den behåller sitt fasläge ändå.

[Janson1]

Testat i traktorn och den går precis som innan, nästan. Det är väl nåt värde jag glömt att dubblera/halvera men annars ingen skillnad. Nu är det väl dags att bygga om även min av JPD-konstruerade motorsimulator till ett annat tandhjulsutsignal 60-2.

[Janson1]

Först byggde jag om JPD- simulatorn till att lämna vevaxelpulser 60-2 och en kamaxelpuls varannan gång när fjärde vevaxelpulsen kommer.
Sen la jag helt enkelt till ett nytt case 44 och nu har jag möjlighet till två insprutningar per reset av 60-2 räknaren och sen var det bara att flytta spridaruppräknaren till insprutningsmodulen och jag tror faktiskt detta kommer att funka i dom nyare typerna av motorer nu. Oavsett 3,4,5 eller 6 cylindrar så blir det "bara" att räkna ut och lägga till lite logik. Nästa grej att mickla med blir väl att försöka göra programmet så att man kan behålla alla 7 tänderna på kamaxeln och kanske tom. räkna på dom om vevaxelgivaren skulle lämna in??

[marcus.bonde]

Marcus.bonde: i ditt inlägg #523 så gjorde du en mer effektiv och fungerande kod för att bestämma vilken referenstid ECU:n skall välja med hänsyn till varvtalet. Där har du med skrivit: ""Vilket inte blir exakt lika matematiskt, men det skiljer ju bara på ±1 i gränsvärdena så det kanske är godtagbart."" Jag tror det är nåt problem med just detta... Den tappar trigposition på några exakta varvtal, jag tror det hamnar lite mellan stolarna där men kan egentligen inte komma på vad som exakt går fel... Det konstigaste är att insprutningsläget påverkas inte av att referenssignalen saknas, den behåller sitt fasläge ändå.

Nja, skillnaden (om jag minns rätt) är att du hade ett uttryck i stil med: if (mduration <= 1000) { ...}; och jag ändrade till (mduration < 1000) i mitt utttryck, vilket praktiskt gör att i ditt fall skulle if-satsen bli sann om mduration är mindre än eller lika med 1000, medan i mitt uttryck så blir den sann då mduration är lika med eller mindre än 999, dvs mindre än 1000.

Vart det där förståeligt?

[Janson1]

Ja, det är förståeligt. Nåt fel är det då min utsignal saknas på fyra ganska bestämda lägen men eftersom det verkar sakna betydelse så får det bero tills vidare. Vid tillfälle (om det blir/behövs) får jag väl fördjupa mig i detta. Som det är just nu så finns det bättre saker at lägga krut på...

[Janson1]

I dag efter jobbet gjorde jag om och dubbelkollade alla värden så dom blev dubbelt/hälften så långa som dom va förut och nu går traktorn exakt lika oberoende på om man kör med eller utan interrupt, jag kan växla i farten mellan ECU-A (interrupt) och ECU-B (det gamla "vanliga" programmet) och jag hör/känner/ser/luktar ingen skillnad i gång uppför som nerför...