Electrokit Buggfix Plus
Aktuellt datum och tid: 04.15 2018-07-20

Alla tidsangivelser är UTC + 1 timme




Svara på tråd  [ 276 inlägg ]  Gå till sida Föregående  1, 2, 3, 4, 5 ... 19  Nästa
Författare Meddelande
InläggPostat: 22.02 2016-12-14 

Blev medlem: 09.06 2016-12-01
Inlägg: 372
Ort: Marks Kommun
Från början en VNT men den kommer jag att låsa i yttersta läget då jag inte behöver några lågvarvsegenskaper.


Upp
 Profil  
 
InläggPostat: 18.15 2017-03-04 

Blev medlem: 09.06 2016-12-01
Inlägg: 372
Ort: Marks Kommun
Här är mitt alster, vissa delar fungerar och vissa delar fungerar ej. Jag får inte till det. Allt code är skriven i Arduinospråk, tror jag.
Och: jag är ny på detta, började i slutet av oktober -16, jag har aldrig programmerat någonting med nån reda förut. Så därför ser det nog bonnit alltihopa. Men, håll till godo!
Kod: [Expandera/Minimera] [Hämta] (Untitled.txt)
    int kampin7 = 7; //kamaxelgivarens ingång, (aktivt låg). används ej än...
    int vevpin2 = 2; // pulsingång vevaxelgivare, (aktivt hög).
    int utpin3 = 3; // pulsutgång 2 pulser per varv (kontrollutgång)
    int sprpin1 = 8; // till spridare 1 (blir aktivt hög)
    int sprpin2 = 9; // 2 används ej än
    int sprpin3 = 10; // 3 -:-
    int sprpin4 = 11; // 4 -:-
    long puls, priv; // här läggs den senaste och föregående pulstiden in i microsekunder
    long starttid, stopptid, sluttid, delta; // starttid, stopptid, sluttid och delta i microsek.
    float error, mduration, bduration; // = varvfelet = motorduration/börduration i decimalform
    byte x = 0; // vevpin2 räknare 0 till 28
    byte starttand, gas, turbo, vtemp;  //starttand = vilken tand där spridaren skall öppna.
      // och gas 0-255, turbo 0-127, vtemp 0-127         
    //________________________________________________________________________________________________

    void setup()
    {
      pinMode(vevpin2, INPUT); //sätt vevpin2 som ingång                           
     
      pinMode(sprpin1, OUTPUT);   // spridarutgång 1  ben 8                                                                 
      pinMode(sprpin2, OUTPUT);  //                2  ben 9                                                                                                                             
      pinMode(sprpin3, OUTPUT);   //               3  ben 10                                               
      pinMode(sprpin4, OUTPUT); //                 4  ben 11                                                           
      pinMode(utpin3,  OUTPUT); // sätt utpin3 som utgång
      Serial.begin(250000);    // bra att ha
     
    }
    //_________________________________________________________________________________________________________

    void loop()
    {
       
          // Det får plats ca 1700 klockcykler mellan varje x tal (1 till 27)  Det tar ca 100 mikrosek att läsa av en analogingång, så max en per lucka.                         
     
       
                                             
       if (digitalRead(utpin3)== HIGH)// när utpin3 går hög startar 0-25 räknaren
        {
         x = 0; // säkerställer att vevpin2 räknaren börjar på 0
        }
     
         x  ++ ; //räkna upp ett steg för varje ny puls Fungerar

       
     
       if (x == 1) // Vid första vevpinpuls Gör:
       {
        gas = analogRead(A1)>>2;   // analogingång 0 till 255( skiftad 2 gånger)Fungerar
       }
       
       if (x == 2) // Vid andra vevpinpuls Gör:
       {
       // turbo = analogRead(A0)>>3; // analogingång för turbotryck 0 till 127 (skiftad 3 gånger)
       }
       
       if (x == 3) // Vid tredje vevinpuls Gör: osv
       {
       // ledigt
       }

       if (x == 4)
       {
        bduration =map(gas,0, 255, 660, 115); // motorns börvärde från gaspoten. 660 mS =tomgång, 115 mS = fullvarv. (ca 750 rpm till ca 4500 rpm)
       }// 660 - 115 mS = 750 till 4500 rpm Fungerar

       if (x == 5)
       {
       // ledigt
       }

       if (x == 6)
       {
        mduration = priv; // motorns pulstid i mikrosek ger motorns fart. 660 - 115 mS
       } // 660 - 115 = 660 - 115 mS Fungerar
       
       if (x == 7)
       {
        error = (mduration / bduration); // felet i mikrosekunder mellan är och börvärde för motorns fart baserat på pulslängderna.
       } // 0.0 - 6.0 Fungerar
       
       if (x ==8)
       {
       // ledigt
       }
       
       if (x == 9)
       {
       // ledigt
       }

       if (x==10)
       {
       // ledigt
       }
       
       if (x ==11)
       {
       // ledigt   
       }
       
     
       
       if (x==12)
       {
       starttand = map(priv,1300, 130, 21, 18);   // y1 = spridarstart från tand 21 vid tomgång till tand 18 vid fullvarv, ca  6-36 grader FÖDP
       }// förtändningen i 4 fasta steg, fungerar

       if(x == 13)
       {
       // ledigt   
       }
     
     

       if (x == 14)
       {
       // ledigt
       }
       
       
       if (x ==15)
       {
       // ledigt
       }
     
       if (x == starttand)  // när rätt puls är räknad, sätt sprpin1 hög, (tand 21 till 18)
       {
       starttid = micros(); // här vill jag ha en markör som signalerar i micros() att sprpin1 går hög. -------<<<<<<<<<--------Kolla
       digitalWrite (sprpin1,HIGH); //spridarpinne hög, insprutning börjar. pin 8   Fungerar 
       } // alternatit att micros() nollställs när sprpin går hög?? ------------------------------------------<<<<<<<<<<--------Kolla
     
       delta = mduration * error ; // felkorrigeringsvärde Fungerar
       sluttid = starttid + delta; // själva uträknaren fungerar
       if (delta, micros() >= sluttid, micros() ) // Detta fungerar nog inte!!!   --------------------------------<<<<<<<<<-------Kolla
       {
      digitalWrite (sprpin1,LOW); //spridarpinne låg, insprutning avslutad pin 8 denna fungerar nog inte heller ----------<<<<<-Kolla
       } // Antingen stänger den av direkt, det blir bara en spik eller stänger den inte av alls. ---------------<<<<<<<<-------Kolla
       
      Serial.print(starttid);
      Serial.print(" ");
      Serial.print(delta);
      Serial.print(" ");
      Serial.println(sluttid); // Hela serialpaketet fungerar men stör övriga funktioner vid lite högre farter, så bara för test.
     
     
     
       

       if (x == 26 || x < starttand)
       {
      digitalWrite (sprpin1, LOW); // För att säkerställa att spridaren stängs av senast 18 grader efter ödp (tand 26)
       }// Denna funktion tar över när tidsfunktionen inte går           Fungerar
       if (x == 26)
       {
 
       }
 
       if (x >= 27) // efter 28 pulser sätt x till 0
       {
       x = 0; //reseta 0-28 räknaren Fungerar
       }
     
        priv = puls;  // gämför ny pulstid med föregående pulstid
        puls = pulseIn(vevpin2, LOW); //Triggar på nersidan

       if  (puls > priv+25) // jämför om ny pulstid i mikrosekunder är större än föregående + 25 mikrosek.
        {
         digitalWrite (utpin3, HIGH);  // utpin_ blir hög när pulsluckan återgår till pulser
        }

       if  (puls < priv-25) // jämför on ny pulstid är mindre än förgående - 25 mikrosek.     
        {   
         digitalWrite (utpin3, LOW); // utpin_ blir låg igen nästa uppgång i pulståget.
        }
    }
    // end void loop()

    //________Hela detta paketet från: if (x == 27) Fungerar________________________________________________________________________________________________








