Svenska ElektronikForumet
https://elektronikforumet.com/forum/

Skillnader i timers, prescalers på Atmega och STM32
https://elektronikforumet.com/forum/viewtopic.php?f=7&t=95924
Sida 4 av 4

Författare:  sodjan [ 15.32 2019-09-11 ]
Inläggsrubrik:  Re: Skillnader i timers, prescalers på Atmega och STM32

Klassisk felsökning. Skala ner. Fixa ett minsta möjliga "reproducer".
Om en speciell funktion strular, gör ett program med enbart det.
O.s.v. o.s.v...

Författare:  Janson1 [ 07.35 2019-09-12 ]
Inläggsrubrik:  Re: Skillnader i timers, prescalers på Atmega och STM32

Tyvärr verkar "klassisk" felsökning inte funka här. Jag har kommit på att var för sig så funkar det så det är nog ingen skillnad på sättet att skriva arrayer. Allt jag har skalat ner funkar var för sig men inte ihop och då faller konceptet lite... Eller rättare sagt: Det funkar i Atmega328-kretsen men inte i STM32 typ "Blue pill" eller Adafruit "Itsy Bitsy". Detta är lite varför jag skapade denna tråd, jag misstänker att det just är en timerkollision. Bara frågan hur man skall komma förbi felet, är det ens möjligt? Jag tror STM32:s arkitektur inte passar att bara lägga in samma upplägg som på Arduino. En Atmega328 verkar bara ha 3 timrar (2 8 bitar, 1 16 bitar) medans STM32 har från 4 upp till en hela tjog med timrar men det verkar vara svårare att återanvända en timer flera gånger i loopen på STM32 medans på Atmega328 går det alldeles utmärkt? Detta är vad jag kommer fram till som lekman...Jag hoppas jag har fel där. Mer som jag kommit fram till är att det kanske är bästa alternativet för mig att faktiskt behålla den lilla NANO:n med 328 kretsen på. I går så hittade jag en uppdaterad version av NANO:n, den heter NANO Every och har en 8 bitars processor som heter Atmega4809. Jag beställde två stycken som prov... Den går på 5 volt, den har samma fotprint. edit: felstavning

Författare:  adent [ 07.48 2019-09-12 ]
Inläggsrubrik:  Re: Skillnader i timers, prescalers på Atmega och STM32

Swech skrev:
Har man bestämt sig för en åsikt så har man...... :roll:
Hatet mot arduino är lite flyktigt och ändrar sig beroende på de svar som kommer in
nåja, en annan hatade ju Amiga då det begav sig..

Swech


Och jag som tyckte du var vettig :verysad: ;) Men det kanske lagade sig?

Författare:  Swech [ 09.36 2019-09-12 ]
Inläggsrubrik:  Re: Skillnader i timers, prescalers på Atmega och STM32

Atari var myyyyket bättre... om man inte jämförde alla delar så noga.... :D

Swech

Författare:  Icecap [ 11.33 2019-09-12 ]
Inläggsrubrik:  Re: Skillnader i timers, prescalers på Atmega och STM32

Janson1: "...det verkar vara svårare att återanvända en timer flera gånger i loopen på STM32..."

Om det finns en "hög" med timers - varför då återanvända?

Hur många behöver du? Om det är 20 olika sekvenser som ska köras igenom är det en sak, om det är 4-5 saker som ska hända regelbundet är det en annan sak.

Författare:  Janson1 [ 13.02 2019-09-12 ]
Inläggsrubrik:  Re: Skillnader i timers, prescalers på Atmega och STM32

