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

[AN]

PID är något jag skulle vilja förstå.
Prövat läsa på lie, och även sett litefilmklipp.
Men polletten faller inte helt ned.
Finns någon bra bok, eller youtube kurs, för nybörjare?
En varvtalsregulator i en gammal dieselpump, som med hjälp av vikter, minskar bränslet vid ökat varvtal, är det då en p regulator?
Är maxvarvtalet 3000 rpm, börjar den ju ge mindre bränsle flera hundra varv tidigare, och effekten mattas av.
Om man haft en PI regulator, hade den reglerat snabbare då, så att vi kunnat använda effekten ända upp till maxvarvtal?

[Towil]

[torbjorn_forsman]

Om man ser historiskt på det hela, så var ju de första varvtalsregulatorerna som användes till ångmaskiner, vattenturbiner mm rena P-regulatorer. Men man upptäckte så småningom att den regleravvikelse som alltid finns hos en P-regulator inte alltid är så bra att ha där. Om man försökte öka förstärkningen i regulatorn för att minska avvikelsen så kunde hela reglersystemet börja självsvänga, i viss mån kunde man lösa det problemet med flera ton tunga svänghjul.
Sedan kom någon på att man kunde komplettera den enkla P-regulatorn med en långsam "efterreglering", och vips hade man en PI-regulator. I rent mekaniska regulatorer fanns det alla möjliga konstiga lösningar för efterregleringen, allt från oljefyllda dämpare till anordningar med friktionshjul och gängade stänger.
I och med att man började använda PI-regulatorer för vattenturbiner i kraftverk (kanske omkring 1910?) , kunde man få regleringen så pass stabil att det var möjligt att samköra flera kraftverk med varandra och få ett sammankopplat elnät över ett helt land.
D:et i PID, alltså den deriverande funktionen, är något som har kommit till för att få regulatorn att reagera snabbare på plötsliga belastningsändringar men ändå ha god marginal till självsvängning.

[Janson1]

Det är väl lite så att jag är nu i princip på mållinjen med detta projekt och dess ECU/reglering. Det blir nu bara fintrimning av befintligt program (jag har en driva parametrar att jiddra med...) Men nästa program, den skall ha interrupt och PI eller PID reglering. Jag har bla en "faktor" som reglerar hur mycket den skall gasa vid pådrag, den arbetar jag med just nu, ändrar lite, provar lite i våran kyrkbacke, ändrar lite igen osv...

[marcus.bonde]

Har snott ihop något som bör funka som en PID-regulator... Den jobbar med vilkorsstyrd integrering för det har jag läst mig till att det är bra om bara de kontrollvärden (cv) tas med som är inom rätt intervall... Nåväl, länge sen jag knackade C++, men kul var det. Någon som är intresserad får gärna leta på alla mina tankevurpor

Kod: Markera allt

#ifndef _PID_H_
#define _PID_H_

struct Constants
{
   double   kp,         // Proportionell förstärkning
         ki,         // Konstant för integrering
         kd,         // Konstant för derivering
         st,         // Samplingstid
         ti,         // Integrationstid
         td,         // Derivatatid
         max, min;   // Max och min-värden för utsignal
};
struct Variables
{
   double   cv,            // Senaste process-värdet
         error,         // "Senaste" avvikelsen mellan är- och börvärde
         integral;      // Ackumelerad integral-del
};

class PID
{
public:
   PID(double _kp, double _ki, double _kd, double _ti, double _td, double _st, double _max, double _min);
   
   // Beräknar och returnerar det nya reglervärdet baserat på börvärdet (set point)
   // Returnerar Control Value - CV - utsignal.
   // Parametrar: Set Point sp - börvärde, process value pv - feedback från "processen"
   double calc(double sp, double pv);
   
   // Returnerar avvikelsen mellan är- och börvärde vid senaste beräkningen
   double error(void);
   
   // Returnerar senaste feedback
   double controlValue(void);
   
   // Förändrar max & min i efterhand
   void setMinMax(double min, double max);
   
   ~PID(void);
   
private:
   Constants *consts;
   Variables *vars;
};

#endif

Kod: Markera allt

#ifndef _PID_CPP_
#define _PID_CPP_

#include <math.h>
#include "pid.h"

PID::PID(double _kp, double _ki, double _kd, double _ti, double _td, double _st, double _max, double _min)
{
   consts = new Constants;
   consts->kp = _kp;
   consts->ki = _ki;
   consts->kd = _kd;
   consts->st = _st;
   consts->ti = _ti;
   consts->td = _td;
   consts->max = _max;
   consts->min = _min;
   
   vars = new Variables;
   vars->error = vars->integral = vars->cv = 0.0;
};