Upp
 Profil  
 
InläggPostat: 20.26 2017-11-21 

Blev medlem: 20.20 2017-11-21
Inlägg: 2
Lite nyfiken på hur det har gått för dig Jansson1? har du fått igång motorn med din arduino? Mvh


Upp
 Profil  
 
InläggPostat: 08.34 2017-11-22 

Blev medlem: 09.06 2016-12-01
Inlägg: 372
Ort: Marks Kommun
Hej, vad roligt att nån läser, ännu roligare om någon frågar också. Jo, en liten resumé. Det har hänt en del sen sist, jag är med ett annat maskinforum som jag har bollat problemen med och med lite hjälp av det forumet och väldigt mycket jävlar anamma har jag fått till ett första (på labb-bänken) fungerande alster. Den senaste svåraste utmaningen var att få till variabel avstängningstid av spridarna, ett måste för att det överhuvudtaget skall vara lönt att fortsätta. I dag har jag fått till det och jag är även inne på att få till en finjustering av insprutningens början men är inte riktigt nöjd där än, jag kommer inte att lägga så mycket krut på det än då det kanske inte ens behövs. Förövrigt har jag gjort lite omändringar här och var i programmet för att (inbillar jag mig) göra det lite mer motorvänligt. Jag har även hunnit med att få till en övervakningsArduino som ligger ganska parallellt med ECUerna, jag har två separata ECU, A och B som jag sen kan välja vilken som skall vara aktiv. ÖvervakningsArduinon har en display (4 x 20) som visar dom viktigaste värden såsom varv, gasläge (effekt) temp. mm. Sen kan man ansluta datorn och se mer värden, förutom ovanstående så kan man se när spridaren öppnar och hur länge plus lite fördjupningar av div värden. Jag har nu byggt hela alstret på en experimentplatta bestående av 3 st Arduino NANO, 3 st spänningsregulatorer, 4 st transistorslutsteg för att kunna driva spridarna och plintar till alla upptänkliga kablar.
Och testat det statiskt mot scopet och datorn och det verkar funka fullt ut. Jag skaffade även mönsterkortsprogram från Dip Trace så nu har det även vuxit fram ett dubbelsidigt mönsterkort. Problem kvar att lösa är kretsen som gör om vevaxelgivarens sinussignal till användbart pulståg så Arduinon blir nöjd. Jag har i dag en krets som heter MAX 9926 som skall kunna lösa detta, väntar på en liten adapterplatta så jag kan ansluta den till yttervärlden. Om intresse finns så kan jag lägga ut sketchen i senaste fung. upplaga. Och även övervakningssketchen.
Edit: felstafat...


