Testade idag när jag hade ett ärende på lunchen. hittade bara "Deviation" för varje spridare, tror inte det säger så mycket men jag sparade ner turen i vart fall.
Undrar vad som styr det?
// Nu helt ny med Interrupt på vevpin (2) och 26-2 tänder på vevtandhjulet.
// Tändlägesjustering verkar ua ochså. Fungerar
// Nu läser den av alla analogread i följd om 2 och 2 Fungerar
// Batterispänningens inverkan grovjusterad Fungerar
// En individuell möjlig iför injustering per spridare finns med. Fungerar
// Ändrad i gasen så analogvärde 20 är tomgång och analogvärde 210 är fullfart Fungerar
// Mjukstarten är förbättrad och går in vid ca 200 RPM och varar till ca 450 RPM Fungerar
// Några fler constanter har kommit till bla. gaspotmin, gaspotmax, utanvärde, Fungerar
// En dubbel förtändning har kommit till, en för start och en för drift. Fungerar
// En ny regleringsmetod inlaggd Fungerar
// En ny delta2 har tillkommit för ökad mängd mellan 200 till 450 rpm Fungerar
// Fasttidsfunktionen är förbättrad, funkar nu på alla 4 grundtider NYTT Fungerar
// senasteinsprdrift = 8.5; Detta är ändrat från 8.0 pga lite knack vid belastning låga varv. Fungerar
// Ändrat: senaste insprutning från 2.0 till 3.0 (start)faktor 1100 till 2000 för att få tidigare/mer gasrespons låga varv. skall testas
// Pga av interrupt så måste alla durationstider inom tandräkning dubbleras, eller halveras beroende på hur och var dom står
//-------------------------------Här börjar programmet---------------------------------------------------------------------------------------------------------------------------------
// här är olika justerbara parametrar (Konstanter) som påverkar enligt följande:
const byte totaltid = 6; // totaltid för case 15
const int minfart = 7600; // lägsta startvarv för spridarfunktion (7600 = 131 RPM)
const byte startmangd = 6; // avgör max startmängd 32 ca 19 grader ontid (32) mellan 131 till 200 RPM (absolut första början)32
const int effektfaktor = 1500; // hur mycket effektökning skall gälla vid gaspådrag.(1500)
const int lagmangd = 2; // max lågvarvsmängd 4 = 2 vevaxelpuls = 12 grader ontid (under tomgångsvarv)(4) 200 till 300 RPM (mjukstartsmängd)max 5 pga 16383 uS!!!
const int tid1 = 4800; // tid 1 är för att hitta pulsluckan vid start/lågvarv < 300 RPM (4800)
const int tid2 = 2500; // tid 2 är för att hitta pulsluckan i mellanvarv 1100--> (2500)
const int tid3 = 1600; // tid 3 är för att hitta pulsluckan i alla andra förekommande varv 1100--> (1600)
const int tid4 = 180; // tid 4 är för att hitta pulsluckan på högsta varvtal (180)
const float senasteinsprdrift = 4.6;// Vid tomgång/drift ges en ny "senasteinsprutningstid" som behålls sedan. (högre tal ger senare tändning)(4.6)
const byte tidigasteinspr = 240; // kortaste insprutningsfördröjning vid maxvarv, högre tal ger tidigare tändning(240)(max 255)
const float korrfaktor = 1.3; // korrektionsfaktor för att senare lägga insprutningsbörjan till högre varv
const float minstaAggrFaktor = 1.8; // gasrespons, den minsta förekommande (2.5) (1.3)
const int sprtroghet = 60; // ett grundvärde för spridarnas påslagsfördröjning i uS (60)
const int sprdiff1 = 20; // en ev tidigareläggning av spridare 1 om den avviker i startfördröjning (20 uS)
const int sprdiff2 = 20; // en ev tidigareläggning av spridare 2 om den avviker i startfördröjning (20 uS)
const int sprdiff3 = 20; // en ev tidigareläggning av spridare 3 om den avviker i startfördröjning (20 uS)
const int sprdiff4 = 20; // en ev tidigareläggning av spridare 4 om den avviker i startfördröjning (20 uS)
const int pumpdelay = 500; // avstängsfördröjning för elpump i millisekunder
const int omslagstartdrift = 3000; // Bestämmer när mjukstarten går ur (omslagspunkt) (1800 = brytvarv 450 RPM) skall vara 3000!!2400
const int omslagmillimicro= 4000; // omslag från milli till micro i case 16 (vid startvarv ca 200 RPM, baseras på mduration i us)(4000)
const byte utanvarde = 60; // om delta är under ett visst värde utanvärde, nollas delta (60)
const byte gaspotmin = 20; // gaspotens minsta tillåtna värde (20)
const byte gaspotmax = 210; // gaspotens största tillåtna värde (210)
const int lagstavarv = 1140; // tomgångsvarvet 1000 uS motsvarar ca 800 Rpm (1140)
const byte hogstavarv = 210; // fullgasvarvet 180 uS motsvarar ca 4000 RPM (210)
const byte mintryck = 55; // lägsta bränsletryck i railen (10)
const byte maxtryck = 150; // högsta bränsletryck i railen (250) max 255!!
//const byte minstaPilotdelta =0; // här ställs den minsta pilotinsprutningstiden, vid låga varv
//const byte mestaPilotdelta = 0; // här ställs den högsta pilotinsprutningstiden, vid högre varv
const int treglerb = 2000; // TryckReglerBörjan, bestämmer vid vilket varvtal trycket skall börja stiga
// dom olika variablerna
float senasteinspr = 2.0; // senaste insprutningstid (vid start upp till tomgång)(6.0 = 3 vevaxelpulser = 18 grader delaytid(2.0) Tomgångsförtändning.
int fasttid = 180; // Fasttid = börjar alltid på 180 för att sedan ställa in mer rätt (tid1 till tid4)
byte tand = 0; // vevaxelräknarpulser räknare 0 till 27.
unsigned long tand2 = 0; // vevaxelräknarpulser för senareläggare av start för HPFV
byte spridare = 0 ; // spridare för att välja rätt spridarutgång, startar på 0
float aggrfaktor; // ett uträknat decimalvärde
unsigned long delvalue; // delvärde av pulstid i uS.
unsigned int ondelay; // tillslagsfördröjning spridare i uS/mS (mS inne i case 16)
long puls, priv; // pulstid, föregående pulstid
unsigned int delta, delta2; // delta (totalöppningstid) i uS(mS) och en delta2 vid start
float error; // error = varvtalsfelet i decimalform
float starttandf; // starttand i decimalform för att få startfördröjningstid och finkorrigering av öppninstiden +-.
float mduration, bduration; // varvfelet = motorduration/börduration i decimalform
int fmduration; // en Förändrad Motor Duration
byte gas; // gas 0-255
byte analogval; // En switch/case till analogread
int sprtroghetklar; // korrektion för den inbyggda påslagströgheten i spridarna
int spridardiff; // en ev. individuell spridartid korrigering (uS)
int sprstartkorr;
int battVolt;
volatile unsigned long VEVTAND_langd; // nuvarande tandlängd
volatile unsigned long VEVTAND_start; // tandstart
unsigned long prev_langd; // föregående tandlängd
unsigned long pumpvakt1_ul32; // en timer inlaggd för att bevaka elbränslepumpen
unsigned long pumpvakt2_ul32; // så den stannar vid motorstopp/misslyckad start
unsigned long nytid_ul32; // nytid läses varje halvvarv
unsigned long datid_ul32; // och jämföres med dåtid förra halvvarvet
unsigned long totaltid_ul32; // summa tiden per halvvarv i uS
volatile int caseRead; // om case x är läst eller ej
byte ftryck; // bränsletryck
// int pilotinspr; // en uträknad pilotstråleinsprutningstid
int HPFS; // avläst värde från bränlsehögtryckssensorn (High Pressure Fuel Sender)
// int pilotdelta; // ett förinsprutningstidsvärde
byte pftryck; // PumpFörTryck till elbränslepumpen
// Dom olika I/O anslutningarna
int vevSignal = 2; // pulsingång vevaxelgivare, (aktivt låg).2
int kamSignal = 3; // kamaxelgivarens ingång, (aktivt hög).3
int pulsutpin = 4; // pulsutgång 2 pulser per varv (kontrollutgång för övervakningen).4
int sprpins [] ={7,8,9,12}; // till spridarna (blir aktivt höga)7,8,9,12
int Disable = 18; // aktivt låg stoppar utsignalerna till spridarna 18
int tidute = 17; // kontrollutgång som blir aktiv när elpumpen är aktivt avstängd 19
int sprControl = 13; // kontrollutgång för spridare till övervakningen 13
int elpump = 11; // PWM-utgång till motorns Elbränslepump 11
int HPFV = 10; // PWM-utgång till motorns bränslehögtrycksreglerventil (High Pressure Fuel Valve) 10
int fardig = 19; // kontrollutgång som indikerar färdig/drift
void setup() // körs bara en gång vid uppstart/reset
{ // här ges alla I/O dess funktion
pinMode(vevSignal, INPUT_PULLUP); // satt vevaxelsignal som ingång (2)
attachInterrupt(digitalPinToInterrupt(vevSignal), VEV_pulse, FALLING); // här blir vevpin (2) interruptstyrd
pinMode(kamSignal, INPUT); // satt kamaxelsignal som ingång (3)
pinMode(sprpins[spridare], OUTPUT);// spridarutgångar satta som arrey (7,8,9,12)
pinMode(sprControl, OUTPUT); // en spridarkontrollutgång som blir hög varje gång en spridare öppnas (13)(Övervakningen)
pinMode(Disable, INPUT_PULLUP); // ECU väljare Hög = on, Låg = off (18)
pinMode(tidute, OUTPUT); // satt tidute som utgång (19)
pinMode(pulsutpin, OUTPUT); // satt pulsutpin som utgång (2 pulser per varv)(4)(övervakningen)
pinMode(elpump, OUTPUT); // elbränslepump satt som utgång (11)
pinMode(HPFV, OUTPUT); // bränslehögtrycksreglerventil satt som utgång (10)
pinMode(fardig, OUTPUT); // satt färdig som utgång
//Serial.begin(250000); // bra att ha...
digitalWrite(elpump, HIGH); // elpumpen startar i setup
delay(1500); // elpumpen går i 1,5 sekunder
digitalWrite(elpump, LOW); // elpumpen stannar igen, motor redo för start.
digitalWrite(fardig, HIGH); // sätter färdigutgången hög inför start.
}
//----------------------------------------Här börjar själva programloopen, denna körs hela tiden------------------------------------------------------------------------------------------
void loop()
{
// Det får plats ca 1700 klockcykler mellan varje x tal(case) (0 till 17 & 30 till 46)
// Det tar lite mer än 100 mikrosek att läsa av en analogingång,
// så ingen analogRead här, skall vara i case 26/56!
if (digitalRead(Disable)==LOW) // Disable låg stänger av ECU:ns utgångar och gör den passiv
{
delta = 0; // Genom att delta (insprutningstid) förblir 0.
pinMode(sprpins[spridare], INPUT);// Gör om spridarutgångarna till ingångar för att ej belasta
pinMode(sprControl, INPUT); // Gör om spridarcontrollen till ingång för att ej belasta
pinMode(elpump, INPUT); // gör om elbränslepumpen till ingång för att ej belasta
pinMode(HPFV, INPUT); // gör om bränsletrycksventilutgång till ingång för att ej belasta
pinMode(fardig, INPUT); // sätter "färdig" låg
}
else //*
{
pinMode(sprpins[spridare],OUTPUT);// Vid aktiv så gäller spridarutgångarna som utgångar igen.
pinMode(sprControl, OUTPUT); // Vid aktiv så gäller spridarcontrollen som utgång igen
pinMode(elpump, OUTPUT); // Vid aktiv så gäller elbränslepumpen som utgång igen
pinMode(HPFV, OUTPUT); // Vid aktiv så gäller bränsletrycksventilutgång som utgång igen
pinMode(fardig,OUTPUT); // Vid aktiv så gäller färdig som utgång igen
digitalWrite(fardig, HIGH); // Vid aktiv så sätts "färdig" hög
} //*Detta är normalläget, samma som i setup*
pumpvakt2_ul32 = millis(); // här läggs en tid in från millisräknaren precis innan case x skall läsas
if(pumpvakt2_ul32 - pumpvakt1_ul32 >=pumpdelay) // här jämförs tiderna, blir det ingen läsning av case x pga att motorn
{ // står stilla så blir det "tidute"
digitalWrite(elpump, LOW); // elbränslepumpen stängs av
digitalWrite(tidute, HIGH); // utgången "tidute" går hög
}
else
{
digitalWrite(tidute, LOW); // normalfall dvs motorn går.
}
if(caseRead == 1) // är case´t läst?
{
caseRead = 0; // case´t läst = 0
pumpvakt1_ul32 = millis(); // här läggs en tid in från millisräknaren precis efter identifiering av: läs av case x
switch (tand) // här startar switch och case, tandräknaren stegar fram ett steg (case)
{
case 0: // lägger in rätt spridare till rätt spridardiff
if (spridare == 0) // om spridarpekaren pekar på 0 (ben D7)
{
spridardiff = sprdiff4; // skall det individuella värdet för spridare 4 hämtas
}
if (spridare == 1) // om spridarpekaren pekar på 1 (ben D8)
{
spridardiff = sprdiff2; // skall det individuella värdet för spridare 2 hämtas
}
if (spridare == 2) // om osv... upp till 3 (fjärde spridaren)
{
spridardiff = sprdiff1; // ben D9
}
if (spridare == 3)
{
spridardiff = sprdiff3; // ben D12
}
break;
case 1: // Detta case ger elbränslepumpens fart (PWM)
pftryck = map(mduration,8000,210, 150, 255); // elbränslepumpens effekt ställs här
pftryck = constrain(pftryck,150,255); // om effekten hamnar utanför så ställs PWM att vara 120-255 ändå.
break;
case 2: // Detta case startar elpumpsstyrningen
if(mduration <15200) // motorn måste gå i startvarv eller mer
{
digitalWrite(elpump, HIGH); //analogWrite(elpump, pftryck); // för att elpumpen skall starta
}
break;
case 3: // Detta case tomt
sprstartkorr =map(battVolt, 150, 700, 200, 0); // batterispänningen blir spridartidskorrigering
sprstartkorr = constrain(sprstartkorr,200,20); // för att hålla färdigvärdet inom 400-200 uS
break;
case 4: // Detta case ger bränslehögtrycksreglering och fördröjd start
fmduration = constrain(mduration,hogstavarv,treglerb); // En ny variabel FörändradMotorDuration
ftryck = map(fmduration,treglerb,hogstavarv, mintryck,maxtryck);// här mapas bränsletrycket om för att följa varvtalet
ftryck = constrain(ftryck,mintryck,maxtryck); // här begränsas min-maxvärde för PWM hpfv 10-255
if(tand2 > 87) // fördröjer starten 1,5 vevaxelvarv
{
if(digitalRead(HPFV == LOW)) // om högtrycksventilen är öppen (opåverkad)
{
digitalWrite(HPFV, HIGH); // så stängs den först 100%
}
analogWrite(HPFV, ftryck); // sen styrs den ut via PWM 0-255
}
break;
case 5: // Detta case ger motorns duration per halvvarv
totaltid_ul32 = nytid_ul32 - datid_ul32; // här jämförs ny tid med gammal tid och det blir en summa tid i uS
datid_ul32 = nytid_ul32; // den nya tiden läggs i föregående tid (dåtid)
mduration = totaltid_ul32/28; // summatiden divideras med 28 för att passa övriga tider (uS)
/* Serial.print("mduration");
Serial.print(mduration);
Serial.print("VEVTAND_langd");
Serial.println(VEVTAND_langd);
*/ break;
case 6: // Detta case ger motorns börvärde från gaspoten som blir lägsta och högsta varvta
gas = constrain(gas,gaspotmin, gaspotmax); // först skall invärdet vara mellan min och max oavsett gaspotens verkliga värde (om utanför)
bduration = map (gas,gaspotmin, gaspotmax, lagstavarv, hogstavarv); // gör om gas analogvärde till lägsta/högsta uS värde
break;
case 7: // Detta case ger error, motorns över/undervarv i förhållande till börvarvet.
error = (mduration / bduration)-1; // felet
if (error <=0.) // om error hamnar under noll
{
error = 0.; // förblir error 0 för att ej få minusvärden
} // felet i uS mellan ärvärde och börvärde för motorns duration (varvtal)
// här testas fasttid ut genom att gämföra vilken mduration som passar bäst.
fasttid = (VEVTAND_langd < 1000) ? tid4 : (( VEVTAND_langd < 2400) ? tid3 : (( VEVTAND_langd < 3600 ) ? tid2 : tid1));
break;
case 8:
// tomt
break;
case 9: // Detta case detekterar kamaxelns hemposition
if (digitalRead(kamSignal)== HIGH) // varje gång kamaxelns hempuls detekteras så resetas 4 räknaren (aktivt låg)
{
spridare = 3; // resetas till 3. dvs cylinder 2 blir aktiv.
}
if (digitalRead(kamSignal)== LOW) // ingen hempuls?
{
//gör ingenting
}
break;
case 10: // Detta case räknar ut tidsdiff per spridare
sprtroghetklar = sprtroghet + spridardiff - sprstartkorr; // spridartröghet klart värde räknas ut här
break;
case 11: // Detta case för insprutningsfördröjning i gånger, ställs högst upp
// Detta case ger förtändningen
starttandf = (mduration * korrfaktor) /tidigasteinspr; // starttandf, ett flyt-tal = motorns duration x korrektionstal/ minsta duration.
if (starttandf >= senasteinspr) // om fördröjning över målvärdet, som vid tex startvarv
{
starttandf = senasteinspr; // blir det målvärdet ändå
}
ondelay = (mduration * starttandf); // tillslagsfördröjning = motorns duration * starttandsfördröjning (decimaltal)
// Ondelay uS = mduration uS * starttandf i decimalform
/* if((mduration > omslagstartdrift) && (mduration < omslagmillimicro)) // om motorns duration ligger mellan 4000 us och 3000 uS
{
delta2 = lagmangd * mduration; // så skall extra insprutningstid läggas till (delta2)
}
else
{
delta2 = 0; // annars ej delta2
}
*/break;
case 12: // Här räknas effektregleringen ut genom hela registret från 450 rpm och uppåt
// även förinsprutningens uträkning skall vara här (pilotinjection)
if(mduration <=omslagstartdrift) // Om/när motorn går över 450 rpm
{
aggrfaktor = effektfaktor/mduration; // Här räknas aggresionsfaktorn ut med hänsyn av en gångerfaktor/ motorns duration. (varvtal)
if(aggrfaktor < minstaAggrFaktor) // om aggresionsfaktorn blir mindre än minsta aggresionsfaktor
{
aggrfaktor = minstaAggrFaktor; // så blir ändå aggresionsfaktorn den förutbestämda agresionsfaktorn.
}
delta = aggrfaktor * mduration * error; // Här räknas delta ut med hänsyn till agresinsfaktorn, motorns duration och gasreglägets värde
// pilotdelta = delta/5; // Pilotinsprutningstid blir här en 5del av total tid
// pilotdelta = constrain(pilotdelta,minstaPilotdelta, mestaPilotdelta); // Pilotinsprutningstid ställs in att bli mellan minsta pilotdelta och mesta pilotdelta uS
}
break;
case 13: // Detta case ger mjukstarten
if (mduration >= omslagstartdrift) // Vid lite över startfart mellan 200 RPM till ca 450 RPM
{
delta = lagmangd * mduration; // blir det mjukstart som justeras via lågmängd
}
// och absolut längsta insprutningstid
if (delta + ondelay >= totaltid * mduration) // om delta och ondelay i uS blir mer än totaltid
{ // så justeras endast delta ner
delta = (totaltid * mduration)-ondelay; // Absolut max insprutningstid (delta),
} // denna justering gäller för max insprutnings-"fönster"
break;
case 14: // Detta case ger olika förtändning för start och drift
if (mduration < omslagstartdrift) // går motorn över driftfart?
{
senasteinspr = senasteinsprdrift; // i så fall läggs förtändning drift (normalfallet)
}
else
{
// gör ingenting // Annars förtändning start
}
break;
//------------------------------------------------------------------------------------- case 15, insprutningsfasen-----------------------------------------------------------------
case 17: // Detta case är insprutningsfasen "spridar-on-off-mode"
if (mduration >=omslagmillimicro) // Om motorns duration är mer än xx uS. (från 131 till 203 RPM räknas alla spridarvärden i mS) 5000 = 203 RPM
{ // går tiden över från uS till mS.
ondelay = ondelay/1000; // Ondelay uS blir mS.
delta = delta/1000; // Delta uS blir mS.
// avgör om tillräcklig fart är uppnådd för motorstart
if(mduration >= minfart) // motorn måste upp i x fart för att få bränsle, (minfart i uS)
{
delta = 0; // vid underfart, delta(insprutningstid)nollas
}
// och startmängden vid motorstart
if ((delta * 4)>= startmangd) // här ställs startmängden in
{ // 32
delta = startmangd; // så det blir rätt startmängd/slag (5 = 0,75 tänder = 4,5 vevgrader)
}
delay(ondelay); // Fördröjer starttiden x antal mS beroende på varvtalet (mdurationen)
digitalWrite (sprpins[spridare],HIGH);// Spridarpinne hög,insprutning börjar. spridare x strömsätts [visare 8,9,10 eller 11].
digitalWrite(sprControl, HIGH); // Kontrollpinne som blir hög vid varje insprutningstillfälle.
delay(delta); // Här läggs insprutningstiden in som sen fördröjer processorn i delta mS
digitalWrite (sprpins[spridare],LOW); // Spridarpinne låg,insprutning avslutad spridare x stängs av [visare 8,9,10 eller 11].
digitalWrite (sprControl, LOW); // Kontrollpinne som går tillbaka till låg efter varje insprutningstillfälle.
ondelay = ondelay*1000; // Ondelay mS blir uS igen.
delta = delta*1000; // delta mS blir uS igen.
} // Detta paket används vid låga farter såsom start/lågvarv < 203 RPM
//----------------------------------------------------------------------------------------------------------------------------
else // Eller om mduration är mindre än 4000 uS. (> 203 RPM)
{
if (delta > utanvarde) // Delta under utanvärde uS har inget värde
{
delta = delta + sprtroghetklar; // Delta blir delta + trögheten i spridaren (ca 80 uS)som tröghetskompensation
// pilotdelta = pilotdelta; // och en förinsprutningstid läggs till
}
ondelay = ondelay - sprtroghetklar; // tidigarelägger insprutningstart med hänsyn till spridartrögheten
delayMicroseconds(ondelay); // Fördröjer starttiden i ondelay uS beroende på varvtalet (mdurationen)
digitalWrite(sprpins[spridare],HIGH); // Insprutning börjar. spridare x strömsätts.
digitalWrite(sprControl, HIGH); // Kontrollpinne som blir hög vid varje insprutningstillfälle.
// delayMicroseconds(pilotdelta); // Pilotinsprutningstid på mellan 100 och 200 uS
// digitalWrite(sprpins[spridare],LOW); // Sen stängs spridaren av igen, beredningstid och tändning av bränslet inleds
// delayMicroseconds(50); // Här ges tiden för just beredning och tändning av bränslet
// digitalWrite(sprpins[spridare],HIGH); // Den stora insprutningen startar här
delayMicroseconds(delta); // Här läggs den stora insprutningstiden in vid drift (normalfallet)
// delayMicroseconds(delta2); // Här läggs en extra insprutningstid in som bara gäller mellan 203-450 rpm (mellan 4000-3000 uS)
digitalWrite (sprpins[spridare],LOW); // Spridarpinne låg,insprutning avslutad spridare x stängs av
digitalWrite (sprControl, LOW); // Kontrollpinne som går tillbaka till låg efter varje insprutningstillfälle.
} //Detta paket används vid varv (203 -> RPM = nästan alltid, förutom vid motorstart)
spridare ++; // här räknas spridarutgången upp ett steg
if (spridare > 3) // när fjärde spridarutgången är nådd börjar den om igen
{
spridare = 0; // spridarutgång 0 är igång igen (0 = D7)
}
break; // Detta paket tar 1 till 6 tänder att genomföra beroende på varvtal och belastning
//-------------------------------------------------------------------- case 16, insprutningsfasen avslutad-------------------------------------------------------------------------
// Här läses alla analoga signaler max 2 per gång av max 8 st totalt (A0 till A7)
case 23: // är mellan tand 17 och 23
switch (analogval)
{
case 0:
gas = analogRead(A0)>>2; // analogingång för gasreglage 0 till 255( skiftad 2 gånger)
// tom
break;
case 1:
HPFS = analogRead(A1); // analogingång som läser av bränslehögtrycket
battVolt = analogRead(A7);
break;
case 2:
gas = analogRead(A0)>>2; // analogingång för gasreglage 0 till 255( skiftad 2 gånger)
// tom
break;
case 3:
// tom
// tom
break;
case 4:
gas = analogRead(A0)>>2; // analogingång för gasreglage 0 till 255( skiftad 2 gånger)
// tom
break;
case 5:
// tom
// tom
break;
}
analogval ++; // räkna upp analogval 1 steg
if (analogval > 5) // när analogval har blivit 5 så
{
analogval = 0; // resettas analogval till 0 igen
}
break; // analalogRead tar ca 120 uS att läsa = 1-2 tänder vid fullvarv
} // nu är alla switch-case lästa
}
}
//-------------------------------------- Nedan är för att leta upp tandluckan, räkna upp tandräknaren,reseta tandräknaren, bestämma motorns duration (varvtal)--------------------------
//---------------------------------------Hela denna del är interruptstyrd och anropas vid varje ny puls från vevaxelgivaren-----------------------
void VEV_pulse() // När en ny vevaxelpuls är detekterad så går denna loop igång
{ // Den:
unsigned long thisLength = micros(); // tar ett ögonblicksvärde på microsekunderräknaren
caseRead = 1; // sätter en flagga till case read
prev_langd = VEVTAND_langd; // nuvarande vevtands längd läggs in som föregående vevtandslängd (döper om)
VEVTAND_langd = thisLength-VEVTAND_start; // Längden på nuvarande lucka hamnar i variabeln VEVTAND_langd
VEVTAND_start = thisLength; // Börja mätning av lucka
tand++; // tandräknaren räknar upp en tand
tand2++; // tandräknare 2 räknar upp en tand
if(VEVTAND_langd > prev_langd + fasttid) // OM nyaste vevtands längd är längre än föregåendes + fasttid
{ // då är luckan hittad
digitalWrite(pulsutpin, HIGH); // Då går utpin hög
nytid_ul32 = micros(); // En tid från microräknaren läggs in
tand = 0; // och tandräknaren resetas till 0 (början på tandräkningen)
// Denna if-sats är bara sann varje halv-varv vid luckan
}
if(VEVTAND_langd < prev_langd - fasttid) // OM nyaste vevtands längd är kortare än föregående -fasttid
{ // då är luckan slut
digitalWrite(pulsutpin, LOW); // och utpin blir låg igen.
}
}
//--------------------------------------------Här slutar den Interruptstyrda delen------------------------------------------------------------------------------------------
//-------------------------------------------------slut loop-----------------------------------------------------------------------------------------------------------------------
Användare som besöker denna kategori: Inga registrerade användare och 2 gäster