double PID::calc(double sp, double pv)
{
   // Beräkna fel
   double error = sp - pv;   
   
   // Proportionell reglering (error * Kp)
   double prop = error * consts->kp;
      
   // Derivatan
   double derivative = consts->td * consts->kd * (error - vars->error) / consts->st;
      
   // Total utsignal (PID)   
   double _cv = vars->cv = prop + vars->integral + derivative;
         
   // Begränsa utsignalen till min/max
   if (vars->cv > consts->max)
      vars->cv = consts->max;
   else if (vars->cv < consts->min)
      vars->cv = consts->min;
   
   // Villkorlig integrering (enbart om cv låg innanför min-max)
   if (_cv == vars->cv)
      vars->integral += consts->ki * consts->st / consts->td * error;
      
   // Spara felet för nästa beräkning
   vars->error = error;
   
   return vars->cv;
};

double PID::error(void)
{
   return vars->error;
};

double PID::controlValue(void)
{
   return vars->cv;
}

void PID::setMinMax(double min, double max)
{
   consts->min = min;
   consts->max = max;
}

PID::~PID()
{
   delete vars;
   delete consts;
};

#endif

Och sist och faktiskt också minst, en snutt för att provköra... Väldigt känsligt på konstanter och tider, kan jag säga...

Kod: Markera allt

#include "pid.h"
#include <stdio.h>

#define KP 0.3
#define KI 0.3
#define KD 0.3
#define ST 0.9
#define TI 1.3
#define TD 2.4
#define MIN -100.0
#define MAX 100.0
#define STARTVAL 20.0
#define SETPOINT 0.0

int main(void)
{
   PID pid (KP, KI, KD, TI, TD, ST, MAX, MIN);
   
   double inc, cv = STARTVAL;
   
   for (int i; i < 100; i++) {
      inc = pid.calc(SETPOINT, cv);
      printf("cv:% 7.3f inc:% 7.3f\n", cv, inc);
      cv += inc;
   }
   return 0;
}

[Janson1]

Om detta är tänkt till min ECU så fattar jag nog nada…

[marcus.bonde]

Nja, det är tänkt som en tankelek, som nog bör anpassas efter din ECU...

[Janson1]

Jag sitter just nu och klurar/funderar på min reglering som jag har i dag. Jag gör just nu lite beräkning på vilken ontid spridarna bör ha vid olika under/övervarv och olika gaspådrag. Enligt mina beräkningar skall den ge mer vid samma varvtal ju mer jag gasar. Men i verkligheten går nog nåt fel där för vid lite över tomgång, högsta växeln och en rejäl backe så ökar den inte alls i varv under ett visst varvtal, jag gissar på runt 6-700 rpm? Det blir nog att sätta sig ner på kammaren och labba fram dels vad som går fel och dels en lösning!

[marcus.bonde]

Mmmm, det är nog där en PID-regulator kanske hade varit användbar. Den proportionala delen ska ju styra efter varvtalet, Integraldelen ska ju kompensera för statiska fel (P-delen kommer aldrig att kunna styra ut till 100% om den inte ska riskera självsvängning med för hög förstärkning). Och derivatan ska försöka förutsäga vart reglerfelet för de andra är på väg åt för håll.

Den jag lade upp i tråden är mest för att jag själv skulle få en känsla för hur en regulator funkar, jag tar bort den om du vill.
Oavsett så är det inta bara att "kasta in" den i ditt program och det kommer att funka rakt av. Det kommer behövas mycket anpassning. Dessutom så är det oerhört lätt att den "går i taket" eller självsvänger om man väljer fel värden på konstanterna. Jag tror att det behövs mycket labbande för att hamna rätt..

[Janson1]

Du får inte ta bort det inlägget bara för att jag inte förstår... Men gärna ett förtydligande del för del så jag kan tänka mig in i hur det bör se ut i min ECU. I dag ligger regleringen lite här och var i mitt program, jag läser börvärde i sista case, tar in ärvärde i flera case (8-10 st). Gör om värden i flera andra case osv. Vad jag förstår så har jag en bra bit av det som behövs redan, P och I finns ju redan. Det är nog bara en förfining av regleringen som behövs. Jag har i dag inga insvängningsproblem och har faktiskt aldrig haft heller. Mycket tror jag beror på motorn själv, när dieseln stryps så stannar den direkt, skjuter aldrig över nåt målvarv. Sen har jag sk underreglering dvs, för att få error 0 så måste motorn motorbromsa i en nerförbacke. Normalt sett så har jag alltid lite error vid målvarvet.

[Janson1]