Upp
 Profil  
 
InläggPostat: 20.35 2017-11-22 

Blev medlem: 20.20 2017-11-21
Inlägg: 2
Vad kul att du har fått igång motorn, jag har följt din tråd och det låter som du verkligen har avancerat och lärt dig endel på vägen. :) Jag skulle gärna vilja se din sketch :) Jag är ganska ny på Arduino och har ett liknande projekt jag tänkt på länge och det skulle va kul att se din sketch i läro syfte:)


Upp
 Profil  
 
InläggPostat: 21.38 2017-11-22 

Blev medlem: 09.06 2016-12-01
Inlägg: 372
Ort: Marks Kommun
Så att inga fel uppstår, jag har inte ens försökt få igång motorn ännu. Allt är på skrivbordet hemma. Min "motor" är en simulator Arduino som efterliknar pulserna från vev och kamaxelgivare i farter från ca 400 till 4500 RPM.
Men min sketch ser ut så här, senaste fungerande versionen...
Kod: [Expandera/Minimera] [Hämta] (Untitled.txt)
int kampin7 = 7; //kamaxelgivarens ingång, (aktivt låg)
    int vevpin2 = 2; // pulsingång vevaxelgivare, (aktivt hög).
    int utpin3 = 3; // pulsutgång 2 pulser per varv (kontrollutgång)
    int sprpins [] ={8,9,10,11}; // till spridarna (blir aktivt hög)
    int sprControl = 13;// kontrollutgång för spridare till övervakningen.
    int turbokorr; // utgående felkorrigeringsvärde från turbogivare
    int disable = 12;// aktivt hög stoppar utsignalerna till spridarna
    long puls, priv, delta, starttid, sluttid, turbovalue, delvalue; // senaste och föregående pulstiden in och start,slut i microsekunder,+ klart turbovärde.
    float error; // error = varvfelet i decimalform
    float starttandf; // starttand i decimalform.
    float  mduration, bduration; //  varvfelet = motorduration/börduration i decimalform
    byte x = 0; // vevpin2 räknare 0 till 28
    byte  gas, turbo, pekare, starttand;  //starttand = vilken tand där spridaren skall öppna.
      // och gas 0-255, turbo 0-127, tmp för att välja rätt spridarutgång         
    //________________________________________________________________________________________________

    void setup()
    {
      pinMode(vevpin2, INPUT); //satt vevpin2 som ingång                           
      pinMode(kampin7, INPUT_PULLUP);// satt kampin som ingång .
      pinMode(sprpins[pekare],OUTPUT);  // 8,9,10,11 satta som utgånsarrey
      pinMode(sprControl, OUTPUT);// en spridarutgång som blir hög varje gång en spridare öppnas.
      pinMode(disable, INPUT_PULLUP);// ECU väljare Hög = on, Låg = off.
                                                                                                                                                pinMode(utpin3,  OUTPUT); // sätt utpin3 som utgång
      Serial.begin(250000);    // bra att ha vid tester, skall var bortkopplat vid högre farter.(stör)
     
    }
    //_________________________________________________________________________________________________________

    void loop()
    {
       
          // Det får plats ca 1700 klockcykler mellan varje x tal (1 till 27)  Det tar ca 100 mikrosek att läsa av en analogingång, så max en per lucka.                         
     if (digitalRead(disable)==LOW) {  // Disable låg stänger av ECU:n och gör den passiv
      puls = 0;// genom att pulstiderna förblir 0.
      pinMode(sprpins[pekare],INPUT); // gör om spridarutgångarna till ingångar.
      pinMode(sprControl, INPUT); // gör om spridarcontrollen till ingång.
     }
    else {
      pinMode(sprpins[pekare],OUTPUT); // vid aktiv igen så gäller spridarutgångarna som utgångar igen.
      pinMode(sprControl, OUTPUT); // vid aktiv så gäller spridarcontrollen som utgång igen
     }
       
        x  ++ ; //räkna upp ett steg för varje ny puls, kommer från pulseIn()funktionen,  Fungerar
       
       if (digitalRead(kampin7)== LOW) { // varje gång kamaxelns hempuls detekteras så resetas 4 räknaren
        pekare = 0; // resetas till 0
       }
     
       if (x == 1) // Vid första vevpinpuls Gör:
       {
        gas = analogRead(A1)>>2;// analogingång 0 till 255( skiftad 2 gånger)Fungerar
        delvalue = priv;// föregående pulstid läggs in som deltid 1
       }
       
       if (x == 2) // Vid andra vevpinpuls Gör:
       {//0,034 v/steg
        turbo = analogRead(A0)>>3; // analogingång för turbotryck 0 till 127 (skiftad 3 gånger)
        delvalue = priv + delvalue; // föregående pulstid + föregående deltid läggs ihop
       }// atm = 1 volt, fullt turbotryck = 2,4 volt (1,4 bar över atm)>> A0 = 29 =atm, A0 = 70 = fullt turbotryck
       
       if (x == 3) // Vid tredje vevinpuls Gör: osv
       {
      turbokorr = map(turbo, 0, 127, 100, 300); // här matas in 0 till 80 som max. invärdet bör bli 70, omgjort till korrfaktor 10
      delvalue = priv + delvalue;// föregående pulstid + föregående deltid läggs ihop
      if (turbokorr <=0)
          {
           turbokorr = 1;  // för att undvika minusvärden
          }
       } //0 till 127 =  100 till 300

       if (x == 4)
       {
        bduration =map(gas,0, 255, 660, 115); // motorns börvärde från gaspoten. 660 mS =tomgång, 115 mS = fullvarv. (ca 750 rpm till ca 4500 rpm)1250
       delvalue = priv + delvalue; // föregående pulstid + föregående deltid läggs ihop
       }// 660 - 115 mS = 750 till 4500 rpm Fungerar

       if (x == 5)
       {
        turbovalue = (mduration * turbokorr); // detta värde minskar spridarens ontid när värdet blir högre än faktor 1
        delvalue = priv + delvalue;// föregående pulstid + föregående deltid läggs ihop
       }
     
       

       if (x == 6)
       {
        mduration = delvalue/9; // motorns totala pulstid i mikrosek dividerat med 9 (4x2+1)  ger motorns fart. 660 - 115 mS
       }  // 660 - 115 = 660 - 115 mS Fungerar
       
       if (x == 7)
       {
        error = (mduration / bduration); // felet i mikrosekunder mellan är och börvärde för motorns fart baserat på pulslängderna.
       } // 0.0 - 6.0 Fungerar
       
       if (x == 8)
       {
       //error = error - 1;
       if (error <=0)
         {
          error = 0;// för att ej få minusvärden
         
         }
       }
       if (x == 9){
        if (error >=6){
          error = 6;// för att få max 6.0 som error
        }
       }
       
       
     

       if (x== 10)
       {
        //ledigt
       }
       
       
       
       if (x == 11)
       {
        // ledigt 
       }
       
       if (x==12)
       {
        // ledigt
       }
     
       
       if(x == 13)
       {
        // ledigt   
       }
     
       if (x == 14)
       {
        // ledigt
       }
       
       if (x ==15)
        {
        starttandf = (mduration-130.0)*(22.0-17.0)/(1300.0-130.0);// +18 
        if ((starttandf >= 1)|| (starttandf <=1)){ // en test för att få variabel tillslagstid av spridare
          starttandf = 0;
        }
        starttand = map(mduration,1300.0, 130.0, 22.0, 17.0);   //  spridarstart från tand 21 vid tomgång till tand 18 vid fullvarv, ca  6-36 grader FÖDP
        //starttandf = starttandf -
        if (starttand >= 22.0)
          {
           starttand = 22.0;
          }
        }   // förtändningen i 4 fasta steg, fungerar   Tand 23 är TDC
       
       
       

       if (x ==16)
       {
        delta = (mduration * error) - turbokorr ; // felkorrigeringsvärde Fungerar
       if (delta <=0)
         {
          delta = 0;// för att ej få minusvärden.
         }
         Serial.print(starttand);
         Serial.print(" ");
         Serial.println(starttandf);
       }
     
       
       if (x == starttand)  // när rätt puls är räknad, sätt sprpin1 hög, (tand 22 till 17)
       {
        starttid = micros(); //Den sätter en markör vid spridarstart.
        digitalWrite (sprpins[pekare],HIGH);//spridarpinne hög, insprutning börjar. pin tmp 8,9,10 eller 11
        digitalWrite(sprControl, HIGH);
        delayMicroseconds(delta); // Nyaste tankesättet, skiter i pulseIn() och väntar istället på offtiden
       }
   
        sluttid = micros(); // håller reda på när sluttiden skall vara
       
       if ((delta <= sluttid - starttid)|| (delta <=delvalue /2)) //
       {
        digitalWrite (sprpins[pekare],LOW); //spridarpinne låg, insprutning avslutad pin tmp 8,9,10 eller 11
        digitalWrite (sprControl, LOW);
       }

     
  //_________________________________________________________________________________________________________________________________________________________   
        priv = puls;  // lägger in den förra pulstiden i värdet "priv"
        puls = pulseIn(vevpin2, LOW, 20000); // Ett färdigt kommando som väntar in nästa puls, mäter offtiden, low
        // vid stillastående motor blir det en timeout var 0,2 sekund.
       if  (puls > priv+25) // jämför om ny pulstid i mikrosekunder är större än föregående + 25 mikrosek.
        {
         digitalWrite (utpin3, HIGH);  // utpin3 blir hög när pulsluckan återgår till pulser
         x = 0; // resetar 0 till 28 räknaren
         pekare=pekare+1;// räknar upp spridarpinneräknare
         if (pekare > 3)// när fjärde pinnen är nådd börjar den om igen
          {
          pekare = 0;// spridarpinne 1 är igång igen
          }
        }
       
       if  (puls < priv-25) // jämför on ny pulstid är mindre än förgående - 25 mikrosek.     
        {   
         digitalWrite (utpin3, LOW); // utpin_ blir låg igen nästa uppgång i pulståget.
        }
    }
   
    // end void loop()

    //________Hela detta paketet Fungerar________________________________________________________________________________________________




