Bygga egen styrning (ECU) till en pumpdyse-dieselmotor

[Towil]

Likna arduino med en låda som har anslutningar med olika bestämda funktioner. I lådan stoppar man sedan en MCU som kan klara av att utföra de funktioner som lådan ger. Stoppar du i en annan MCU så får du samma funktioner från arduinolådan. Det blir enkelt att lära sig och allt är lika hela tiden.
Det stora problemet är MCU’n klarar mycket mera än var arduinolådan ger dig tillgång till. För att utnyttja alla funktioner så måste man byta låda som är mera anpassad för den MCU man tänker använda.
Ta atmega328 som sitter på ditt nanokort. Den har interrupt på alla data pinnar, variabel PWM frekvens, ADC med 13 - 260µs konverterings tid plus mycket mera. Du kan inte använda det för Arduino har inte stöd för det. Tillslut så är lådan för liten och det dags att byta till en större mer anpassad låda. Man får vänja sig vid att lådan inte hela tiden ser lika dan ut.

”Jag skall ju inte direkt blinka en lysdiod eller tre...”

Nä, du skall blinka fyra!
Om det är 4 led eller insprutare är det fortfarande samma kod för att ändra själva pinnen.

jag är kluven till detta med programmeringsmiljö

Mycket sämre än du kör nu blir det knappt.
I en riktig miljö kan man köra en debugger och stega dig fram i koden när den körs på MCU läsa av värde i variabler. Lägga brytpunkter i koden så att mcu’n stannar när den kommer till en speciell rad i koden för vidare felsökning.

Vill du att den fysiskt passar i din nano sockel är utbudet ganska begränsat med Nucleo 32.
Är sockel ingen begränsning så är Nucleo 64 nästa steg. Har 4 olika Nucleo 64 jag kör vid testning.

Vilken Nucleo du skall köpa avgörs av vilka funktioner du vill ha?
Ladda hem CubeMX och kolla runt lite eller skriv vad du vill ha, så kan jag ge lite alternativ.

https://www.st.com/en/development-tools ... ubemx.html

Nucleo-kort STM32F103RBT6 tror jag passar mig bäst??

Den har ingen DAC och är en Nucleo 64.

[Janson1]

Jag behöver ju "blinka" 6-8 st lysdioder men skit samma. Jag är beredd på att byta programmeringsmiljö för att just komma på själv vilket som är bäst/sämst. Det här med DAC, behöver jag det? Jag har ju klarat mig utan det förut utan att jag saknat det. Min tanke med valet av Nucleo är att det skall likna den här "Blue pill" så mycket som möjligt så jag vill nog börja där. Sen så skaffar jag givetvis det "bästa" om jag bara behärskar det, eller kommer att behärska det inom överskådlig framtid...
CubeMX skall jag ladda upp när jag kommer hem, just nu har jag begränsade möjligheter.
Att den nya processormodulen skall passa rent fysiskt har jag inte begärt någon gång (bara ett önsketänkande) utan jag gör ett nytt mönsterkort (pcb) när det är dags, inga problem.
Men Towil, du vet väl lite vad som jag bör ha till denna ECU så ge ett förslag på om jag skall ha nåt annat istället för mitt förslag.

[Towil]

Skiljer så lite i pris, så kör med en i de övre segmentet NUCLEO-F446RE

https://www.elfa.se/sv/stm32-nucleo-kor ... track=true

Finns inte i lager ser jag.

https://www.tme.eu/se/details/nucleo-f4 ... ectronics/

[Towil]

Såg att RS-online är billiga med Nucleo. Gratis frakt på order över 500kr
https://se.rs-online.com/web/p/processo ... s/9064624/

[Janson1]

Tack! Nu har jag beställt den som du länkade till och så beställde jag även en som jag själv tror jag vill ha...
Just nu försöker jag installera Cube-programmet.

[Janson1]

Jag gjorde om lite I/O på min ECU utan Interupt och la in den i STM32 modulen "Blue pill" och det verkar ju fungera. Jag har ju även en ECU med interrupt så jag försökte med nåt liknande, dvs döpa om benen så dom finns i verkligheten på modulen men nu så får jag "Error kompilering" direkt och kan egentligen inte felsöka vad som går galet. Jag misstänker interuptrutinen?? En fil för beskådan:

Kod: Markera allt

    // Nu helt ny med Interrupt på vevpin (2) 2019-05-13 och inlagd, provad   omgjord till STM32- går ej att kompilera...                                                           
    // 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 = 7;            // totaltid för case 15: x * motorns duration * 2 (10)tand 15-22 = max 14 totalt
    const int minfart = 7600;           // lägsta startvarv för spridarfunktion (3800 = 131 RPM)x 2 = 7600 uS
    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 = 1500;            // en hur mycket effektökning skall gälla vid gaspådrag.(1100)ändrad till 1400 till 2000
    const int lagmangd = 3;             // 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 = 4800;              // tid 1 är för att hitta pulsluckan vid start/lågvarv < 300 RPM (2500)                           
    const int tid2 = 2500;              // 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 = 3.9;// Vid tomgång/drift ges en ny "senasteinsprutningstid" som behålls sedan. (högre tal ger senare tändning)
    const int tidigasteinspr = 260;     // kortaste insprutningsfördröjning vid maxvarv, högre tal ger tidigare tändning(110)(max 255)
    const float korrfaktor = 1.2;       // 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 = 2400;  // Bestämmer när mjukstarten går ur (omslagspunkt) (900 = brytvarv 450 RPM) skall vara 1200!! nu 2400
    const int omslagmillimicro= 5000;   // omslag från milli till micro i case 16 (vid startvarv ca 200 RPM, baseras på mduration i us)2500 nu 5000
    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 = 1180;         // tomgångsvarvet 500 uS motsvarar ca 800 Rpm (545)(550)1180
    const byte hogstavarv = 224;         // fullgasvarvet 90 uS motsvarar ca 4000 RPM  (90) (112) 224

                // 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 = 180;                // Fasttid = börjar alltid på 300 för att sedan ställa in mer rätt (tid1 till tid4) nu 180
    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 grundfartflakt = 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 = PB1;                   // pulsingång vevaxelgivare, (aktivt låg).
    int kampin = PB0;                   // kamaxelgivarens ingång, (aktivt hög).
    int pulsutpin = PB14;                // pulsutgång 2 pulser per varv (kontrollutgång för övervakningen).
    int sprpins [] ={PB8,PB5,PB6,PB7};      // till spridarna (blir aktivt höga)
    int Disable = PB15;                 // aktivt hög stoppar utsignalerna till spridarna
    int sprControl = PC13;              // kontrollutgång för spridare till övervakningen
    int elflakt = PA3;                  // PWM-utgång till motorns elkylfläkt (måste ha ett tildetecken)
    int gasPin = PA0;
    int battPin = PA1;
    int flaktPin = PA2;
   
 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
   pinMode(gasPin, INPUT_ANALOG);
   pinMode(battPin,INPUT_ANALOG);
   pinMode(flaktPin, INPUT_ANALOG);
   //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(VEVTAND_langd);
     // 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
         
           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
            }
     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/10;                                           // 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(gasPin)>>2;           // analogingång för gasreglage 0 till 255( skiftad 2 gånger)
           // tom
        break; 

        case 1:
           battVolt = analogRead(battPin);         // analogingång som läser ECU:ns systemspänning
           // tom
        break;

        case 2:
           gas = analogRead(gasPin)>>2;           // analogingång för gasreglage 0 till 255( skiftad 2 gånger)
           // tom                             
        break;
       
        case 3:
            fart_flakt = analogRead(gasPin)>>2;    // analogingång för gasreglagefläkt 0 till 255( skiftad 2 gånger)
            fart_flakt = fart_flakt + grundfartflakt;// Här läggs en grundfart till för att säkerställa fläktfunktion lågfart.
        break;

        case 4:
           gas = analogRead(gasPin)>>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
   
   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-----------------------------------------------------------------------------------------------------------------------       
                                             

Så vad göra?

[jpd]

Får du inget mer matnyttigt felmeddelande?
Vilken fil/rad eller vilket fel?

[Janson1]

Tyvärr ingen hint om något, den klagar precis direkt...

[Towil]

under inställningar finns verbose, kryssa i för att få mera info vid kompilering.

[Janson1]

Jag hittar ingen "verbose" men jag har kryssa i att den skall visa samtliga varningar från kompilatorn. Den skriver: Arduino:1.8.9 (Windows 10), Kort:"Generic STM32F103C series, STM32F103C8 (20k RAM. 64k Flash), Serial, 72Mhz (Normal), Smallest (default)"