Jag hade lite labb tid i dag och fann "felet". Jag har från början bestämt ett "fönster" där insprutningen skall ske. Fönstret börjar ca 40 grader FÖDP och slutar nån grad innan FÖDP. Då jag haft lite knackproblem vid gaspådrag lägsta varvtal, hög belastning så har jag "sänkt" tändningen, dvs insprutningsbörjan så den börjar spruta in soppa lite senare. Detta har till sist resulterat att jag har hamnat så nära slutet på möjlig insprutningsvinkel att ECU:n stängt av insprutningen på eget bevåg när FÖDP närmat sig. Nu har jag justerat ut "fönstret" så att man kan spruta in soppa på ÖDP och lite efter och vips kommer krämen tillbaka på dom lägsta varven med. Så det är inte alltid själva PI-regleringen som felar, det är ett komplext system med många parametrar som kan ställa till det...

[Janson1]

Ja, senaste koden för den som är intresserad.

Kod: Markera allt

    // Förändrad 2019-05-04 och 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...
//-------------------------------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 = 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--> (900)
    const int tid4 = 90;                // 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 = 3.0;         // senaste insprutningstid (vid start upp till tomgång)(6.0 = 3 vevaxelpulser = 18 grader delaytid(2.0) Tomgångsförtändning.
    int fasttid = 300;                // 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)
   
                 // 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) Testar nu med pullup...                       
   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
      }
     
       
     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 = 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, 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 = 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/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
        }
     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 17:                                 // ä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
 
 
 //-------------------------------------- Nedan är för att leta upp tandluckan, räkna upp tandräknaren,reseta tandräknaren, bestämma motorns duration (varvtal)--------------------------
    tand  ++ ;                                  // räkna upp ett steg för varje ny tand, kommer via pulseIn()funktionen.
    priv = puls;                                // lägger in den förra pulstiden i värdet "priv" (uS)

             // här testas fasttid ut genom att gämföra vilken mduration som passar bäst.
    fasttid = (mduration < 500) ? tid4 : (( mduration < 1200) ? tid3 : (( mduration < 1800 ) ? tid2 : tid1));   
     
      puls = pulseIn(vevpin, LOW, 30000);     // Detta kommando väntar in nästa puls (tand = case).  ----|___|--- = LOW skall vara LOW med kanal B på ny givaren
                                              // 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
        visare ++;                            //  och räknar upp spridarpinnepekar-räknare

        if (visare > 3)                       // när fjärde pinnen är nådd börjar den om igen
         {
         visare = 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.
         }
         
         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)
 }       
//-------------------------------------------------slut loop-----------------------------------------------------------------------------------------------------------------------       
                                             
 

[Janson1]

I dag efter klubbens arbetsdag så var det dags för lite utökad utprovning av Grållen, det blev åtskilliga turer i kyrkbacken upp och ner... Tre grejer la jag märke till. Dels stallfarten, den sista programmeringen hjälpte.
Sen orken från lägsta varv till mer varv i brant backe blev också bra nu, (dvs krämen på lägsta varv är tillbaka).
Tredje grejen jag upptäckte är att vid motorbromsning så arbetar errorvärdet (error) åt ena hållet medans aggresionsvärdet (aggrfaktor) arbetar åt andra hållet vilket innebär att den ökar inte i nerförsbacke (övervarv) men insprutningen går inte ner till 0 utan ger en liten mängd som initialt ökar vid ökat varv och sen när varvet går ner så minskar insprutningen igen för att sen öka igen inför målvarvet. Detta medför att jag får lite sämre motorbroms, jag vet inte om det är lönt att ens försöka åtgärda detta "problem"...?
edit: felskrivet.

[Janson1]

Nu har jag hunnit provköra ordentligt ett par dagar, uppför, nerför, rakmark, sakta, fort. Och, jag är ganska nöjd nu, möjligtvis ryker den lite för mycket vid gaspådrag... men det kan jag leva med, så länge. Nu blir det nog inga revolutioner ang programmeringen mera, jag har hittat bra kompromisser över hela registret inkl bra startegenskaper, provat från - 7 grader till fullt varm motor. Jag avser väl inte sluta projektet bara så här rakt av men nu känner jag mig ganska nöjd för tillfället... Jag har skaffat en till motor (via blocket) som lär anlända i mitten på maj, jag är inte riktigt säker med det bör vara en ganska likadan. Ev så har den ett tandhjul med 60-2 tänder istället för 30-2+30-2 som min nuvarande motor. Om så är fallet så blir jag TVUNGEN att bygga min ECU med INTERRUPT...
Ja, alla som tjatat om detta får nu rätt, det går inte att bygga utan interrupt...

[Håkan Frid]

Imponerande.