Och övervaknings-sketchen
Kod: [Expandera/Minimera] [Hämta] (Untitled.txt)
 #include <LiquidCrystal.h>
    char x;
    int ecuAktiv = 2; // pulsingång vevaxelgivare, (aktivt hög).
    int inpin3 = 3; // pulsingång 2 pulser per varv till beräkning av motor/propvarv.
    int motorvarvut = 9; // till motorns varvräknare PWM
    int propvarvut = 10; // till propellervarvräknare PWM
    int gasvalue; // gasvärde från poten 0-1023
    int turbovalue;// turbovärde från tryckgivaren 0-1023
    int sprSignalin = 8;// ansluts till valfri spridarutgång eller sprcontrol, valfritt
    float sprTid; // spridaröppningstid i % av halvt motorvarv
    float liter;  // liter/timma
    int rs=4, en=5, d4=6, d5=11, d6=12, d7=13;// till displayanslutningar
    LiquidCrystal lcd(rs,en,d4,d5,d6,d7);// till display
    long varvtalprop; // värde i microsek
    long puls, varvtalmotor;// värde i mikrosek
    int readECUAvoltage;
    int readECUBvoltage;
    int readbattVoltage;
    int engineTemp;
    int turboAirTemp;
    int ambientTemp;
    int atmTryck;//
    float ECUAvoltage;
    float ECUBvoltage;