FindFirstFile C:\Users\LNEDAT~1\AppData\Local\Temp\arduino_build_131286: Det går inte att hitta filen.

Error compiling for board Generic STM32F103C series.

This report would have more information with
"Show verbose output during compilation"
option enabled in File -> Preferences.
SLUT

[Towil]

Finns på min. Ver 1.8.9

[Janson1]

Aha, på min svenska version står det: Visa detaljerad info vid: kompilering. """Arduino:1.8.9 (Windows 10), Kort:"Generic STM32F103C series, STM32F103C8 (20k RAM. 64k Flash), Serial, 72Mhz (Normal), Smallest (default)"

C:\Program Files (x86)\Arduino\arduino-builder -dump-prefs -logger=machine -hardware C:\Program Files (x86)\Arduino\hardware -hardware C:\Users\Lånedator\AppData\Local\Arduino15\packages -tools C:\Program Files (x86)\Arduino\tools-builder -tools C:\Program Files (x86)\Arduino\hardware\tools\avr -tools C:\Users\Lånedator\AppData\Local\Arduino15\packages -built-in-libraries C:\Program Files (x86)\Arduino\libraries -libraries C:\Users\Lånedator\Documents\Arduino\libraries -fqbn=stm32duino:STM32F1:genericSTM32F103C:device_variant=STM32F103C8,upload_method=serialMethod,cpu_speed=speed_72mhz,opt=osstd -ide-version=10809 -build-path C:\Users\LNEDAT~1\AppData\Local\Temp\arduino_build_131286 -warnings=all -build-cache C:\Users\LNEDAT~1\AppData\Local\Temp\arduino_cache_889474 -prefs=build.warn_data_percentage=75 -prefs=runtime.tools.stm32tools.path=C:\Users\Lånedator\AppData\Local\Arduino15\packages\stm32duino\tools\stm32tools\2019.3.31 -prefs=runtime.tools.stm32tools-2019.3.31.path=C:\Users\Lånedator\AppData\Local\Arduino15\packages\stm32duino\tools\stm32tools\2019.3.31 -prefs=runtime.tools.arm-none-eabi-gcc.path=C:\Users\Lånedator\AppData\Local\Arduino15\packages\arduino\tools\arm-none-eabi-gcc\4.8.3-2014q1 -prefs=runtime.tools.arm-none-eabi-gcc-4.8.3-2014q1.path=C:\Users\Lånedator\AppData\Local\Arduino15\packages\arduino\tools\arm-none-eabi-gcc\4.8.3-2014q1 -verbose C:\Users\Lånedator\Desktop\ECU_interruptSM32190604\ECU_interruptSM32190604.ino
FindFirstFile C:\Users\LNEDAT~1\AppData\Local\Temp\arduino_build_131286: Det går inte att hitta filen."""

Error compiling for board Generic STM32F103C series.
Ja mycket text men jag kan nog inte utläsa nåt matnyttigt av detta...

[Janson1]

Jag tror själv felet har med interuptet eller sättet att ange det på är boven i dramat. Jag har ju en förutom interrupt en "vanlig" likadan ECU-fil så det ända som skiljer är att pulseIn() är borta och interruptrutin är inlagd istället. Jag har blivit tipsad om ett forum som bara behandlar STM32 i Arduinomiljö. :http://www.stm32duino.com/ Problemet är bara att det är så mycket att jag går vilse...

[Towil]

Vilket span behöver du mäta tiden på kuggen?

Denna setup klar tider mellan 7us till 30ms med 1us upplösning från pine PB7 på en Nucleo F411RE körd i 84MHz (100MHz max).

Timer konfigurering


10us puls.


Kod att skriva in

Kod: Markera allt

void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
   if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2)
   {
      PulseTime = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_2) - HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);
   }
}

[Janson1]

Mätspannet räcker nog. Jag behöver mäta från ca 8000 uS (7600 uS är gränden mellan insprutning eller ej) och lägsta användbara kuggtid är ca 200 uS, behöver jag upp i högre varv så kommer minsta tid krypa ner till kanske 160 uS?. Är skärmutklippet från Cube? Jag har nu installerat det på min arbetsdator men har precis fått en ny från jobbet. Så, vilket program skall jag välja? Jag har inte fått några Nucleo kretsar än...