Ja, det är det som är grejen, finns det en driva timers så behöver man inte återanvända. Men Blue Pill, Adafruit, feather m0 mm. är byggda på/runt ganska "små" STM32 kretsar som just bara har 3-4 timers. Hur många timers behöver jag? Svar: vet ej, än...
Jag sitter lite fast i Arduinostuket men jag har skaffat CubeMX och Atollic och ett par Nucleomoduler, en 103 och en 446 tror jag den heter. Men att få till nåt vettigt (för mig) av detta blir en ganska lång startsträcka. Visst, att få till en blinkande lysdiod var framkomligt men en hel ECU-styrning är det mer meck med... Och där tror jag att jag kommer att gå bet? Eftersom jag programmerat i högnivå så vet jag ju inte riktigt vad som händer i källaren. Att hitta dels dokumentation på begripligt sätt (gärna svenska) och dels hitta lättöverskådliga exempel på programmering är inte det lättaste. Jag har fått låna en bok på prov om STM32, 850 sidor engelska. Jag är nu på sid 90... Här är senaste alstret som fungerar bra på NANO:n
Kod: [Expandera/Minimera] [Hämta] (Untitled.txt)
    // Nu helt ny med Interrupt på vevpin (2) 2019-05-13 och inlagd 2019-08-xx med en del småjusteringar i const. (se Lenovos program, nu inlagt)                                                               
    // 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)
    const byte startmangd = 32;         // 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 = 4;             // 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 = 4.6;// Vid tomgång/drift ges en ny "senasteinsprutningstid" som behålls sedan. (högre tal ger senare tändning)
    const byte tidigasteinspr = 240;     // 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 = 1.8; // 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 = 3000;  // Bestämmer när mjukstarten går ur (omslagspunkt) (900 = brytvarv 450 RPM) skall vara 1200!!
    const int omslagmillimicro= 4000;   // 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 = 1140;         // tomgångsvarvet 500 uS motsvarar ca 800 Rpm (545)(550)
    const byte hogstavarv = 210;         // fullgasvarvet 90 uS motsvarar ca 4000 RPM  (90) (112)

                // dom olika variablerna
    float senasteinspr = 2.5;         // senaste insprutningstid (vid start upp till tomgång)(6.0 = 3 vevaxelpulser = 18 grader delaytid(2.0) Tomgångsförtändning.
    int fasttid = 180;                // 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;                  // pulstid, föregående pulstid
    unsigned int delta, delta2;       // 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; // nuvarande tandlängd
    volatile unsigned long VEVTAND_start; // tandstart
    unsigned long prev_langd;             // föregående tandlängd
    volatile int caseRead;                // om case x är läst eller ej
   
                 // Dom olika I/O anslutningarna
    int vevpin = 2;                   // pulsingång vevaxelgivare, (aktivt låg).
    int kampin = 3;                   // kamaxelgivarens ingång, (aktivt hög).
    int pulsutpin = 7;                // pulsutgång 2 pulser per varv (kontrollutgång för övervakningen).
    int sprpins [] ={11,10,9,8};      // till spridarna (blir aktivt höga)
    int Disable = 12;                 // aktivt hög stoppar utsignalerna till spridarna
    int sprControl = 13;              // kontrollutgång för spridare till övervakningen
    int elflakt = 6;                  // PWM-utgång till motorns elkylfläkt (måste ha ett tildetecken)
   
 void setup()                         // körs bara en gång vid uppstart/reset                   
 {               // här ges alla I/O dess funktion   
   pinMode(vevpin, INPUT_PULLUP);     // satt vevpin som ingång (2)
   attachInterrupt(digitalPinToInterrupt(vevpin), VEV_pulse, RISING);      // här blir inpin interruptstyrd                     
   pinMode(kampin, INPUT);            // satt kampin som ingång (3)
   pinMode(sprpins[visare], OUTPUT);  // spridarutgångar satta som arrey (11,10,9,8)
   pinMode(sprControl, OUTPUT);       // en spridarutgång som blir hög varje gång en spridare öppnas (13)(Övervakningen)
   pinMode(Disable, INPUT_PULLUP);    // ECU väljare Hög = on, Låg = off (12)
   pinMode(pulsutpin, OUTPUT);        // satt pulsutpin som utgång (2 pulser per varv)(7)(övervakningen)
   pinMode(elflakt, OUTPUT);          // satt som utgång
   
   //Serial.begin(250000);            // bra att ha...
 }