void setup() {
      pinMode(ecuAktiv, INPUT_PULLUP); //satt vevpin2 som ingång                           
      pinMode(motorvarvut, OUTPUT);   // till motorvarvräknare PWM                                                             
      pinMode(propvarvut, OUTPUT);  // till propvarvräknare  PWM                                                                                                                         
      pinMode(sprSignalin, INPUT);   // från en valfri spridare                                                                                                     
      pinMode(inpin3,  INPUT); // ingång för att beräkna motor/propvarvtal 
      lcd.begin(20,4);
      lcd.setCursor(0,0);
      lcd.print("Diesel ECU ver.1.0");// visar versionsnummer
     
      lcd.setCursor(0,1);
      lcd.print("Byggd av J Berglund");//
     
      lcd.setCursor(0,2);
      lcd.print("Motor VW PD 135 hp");//
     
      lcd.setCursor(0,3);
      lcd.print("Mjukvara 1.0 rev 0");//
      Serial.begin(250000);    // serial utgång till datorn
      delay(5000);
}

void loop() {
  gasvalue = analogRead(A0);
  turbovalue = analogRead(A1);
  atmTryck = analogRead(A2);
  readECUAvoltage = analogRead(A3);
  readECUBvoltage = analogRead(A4);
  engineTemp = (5.0* analogRead(A5)*100.)/1024;// använder LM-35 tempgivare
  turboAirTemp = (5.0* analogRead(A6)*100.)/1024;// använder LM-35 tempgivare
  ambientTemp = analogRead(A7);
 
  gasvalue = map(gasvalue,0,1023,0,100);// 0 till 100 % effekt börvärde
  turbovalue = map(turbovalue,0,1023,400,4000);// 400 till 4000 mBar
  atmTryck = atmTryck *4;//  absoluttryck i mBar.
  ECUAvoltage = readECUAvoltage *(6.0/1023.0); // ECU A drivspänning till 6 volt
  ECUBvoltage = readECUBvoltage *(6.0/1023.); // ECU B drivspänning till 6 volt
  ambientTemp =map(ambientTemp,0,1023,-20,60);// omgivningstemperatur -20 till 60 G c med en NTC
 
  sprTid = pulseIn(sprSignalin, HIGH); // mäter in valfri spridares ontid
  sprTid = sprTid/puls*100.;// gör om ontiden från microsek till procent
  liter = sprTid * varvtalmotor /150;//: /150 skall provas ut...

  if (digitalRead(ecuAktiv)== HIGH){
    x =  'A';
  }
  else {
    x =  'B';
  }
 
  lcd.setCursor(0,0);
  lcd.print("Propeller ");
  lcd.print(varvtalprop);
 
 lcd.setCursor(0,15);
  lcd.print("     ");     
  lcd.print("  RPM");
 
  lcd.setCursor(0,1);
  lcd.print("EFFEKTSETTING ");
  lcd.print(gasvalue);
  lcd.print(" %");
 
  lcd.setCursor(0,2);
  lcd.print("Motortemp ");
  lcd.print(engineTemp);
  lcd.print(" gr. C.");
 
  lcd.setCursor(0,3);
  lcd.print("FUELFLOW ");
  lcd.print(liter);
  lcd.print(" L/h");
 
  Serial.print("Gasvalue ");// skriver ut div realtidsvärden
  Serial.print(gasvalue);
  Serial.print("% ");
  Serial.print("Turbovalue ");
  Serial.print(turbovalue);
  Serial.print(" Bar  ");
  Serial.print("Turbo Air Temp ");
  Serial.print(turboAirTemp);
  Serial.println(" Grader C.");
  Serial.print("Absoluttryck  ");
  Serial.print(atmTryck);
  Serial.print(" mBAR  ");
  Serial.print("ECU A ");
  Serial.print(ECUAvoltage);
  Serial.print(" Volt  ");
  Serial.print("ECU B ");
  Serial.print(ECUBvoltage);
  Serial.println(" Volt");
  Serial.print("Engine Temp ");
  Serial.print(engineTemp);
  Serial.print(" Grader C. ");
  Serial.print("Ambient Temp ");
  Serial.print(ambientTemp);
  Serial.print(" Grader C.");
  Serial.print(" ECU ");
  Serial.print(x);
  Serial.println(" Aktiv");
  Serial.print("Motor ");
  Serial.print(varvtalmotor);
  Serial.print(" RPM");
  Serial.print("  Propeller ");
  Serial.print(varvtalprop);
  Serial.print(" RPM");
  Serial.print(" Pulswidth ");
 
  if (varvtalmotor >=5100){// max pulslängd tomgång, < 5000 mikrosek
    varvtalmotor = 0; // om stillastående/startmotorvarv så blir motorvarvet noll till ev varvräknare
  }
  varvtalmotor = map(varvtalmotor,0,5000,0,255);// 0 till 5000 mikrosek görs om till 0 till 255
  analogWrite(motorvarvut,varvtalmotor); // ger ut en pwm signal 0 till 255 beroende på motorns varvtal
  analogWrite(propvarvut,varvtalmotor * 0.625);// ger ut en pwm signal som är konverterad för att passa propellervarvet
  Serial.print(varvtalmotor);// fortsättning div realtidsvärden
  Serial.print(" spridare ");
  Serial.print(sprTid);
  Serial.println(" % open");
  delay(100);
        puls = pulseIn(inpin3, LOW); // väntar in nästa puls, Triggar på nersidan
        // vid stillastående motor blir det en timeout varje sekund.
      varvtalmotor = (1000000/puls)*30.06;// pulsbrädden görs om till RPM motor
      varvtalprop = varvtalmotor *0.625;// RPM motor görs om till RPM propeller
     
     
}

Nu vet jag inte om jag ändrat på något då jag i princip kontinuerligt förändrar/förbättrar/försämrar sketcherna.


Upp
 Profil  
 
InläggPostat: 22.26 2017-11-22 

Blev medlem: 15.21 2006-04-30
Inlägg: 19
Ort: Alingsås
Hej och kul projekt Janson! =)

Jag programmerar maskinkod och assembler på Mitsubishis äldre styrboxar. Har även programmerat massor med LH 2.4 bla Volvo, Porsche, BMW, osv.

Håller med om att Arduinoprylarna är kul att pilla med. Tyvärr är dom hopplöst svajiga med att hålla takten. Jitter ligger på ca 6 usec med portmanipulering.
Ser på din kod att du inte använder interrupt. Stämmer det?

Mvh. Kim.


Upp
 Profil  
 
InläggPostat: 06.46 2017-11-23 

Blev medlem: 09.06 2016-12-01
Inlägg: 372
Ort: Marks Kommun
Stämmer, använder inga interrupt, mest för att jag aldrig fått till det. Jag kan faktiskt se att på scopet att det är inte exakt stabilt, trodde mest det var mätfel men det kan ju vara som du skriver med jittret. Nu har jag aldrig programmerat förr och har inget att jämföra med. Men, kan du utveckla det här med svajighet och jitter?