//----------------------------------------Här börjar själva programloopen, denna körs hela tiden------------------------------------------------------------------------------------------
    void loop()
 {     
                                    // Det får plats ca 1700 klockcykler mellan varje x tal(case) (1 till 17)
                                    // Det tar lite mer än 100 mikrosek att läsa av en analogingång,
                                    // så ingen analogRead här, skall vara i case 16!
                                   
                                 
     if (digitalRead(Disable)==LOW)     // Disable låg stänger av ECU:n och gör den passiv
      { 
      delta = 0;                        // Genom att delta (insprutningstid) förblir 0.
      pinMode(sprpins[visare], INPUT);  // Gör om spridarutgångarna till ingångar för att ej belasta
      pinMode(sprControl, INPUT);       // Gör om spridarcontrollen till ingång för att ej belasta
      pinMode(elflakt, INPUT);          // gör om elfläktsutgången till ingång för att ej belasta
      }
     
     else //*
      {
      pinMode(sprpins[visare], OUTPUT); // Vid aktiv så gäller spridarutgångarna som utgångar igen.
      pinMode(sprControl, OUTPUT);      // Vid aktiv så gäller spridarcontrollen som utgång igen
      pinMode(elflakt, OUTPUT);         // Vid aktiv så gäller elfläksutgången som utgång igen
      }                            //*Detta är normalläget, samma som i setup*
     

 
     if (digitalRead(kampin)== HIGH)   // varje gång kamaxelns hempuls detekteras så resetas 4 räknaren
      {
      visare = 0;                      // resetas till 0. dvs cylinder 4 blir aktiv
      }
     
      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 
     case 30:                       
          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
     case 31:
          delvalue = VEVTAND_langd;            // Första pulstid läggs in som deltid 1
     break;
     
     
     case 2:              // Detta case ger andra pulstid + batterispänningskontroll
     case 32:
          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
     case 33:
          delvalue = VEVTAND_langd + delvalue;                    // föregående pulstid + föregående deltid läggs ihop
     break;
       
                                     
     case 4:             // Detta case ger fjärde pulstid
     case 34:
          delvalue = VEVTAND_langd + delvalue;                    // föregående pulstid + föregående deltid läggs ihop
     break; 
                             
       
     case 5:             // Detta case ger femte pulstid
     case 35:
          delvalue = VEVTAND_langd + delvalue;                   // föregående pulstid + föregående deltid läggs ihop
     break;
     
     
     case 6:              // Detta case ger sexte pulstid
     case 36:
           delvalue = VEVTAND_langd + delvalue;                   // föregående pulstid + föregående deltid läggs ihop
     break;
             
       
     case 7:             // Detta case ger sjunde pulstid
     case 37:     
           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
     case 38:
                         // 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
     case 39:
           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
     case 40:
       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
     case 41:               
       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
     case 42:
        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
     case 43:
     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
     case 44:
      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
     case 45:
         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"
     case 46:
     
      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.
          // Serial.println(delta);
           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.
           ondelay = ondelay*1000;               // Ondelay mS blir uS.
           delta = delta*1000;
       }         // 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.
         // Serial.print(delta);
         // Serial.print(" ");
         // Serial.println(delta2);
          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)
       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)
         }
        // Serial.println(visare);
     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
     case 56:
          switch (analogval)
     {
        case 0:   
           gas = analogRead(A0)>>2;           // analogingång för gasreglage 0 till 255( skiftad 2 gånger)
           // tom
        break; 

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

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

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

        case 5:
           // tom
           // tom
        break;                               
     }
     
     analogval ++;                              // räkna upp analogval 1 steg   
       if (analogval > 5)                       // när analogval har blivit 5 så
        {
         analogval = 0;                         // resettas analogval till 0 igen
        }   
    break;     // analalogRead tar ca 120 uS att läsa = 1-2 tänder vid fullvarv
  }                                            // nu är alla switch-case lästa
     if(fart_flakt >= flaktfart)           // om gasfläktens fart ät mer än 255
         {
          fart_flakt = flaktfart;              // så förblir gasfläkt max 255
         }
         analogWrite(elflakt,fart_flakt );     // pulsbreddsmodulerar ut fläktfart mellan grundfart och maxfart (980 hz PWM)
  }
 //-------------------------------------- Nedan är för att leta upp tandluckan, räkna upp tandräknaren,reseta tandräknaren, bestämma motorns duration (varvtal)--------------------------
           
     
 }
  void VEV_pulse()                          //
 {
  long thisLength = micros();              // 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
   //Serial.println(tand);
   if(VEVTAND_langd > prev_langd + fasttid)     // OM nyaste vevtands längd är längre än föregåendes + fasttid
    {                                           // då är luckan hittad
    digitalWrite(pulsutpin, HIGH);              // Då går utpin hög
    tand = 0;                                   // och tandräknaren resetas till 0 (början på tandräkningen)
   
                  // 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-----------------------------------------------------------------------------------------------------------------------       
                                               

Författare:  Janson1 [ 21.19 2019-09-24 ]
Inläggsrubrik:  Re: Skillnader i timers, prescalers på Atmega och STM32

Nästa kanske konstig/dum fråga men först lite bakgrund: Av en händelse så sprang jag på en ny NANO med efternamn Every
Den har en nyare processor Atmega 4809, en 8 bitars med mer timers (bla.) Jag har nu fått hem den, provat mitt ECU-program men det blir nåt slags fenomen, jag vet inte än om det påverkar motorn gång eller ej då jag hittills bara kört hemma på kammaren. Nu till min fråga som fortfarande gäller timers/prescalers: Arduinos IDE, är det speciellt anpassat för Atmega328 och 2560 serien? Jag tycker att den här 328 klarar alla mina behov på ECU:n men känner att jag kanske behöver lite mer kräm, nån mer PWM-utgång, nån mer analogingång etc. Och så fort jag provat en annan processorfamilj, (STM32, Atmega 32) så har mina fungerande funktioner antingen gett upp helt eller fått en massa bieffekter... Så, är IDE:n gjord speciellt för 328:an (2560)???
För varje gång jag provat en annan processorfamilj har det blivit skit!

Författare:  ToPNoTCH [ 21.57 2019-09-24 ]
Inläggsrubrik:  Re: Skillnader i timers, prescalers på Atmega och STM32

Jag tror jag berört detta tidigare.

Det enkla svaret är ja.
Porteringar till andra processorer utöver de "officiella" är oftast egna opensource initiativ.
Därav är vissa porteringar bättre än andra.

Arduino utvecklades ursprungligen för 328 och 2560 som med dagens mått är jäkligt omoderna.
Detta gör att den som porterar måste ta ställning till om att behålla kompatibilitet eller tillföra kommandon för att utnyttja processorn är viktigast.

Ett bra exempel är ESP32 där man lagt till ledc kommandot för att styra den interna LED-Controllern.
Kod med det kommandot går ju inte att köra på annan processor trots att det är "Arduino språk".

Här har man alltså gjort ett val att tillföra processor unik funktionalitet på bekostnad av kompatibilitet.
Andra som porterar kan ha en mer stringent syn för att alla befintlig kod som figurerar skall funka direkt.

Om du ovanpå detta faktum lägger till alla bibliotek som i sin tur fungerar olika (eller inte fungerar alls) med andra processorer, så är komplexiteten och förvirringen ett faktum.

Jag vet att talat om att växla till standard C och jag vill inte verka tjatig. Men det är enligt min uppfattning nära på nödvändigt om du vill nyttja en modern processor fullt ut och verkligen själv förstå hur hela ditt program fungerar.
Om din hobby är ECU och kodningen nödvändigt ont så fattar jag din tvekan. Men om du tycker kodningen är intressant och funderar på fler MCU projekt framöver tycker jag du borde smyga igång lite med C och känna dig för.
Tröskeln kanske inte är så stor som den känns.

Fick för mig att du hade en "Blue Pill" liggandes. Bara att ladda ner Atollic (gratis) och skaffa en St Link programmerare så är du igång.

Författare:  Janson1 [ 05.42 2019-09-25 ]
Inläggsrubrik:  Re: Skillnader i timers, prescalers på Atmega och STM32

Ja detta är väl egentligen svar på min fråga. Jag har Atollic som jag så smått börjat titta på, även ett antal "Blue Pill" moduler.
Till dom har jag i dag en omvandlare från USB till ja, seriellt snitt av något slag, det funkar att programmera med i alla fall. Duger detta ihop med Atollic också, eller måste det vara en ST-Link?

Författare:  ktm_micke [ 12.57 2019-09-26 ]
Inläggsrubrik:  Re: Skillnader i timers, prescalers på Atmega och STM32

Har du tittat på Teenesy jag ska bygga en styrning till en BMW DCT låda o hade först tänkt att ha en arduino men så hittade jag dessa har tänkt att göra ett kort som man dockar på denna blir nog en Teenesy 3.6 en nere i lådan o en inne i bilen med can bus communikation den i lådan läser av växlingsläge (analog HAL) och varvtal skickar till den inne i bilen där den styr solenoiderna totalt 10 st varav 6 st PWM styrda anledningen till att jag måste ha en i lådan med är att jag ska använda original kontakt på lådan o den har bara 13 kablar.
https://www.pjrc.com/teensy/techspecs.html

Författare:  Janson1 [ 19.53 2019-09-27 ]
Inläggsrubrik:  Re: Skillnader i timers, prescalers på Atmega och STM32

Just denna Teenesy har jag inte tittat på. MEN, jag misstänker att Arduinos kompilator inte är den bästa för denna processorn heller... Jag är inte riktigt beredd på att skippa Arduinos IDE så kanske jag gör ett försök? Ktm_micke: Skall du programmera i Arduino eller nåt annan IDE?

Författare:  ktm_micke [ 08.11 2019-09-28 ]
Inläggsrubrik:  Re: Skillnader i timers, prescalers på Atmega och STM32

Ang IDE vet jag inte ännu lutar dock åt arduino

Sida 4 av 4 Alla tidsangivelser är UTC + 1 timme
Powered by phpBB © 2000, 2002, 2005, 2007 phpBB Group
http://www.phpbb.com/