Upp
 Profil  
 
InläggPostat: 07.00 2017-11-23 

Blev medlem: 09.06 2016-12-01
Inlägg: 372
Ort: Marks Kommun
Skall väl tillägga att det finns ett annat sätt att anropa pinMode och digitalWrite som ger betydligt snabbare responstid, alltså många mindre cycler för att tex sätta spridare hög och låg, jag har funderingar på att prova detta, jag kanske tom. blir tvungen då jag börjar närma mig taket av vad sketchen klarar av, nu har jag ju satt maxvarvet till 4500 rpm men vid stressskörning börjar något hända vid 6-7 tusen rpm. Jag tror i och för sig aldrig det stannar helt utan det börjar fungera igen så fort varvet minskas under kritiskt varv.


Upp
 Profil  
 
InläggPostat: 07.46 2017-11-23 

Blev medlem: 15.21 2006-04-30
Inlägg: 19
Ort: Alingsås
Själva svajet dvs jittret kommer just ifrån att Arduinokodning är baserat på en main loop. Kallas ibland för sekventiell exekvering. Tanken med just detta är att det blir enkelt att skriva kod och låta processorn sköta allt annat som matematik och beräkningar. Allt ok så här långt.

Men när man kliver in och skall styra tidskritiska saker, tex köra en motor så räcker det inte till längre.
En motor på tomgång är inte så störd av lite fördröjningar. Inte heller på högre varv utan last.
Men den dagen du lägger last på motor och koden sitter och sover när det behövs bränsle då blir inte motorn gammal. Tänk dig själv att endast andas med näsan. En slapp kväll framför TVn eller kort promenad störs knappt av att nån nyper ihop näsborrarna på dig då och då.
Men skulle detta ske under en sprint på löpbandet, en brant uppförsbacke eller maratonlopp så skulle vi garanterat få hjärtstillestånd.
Samma sak händer när motor inte styrs tidskritiskt. Kritiskt i detta fall betyder viktigt samt prioriterat. Inget annat.

Så till interrupt. På Arduino har dom gjort det görenkelt att använda interrupt. Man ansluter en bit kod till en händelse. Tex öka en räknare varje gång man passerar en tand på triggerplattan. Här kan du använda alla sorters triggerkod precis som på oscilloskopet. Rising, falling, change.
Man lagrar därefter in detta i säg 4 olika variabler. Vi kallar dom cylinder cycles.
Nu har du en annan interruptkod som triggas av en sanningstabell som visar vart i cykeln motorn befinner sig.
Denna är livsviktig för motorn behöver olika mycket bränsle och tändvinkel beroende av varv och last. Tänk på det som en PWM-signal med både varierande frekvens och pulsbredd. I Arduinon så regleras endast pulsbredden men frekvensen är statisk. Detta måste göras om. Men det är också döenkelt med ett interrupt och counter.

Summa på vilka interrupt som man kan behöva så här i början är;
1. master counter. Dvs godtyckligt räknare för hela 720 graders otto cykeln.
2. Trigger interrupt.
3. Scheduler. Dvs schemaläggare. Detta är din sanningstabell.
4. Ny PWM-styrning för bla spridare.

För om du räknar på 1/4500 varv får du 222 microsekunder. Det blir värre, tro mig. Om vi då redan har 6 usec jitter åt båda håll. Dvs 12/222 ger 5,5% konstant fel per varv! Detta är enormt i motorsammanhang. Dvs 720*0,055 är 39,6 grader i båda riktningarna dvs både innan och efter dödläge. Ifall vi nu räknar med det som vår referens. Men det är detsamma vilken del av cykeln vi använder.

Med interrupt försvinner dessa problem nästan helt. Inte till 100% men bra nära.

Hoppas denna infon var till hjälp. =) Kan nog slänga ihop lite bilder och kod från oscilloskop och Arduino åt dig så du får testa själv.

Mvh. Kim.


Upp
 Profil  
 
InläggPostat: 09.48 2017-11-23 
Användarvisningsbild

Blev medlem: 16.34 2004-09-06
Inlägg: 21693
Ort: Sparreholm, Södermanland N 59° 4.134', E 16° 49.743'
Mycket bra förklaring :tumupp:


Upp
 Profil  
 
InläggPostat: 17.28 2017-11-23 

Blev medlem: 09.06 2016-12-01
Inlägg: 372
Ort: Marks Kommun
Jag håller med, en bra förklaring. Jag har ju inte kört mot en riktig motor men det är fullt möjligt att det inte kommer att funka alls. Däremot använder jag inte den inbyggda PWM regleringen för spridarna utan använder några fasta påslagstider och helt variabel fråntid beräknat på motorns fart. Däremot uppfattar jag inte felet så högt som upp till +-40 grader, utan bara någon grad om ens det, men det är som sagt var när jag kör mot en "Arduinomotor"
Det verkar som att du Kim har den kunskapen som jag söker för att ev lyckas...
Så, har du möjlighet att "slänga ihop" nåt så vore jag tacksam!


Upp
 Profil  
 
InläggPostat: 20.30 2017-11-23 

Blev medlem: 15.21 2006-04-30
Inlägg: 19
Ort: Alingsås
Tack Tecno & Janson!

Du skall veta en sak Janson; det projekt du valt kommer ge dig massor med insikter om programmering, matematik, mätmetoder, mekanik, osv.
Att driva just en "levande" mekanisk maskin är väldigt svårt, men och mycket givande. Och man lär sig massor.
Det finns inget rätt eller fel i just denna kategorin av projekt. Varför säger jag så? Jo för att motorn som vi känner den är ca 150 år gammal. Och fortfarande finns
det massor av olika bil- och motortillverkare. Det visar och har bevisats gång på gång att revolutionerna sker inte i dom stora forskningslabben. Dom sker i folks garage.
Sedan köper dom stora tillverkarna kunskapen, eller helt enkelt en prototyp av den uppfinnaren. Svårt att tro. Men kolla bara på Svenska Christian von Koenigsegg och
hans bidrag till motorvärlden. En av dom senare uppfinningarna löser massor med problem, den steglösa växellådan. Visst har såna funnits i massor förr, men inte en som
funkar med stort kraftuttag och hög hastighet. Och dessutom innehåller så få rörliga delar som möjligt och nästan är passiv i drift.

Så fortsätt med det du gör. Uppfinn dina egna mätmetoder, skriv dina egna loggerprogram och analysverktyg, och viktigaste av allt, våga ta steget till att testa den på en
riktig motor. Du kommer se att den enkla best vi tar för givet under huven är nåt helt annat när man bryter ner dess cykel under endast ett varv, eller en sekund, osv.
Vibrationer från motorfästen syns i dina loggar, du tvivlar. Undrar vad det är. Du ser vad som ser ut som en impulssignal på loggade värden från hastighetsmätarn, inser att
det är hastighetsmätarvajern som resonerar vid växlingar. Och så vidare.

Lycka till! Och låt ingen säga till dig hur saker och ting skall göras. Men undvik också att uppfinna hjulet igen. =)

Mvh. Kim.


Upp
 Profil  
 
InläggPostat: 20.43 2017-11-23 

Blev medlem: 09.06 2016-12-01
Inlägg: 372
Ort: Marks Kommun
Bilaga:
IMG_20171123_201442.jpg
Jodå, jag insåg ganska tidigt att det är nog ett av dom större projekt man kan krama ut av en Arduino och en som aldrig programmerat förut. Så jag ger mig inte så lätt... Var skall motorn användas till då? Ett flygplan om jag kommer så långt nån gång... Så jag kräver ganska mycket, dubbelt där det går och så mycket felsäkert som möjligt.
Jag har nu fått en MAX9926 krets som skall göra om sinusen från vevgivaren till pulser som Arduinon kan läsa, första försöket och jag tappar första pulsen efter luckan varje gång. Så det blir till att byta inkoppling och prova igen.
På bilden ett 32 tänders drev som tappat 2 tänder...


Logga in för att visa de filer som bifogats till detta inlägg.


Upp
 Profil  
 
InläggPostat: 21.26 2017-11-23 

Blev medlem: 15.21 2006-04-30
Inlägg: 19
Ort: Alingsås
Ah. Ser att du leker med en induktiv givare. Dom är av sk zero crossing typ. Dvs du mäter inte kanterna eller tänderna på signalen. Man mäter istället när pulsen svänger över från positiv spänning till negativ, och vice versa. Här kan du ha nytta av att fördröja din avläsning baserat på tid. Då slipper du sampla falska positiva signaler.

Hade du valt en optisk givare så hade du läst av kanterna på din signal istället.
Induktiv givare = billig och driftsäker. Men jobbig signal pga sin magnetiska princip. Den har med andra ord inbyggd fördröjning pga fysikens tröghetslagar.
Optisk givare = dyrare och driftsäker. Fyrkantssignal. Lätt att jobba med.


Upp
 Profil  
 
Visa inlägg nyare än:  Sortera efter  
Svara på tråd  [ 276 inlägg ]  Gå till sida Föregående  1, 2, 3, 4, 5 ... 19  Nästa

Alla tidsangivelser är UTC + 1 timme


Vilka är online

Användare som besöker denna kategori: Inga registrerade användare och 4 gäster


Du kan inte skapa nya trådar i denna kategori
Du kan inte svara på trådar i denna kategori
Du kan inte redigera dina inlägg i denna kategori
Du kan inte ta bort dina inlägg i denna kategori
Du kan inte bifoga filer i denna kategori

Sök efter:
Hoppa till:  
   
Drivs av phpBB® Forum Software © phpBB Group
Swedish translation by Peetra & phpBB Sweden © 2006-2010