• Live: io-techin Tekniikkapodcast tänään perjantaina noin klo 15:15 alkaen. Keskustellaan viikon mielenkiintoisimmista tietotekniikka- ja mobiiliaiheista. Suora lähetys YouTubessa. Tule mukaan katselemaan ja keskustelemaan! Linkki lähetykseen >>

Autolaturi mökille varavoimaksi Arduinon avulla

@ississ, no joo, sama melkein laittaa erillisetkin paikat, kun ei käytännössä mitään merkitystä ole tuolla kortin hintaan. Jos onnistun irrottamaan tuosta relemoduulista nuo ylöspäin juotetut piikit ja siirrettyä ne alaspäin, ei tuota lisäpaikkaa kylläkään tule tarvitsemaan.

Tuo relemoduuli tulisi asentaa niin alas levylle kuin mahdollista. Ei siinä kotelon korkeussuunnassa loputtomiin ole pelivaraa. Paitsi, että nyt taitaa ollakin, kun ei tule sitä toista relemoduulia lainkaan. Voi olla, että tuleekin aika matala paketti. No, noita erilaisia korttikorokkeita kyllä nyt on, joten sen puoleen ei tarvitse miettiä. :)

Ehkäpä nuo jo uskaltaa pistää Kiinanmaalta tulemaan.
 
Nyt alkaa kortit olla aika pitkälti juoteltu ja laiteltu, harmi vaan kun joitakin osia kuitenkin unohtui tilata, joten odotellaan taas osien tuloa. Pitää varmaan testata korttia kuitenkin, että komponentit on kunnossa, ennen kuin laittaa suojalakan pintaan.

Mutta tässä voisi vähän pohtia tuota hommaa, että miten laturin PWM ohjataan. Tuossa moottorissa ei riittänyt teho yli n. 45 ampeerin latausvirtaan. Tämän vuoksi latausjännite jää aika alhaiseksi ja virta varmastikin laskee alun suuremman virran jälkeen.

Hieno ratkaisu olisi varmasti PID-pohjainen PWM:n ja sitä kautta latausvirran säätö. Tämä maksimoisi latausnopeuden, mutta PID-säätö olisi taas uutta koodia ja ymmärtääkseni aika intensiivinen homma saada viritettyä. Lisäksi se käytännössä vaatisi kierrosnopeuden mittauksen toiseksi muuttujaksi, jonka mukaan latausvirta maksimoitaisiin turvallisen maksimijännitteen (14,7 V) rajoissa. Tai ei välttämättä ehkä vaatisikaan, jos mitataankin vain sitä maksimia latausvirtaa ja pyritään pitämään se samana, kunnes jännitteen yläraja saavutetaan, johon jännitteen nosto pysähtyisi.

Olisikin ehkä mahdollista joku ruma koodi, jossa jos-lauseilla haetaan hommaa eteenpäin. Esim. jos latausvirta alle 30 ampeeria, nostetaan PWM:n niin ja niin paljon. Tätä jatketaan, mutta tässäkin pitäisi olla joku ehto, ettei turvallinen jännite saa ylittyä. Enpä osaa arvioida, kuinka monta "porrasta" tuohon tarvittaisiin. Parempi olisi, jos säätö olisi portaaton niin, että kun latausvirta laskee, nostetaan sitä mukaa jännitettä, mutta vain turvallisissa rajoissa.

Kolmas vaihtoehto on, että antaa olla noin. Kuinkahan alas latausvirta tuolla noin 13,2 voltilla arviolta laskee?

Neljäntenä vaihtoehtona on hankkia tehokas moottori, joka jaksaa repiä alusta saakka yli 14 voltilla ja rakentaa koko runko uusiksi. Tässä olisi taas investointi ja jos uuden moottorin hankkisi, olisi melkein kohtuullista hankkia se jopa samanhintainen tai muutamia kymppejä kalliimpi sähköstarttiversio.
 
Viimeksi muokattu:
Minkälainen moottori sulla siinä on? En nopeasti ketjua selaamalla löytänyt paljonko moottorista suurin piirtein saa tehoja
 
Muistutapa vielä laiskoille minkälainen akusto on ?
Osassa pitäisi rajoittaa jännite tiettyyn max- arvoon ja virta myös. Käytännössä aina jänniterajaus jolloin virta on alussa mitä on kunhan rajoitetaan maksimiin ja sen jälkeen vain jänniterajoitus jolloin lopussa virta laskee.

Karkeasti laskien 3.5hp ~ 2.6kW, arvataan siitä 80% = noin 2kW joka on suunnilleen 140A @14V (70% hyötysuhteella 1.8kW, 130A)
Ja kaikki muut hidastavat tekijät tietysti mukaan...

Yritit siis ladata yli 45A jolloin moottorin kierrokset laski liikaa ?
Mikä jännite silloin oli ?
 
@ississ , testissä akkuna yksi 100 Ah myös starttiakuksi sopiva vapaa-ajan lyijyakku. Lopulliseen tulee kaksi identtistä 100 Ah:n akkua.

Onkohan autolaturin hyötysuhde lähempänä 50 % kuin 70 %? Jos näin laskisi, niin silloin laturi nähdäkseni vaatisi tehoa toimiakseen täydellä 80 A:n latausvirralla 14 V x 80 A = 1120 W / 0,50 = 2240 W, jolloin nähdäänkin, ettei tuo heittämäsi 2 kW riittäisi tai olisi aivan täpärällä. Eli tehokkaampaa konetta käyttöön tai tyytyä pienempään latausnopeuteen?

Uskoisin kuitenkin, että tuo 3,5 hepan teho on kampiakseliteho, mutta voihan nyt olla niin, että tuo kone on jo niin väljä, ja voi olla tehoa vähemmänkin kuin 2 kW. Vaatimattomat 41 vuotta ikää koneella!

Kun latausvirta oli noin 40-45 A, jännite oli luokkaa hieman päälle 13 V. Moottori sammui tai alkoi käydä kaasu pohjassa tyhjäkäyntinopeutta jos yritti vähän nostaa lataustehoja (pulssinleveyttä).
 
Uusien laturien hyöty yleensä ilmoitetaan olevan 70-80% luokkaa mutta en kyllä ole tutustunut aiheeseen sen tarkemmin...

Varmaan noin vanhalla moottorilla ei enää saa maksimia ja toinen kysymys on tietysti koneen vääntökäyrä... millähän kierroksilla max teho mahtaa tulla. Eikä se kierrosluku ehkä ole se jolla laturi toimisi parhaiten...

Mutta joo, vähän alimittaisella moottorilla pitäisi varmaan rajata lähtö niin että pysyy vähän alle täyden kaasun ja kierrokset järkevinä. Sitten kun akut täyttyy niin jännitettä voisi saada vähän nostettua että saa täyteen asti.

Eli lisäät vaan ojaukseen kierrosluvun ja kaasuläpän asennon mittaukset ja 3 kiloa koodia 😋
Joku akiivinen säätö joko pid tai konservatiivisilla raja- arvoilla voisi olla sopiva mutta kierrokset pitäisi ehkä mitata jos pitää valvoa ettei laske liikaa
 
@ississ , jeps. Olisi kyllä hieno peli, jos vielä poistaisi sen "governorin" käytöstä, niin kuin B&S-slangissa vakiokierrossäätöä kutsutaan ja ohjaisi jopa moottorin kierroslukua Arduinolla. Ehkä siihen ei nyt viitsi lähteä, eikä periaatteessa tuossa varmaan kierrosluvun mittausta tarvitsisi, koska tiedetään suurin piirtein se maksimi latausvirta, jota moottori pystyy tuottamaan.

Pitää nyt miettiä, hankkisiko uuden moottorin vai laittaako jotain latausvirran "on-the-fly" säätöä vielä koodiin.
 
Ei sitä säädintä yleensä kannata poistaa mutta vanhoissa kannattaa varmistaa ettei mikään ole jumissa tai liian kulunut.
Tuollaiset eivät yleensä pidä kovin suurista kierroksista joten on hyvä olla rajoitin.
 
Tuota jo arvelin aikaisemmin käyvän siksi ehdotin jo alkuun että Arduino lukisi myös kierrokset jotta osaa laskea lataus virtaa jos moottori meinaa kyykätä. Helpoiten tuon kai kiertää sillä että turbottaa sen moottorin 😁 tai hommaa suosiolla pari heppaa isommaan mosan
 
Eiks se oo just sitä kallista säästämistä josta joskus puhutaan. Ihan oli asiaa ootko muuten koodissa huomioinut vikatiloja jos esim jokin johto irtoaa ettei koita vikatilanteessa puskea Max virtaa? Piti jo aikaisemmin ehdotella mutta unohtui
 
@Nasty76 , joku max-arvo on tosiaan oltava koodissa ainakin, kun pulssinleveyteen kajotaan käynnistyksen jälkeen. Tosi hyvä vinkki!

Mitä mahdollisuuksia on, että Arduinolta tulisi vikatilassa liian korkeaa PWM:ää?

Ainakaan periaatteessa en näkisi riskiä kovin suureksi, jos jotakin arvoa ei jatkuvasti mitata ja säädetä PWM:ää sen mukaan korkeammaksi. Paitsi nyt kun miettii, niin eikös tuo sammutusfunktio juuri sellainen riskihomma olekin? Jos virranmittauksen tulo katkeaa syystä tai toisesta, tilanne saattaa kääntyä akun täyttymiseksi, ja tällöin siirrytään sammutusfunktioon, jossa PWM nostetaan 100 prosenttiin, jolloin laturin magnetointi ajetaan nolliin JOS laturi ei pyöri. Mutta kun laturi vikatilassa pyöriikin, niin tuo kääntyy yli 16 V:n jännitteeksi ja sehän saa tuhoa varmasti aikaan.

Mutta periaatteessa kai tuossa yksi turvamekanismi olisi se, että moottorin pitää olla sammunut, eli toiselta anturilta, oli se sitten tärinäanturi tai kierrosluku pitää tulla tieto, että moottori seis. Ja tuohan koodissa jo on. (Kierroslukuanturi tulee vain tapauksessa, jos laitetaan sähköstartillinen moottori.)

Virta-anturin alueen tulisi (en ole vielä kokohässäkkää testannut Pololun anturilla) olla suunnilleen 1,5-4 volttia alueella, joten tuollakin voisi miettiä koodiin, että pitää olla tuo alue tai moottori sammutetaan.
 
Viimeksi muokattu:
Joo eihän tuossa nyt niin suurta riskiä ole mutta itse ajattelen aina siltä kantilta että jos joku asia menee pieleen niin se yleensä menee voihan tuo Arduino saada jonkun sätkyn ja jäädä vika tilaan tai tärinästä joku kriittinen johto katkeaa ja sitten tapahtuukin jotain pahaa en tiedä saisiko jostain passiivi komponenteista rakennettua vaikka watchdogin joka osaisi katkaista arduinosta virrat ja laittaa hetken päästä päälle tms itse ajattelen että Arduino hengissä ollessaan pulsittaa pinniä joka pitää konkan virroissa ja jos pulsseja ei tule konkka tyhjenee ja jonkin näköinen rele katkaisi Arduino viirrat ja hetken päästä rele osaisi vetää itsensä takaisin päälle tms
 
Ennen kuin alkaa taas koodia ähräämään, voisi miettiä vähän moottorihommia. Oon tässä kuolannut noita sähköstartilla olevia paikallismoottoreita, mutta harmi kyllä niissä on käsikäyttöinen choke, tai suomeksi "ryyppy". Eipä olekaan niin automaattinen sitten, kun jos Arduinolta tulee starttauskäsky.

Ei ainakaan ole intoa lähteä jotain servoja virittelemään ja muokkaamaan jo kättelyssä vivustoa. Mitähän keinoja tuommoisen moottorin käynnistymiseen on, siis sellaisia, ettei tarvitse sen isommin muokata heti alkuunsa. Ja ilman, että kumpparimies hyppää jostain päin tiluksia vetelemään ryyppyvipua pois ja päälle. En usko, että lähtee kuitenkaan ilman ryyppyä käyntiin. :D

Liekö muuta vaihtoehtoa, kuin yrittää löytää moottori, jossa automaattiryyppy? Katsastin 5 eri moottoria, ja yhdessäkään ei ollut automaattiryyppyä.

Nooh, jos tuohon ei saa ratkaisua, niin tuskin sitten tarvitaan sähköstarttiakaan.
 
Moposkoottereissa näkee sähköryyppyä, voisiko joku sellainen sopia paikallismoottorin kaasariin? Haku

Toisaalta jos tietää moottorissa käytetyn (oletettavasti kopioidun) kaasarin alkuperäisen mallin, niin liekö niihinkin saattaisi löytyä suoraan sopivia sähköryyppyjä.

Voisi siltikin olla helpointa muuttaa alkuperäinen käsikäyttöinen ryyppy sähkötoimiseksi. Itse lähtisin sellaista tekemään solenoidilla, vaikkapa hakusanalla sammutinsolenoidi voisi löytyä kapistus joka on helppo kiinnittää alkuperäiseen vipuun tai vaijeriin ja ohjauksen voi hoitaa vaikkapa releellä.
 
Helpoiten tuon tekee yhdellä rc servolla ja pätkällä jotain tankoa tai parhaassa tapauksessa servon varren saa suoraan liikuttamaan ryyppyä
 
@KanOl , kaikkihan nuo kiinanmoottorit lienee jonkun perus Hondan kopioita. Esim. tässä: Robota E193 6,5hp 4-tahti irtomoottori | Karkkainen.com verkkokauppa

Mielellään jos olisi joku mekaaninen ohjaus tuohon automaattiryyppyyn tai irrallinen tästä ohjaus-Arduinosta! Ihan jo sen vuoksi, ettei sitten moottorin käynnistyminen olisi Arduinosta kiinni.

EDIT: Näyttää olevan ainakin olemassa tuommoisia kaasuttimia, joissa on jo automaattiryyppy. Tällainen Hondaan tarkoitettu kaasari maksanee joitakin kymppejä. Enpä osaa sanoa, käykö sitten esim. tuohon Robotaan, joka on edullisin sähköstartillinen moottori.
 
Viimeksi muokattu:
Laittaa jousen pitämään ryyppyä päällä ja solenoidi tms vetämään se pois päältä. Solenoidin ohjaus laturilta, niin kun kone käynnistyy ja laturi alkaa tuottaa sähköä lähtee ryyppykin pois 🤔

Toisaalta, ei kai sillä koko systeemillä tee mitään muutenkaan ilman sitä Arduinoa. Siis mitä merkitystä on sillä onko moottori riippuvainen siitä Arduinosta vai ei.
 
@TemeV , no näinhän se on, ettei koko systeemillä juurikaan ole merkitystä, jos Arduino ei toimi. Mutta jotenkin sitä vaan haluaisi tuon itse moottorin ohjaamisen olevan mekaniikan hallussa / itsenäinen digidigihömpästä. Hyvä vinkki tuo solenoidin ja jousen yhdistelmä. Solenoidia voisi ohjata sitten pois päältä tuollaisella erotusreleellä. Esim. Automaattinen erotusrele 12 V 140 A | Hamron | Jula

Toki tuollakin erotusreleellä on hintaa, eikä tarvisi olla noin järeää kaliiberia tämmöisiin pikkuohjauksiin, mutta esimerkinomaisesti varmaan toimisi.

Toinen on tietenkin, ettei projekti loputtomasti paisuisi kuin pullataikina, vaikka toki se jo onkin paisunut, mutta ehkä hiivan määrää pitää yrittää hillitä! ;)

Ehdottomasti paras vaihtoehto olisi löytää se näihin moottoreihin tarkoitettu automaattiryyppysetti tai kaasutin automaattiryypyllä.

EDIT: Honda-Type GX160-200 5.5-6hp Auto-Choke Carburetor Generator Pressure Washer | eBay

Tuossa saattaisi olla. Ilmeisesti siis nämä päälle 6 hepan moottorit on tuon Honda GX200:n kopioita.
 
Viimeksi muokattu:
Yksi mahdollisuus olisi laittaa moottorin ohjaimeksi toinen arduino.
Toisella voi käskyttää toista suoraan on/off pinnillä, sarja- tai spi- väylällä jne. Tietysti koko systeemi mutkistuu mutta silloin kummallakin olisi vain se oma homma tehtävänä jolloin koodi on helpompi.

Ryypyn jousen suunta kannattaa miettiä virheiden kautta, kumpi on parempi/pahempi, se että virheen sattuessa (esim johto poikki, solenoidi rikki tms) ryyppy on päällä vai ei.
Monet moottorit lähtee aika hyvin käymään ilmankin mutta jokainen kä varmasti huonosti jos ryyppy on koko ajan päällä.
 
No niin, tässä yritän testata tuota korttia "kuiviltaan", että onko edes komponentit kunnossa, mutta varmaan kämmään nyt jotain yksinkertaista. Mielestäni nämä rivit:

C++:
  Serial.print("Jannite: ");
  Serial.print((float)sensVoltage);
  Serial.println();
  Serial.print("Virta: ");
  Serial.print((float)current);
  Serial.println();

Pitäisi tulostaa edes jotain sarjaportilla, mutta ei tule mitään. Ja on setupissa sarjaportin alustus myös.

EDIT: Ainakin Arduino kunnossa, Hello world, testikoodi toimii. Eli "vika" on tuossa hienossa ohjauskoodissa, johon ei ole tehty mitään merkittäviä muutoksia. Nähtävästi pitää kaikki olla kytkettynä, jotta toimii.

EDIT2: Tosiaan jotain en nyt varmaan hoksaa, miksen saa tuota koodia "tyhjiltään" pelittämään. Toimihan se edellisessä koekokoonpanossa niin kyllähän sen nytkin pitäisi. Eli nyt on pohjakortille asennettu Arduino kytkettynä koneeseen USB:llä ja muu pohjakortti ei saa mistään virtaa. Motorpin (eli tieto moottorin käymisestä, INPUT_PULLUP) kytketään katkaisimella maata vasten, jonka pitäisi käynnistää rampup-funktio. Mutta näen jo toimimattomuuden siitä, kun Arduinon merkkiledit eivät ala vilkuttamaan.

Tässäpä koodi taas ihmeteltäväksi. Huom. koodissa on vanhoja kommentteja ja osien aiemman shuntiin perustuvan virtamittauksen aikaisia pätkiä. Koodia pitää vielä siistiä.

C++:
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);  // Create a new LiquidCrystal_I2C display object with the correct I2C address and display size
// Define the pins
const int currentPin = A0;             //information about current
const int voltagePin = A2;             //information about voltage
const int motorPin = 2;                //motor running pin, HIGH = motor running, TEST purpose LOW
const int pwmPin = 9;                  //PWM output pin
const int relayPin = 4;                //Relay control pin
float voltageFactor = 5.00 / 1023.00;  //Factor to convert ADC reading to voltage
// OLD: float currentFactor = 80.00 / (4.15 - 2.02);  // Adjusted for 2.02 volts = 0 amps and 4.15 volts = 80 amps
// NEW: Define the points for current calculation / the line equation
float x1 = 0.500;  // volts
float y1 = 0;      // amps
float x2 = 4.005;  // volts
float y2 = 150;    // amps
// Calculate the slope and intercept
float m = (y2 - y1) / (x2 - x1);
float b = y1 - m * x1;
float currentCal = 1;  // Variable to shift th whole current level
float sensVfactor = 20.00 / 4.9248;  //4.9248 volts = 20 volts, factor to convert high voltage to 0-5 V
float current;                       //store current value
float sensVoltage;                   //store sensed voltage
const int N = 25;                    //number of current readings to average
const int Y = 25;                    //number of sensed voltage readings to average
int readings[N];                     //array to store the current readings
int readingsV[Y];                    //array to store the sensed voltage readings
int motorStatus;                     //0=stopped, 1=starting, 2=running, 3=stopped but did run, on status 3, just switch off and on again to go back 0
// int lcdStep;                         //0=current display, 1=voltage display
unsigned long lastTime = 0;  //timer to measure engine sensor input time for starting



void setup() {
  Serial.begin(9600);  // Start the serial communication
  // Initialize the LCD here
  // Give the screen time to boot
  delay(50);
  lcd.begin(16, 2);
  lcd.backlight();
  lcd.clear();
  // Change timers on pins to change PWM freq to 122 Hz
  // Pins D9 and D10 - 122 Hz
  TCCR1A = 0b00000001;  // 8bit
  TCCR1B = 0b00000100;  // x256 phase correct
  // Make pins output/input
  pinMode(currentPin, INPUT);       //Information on charging current
  pinMode(voltagePin, INPUT);       //information on voltage, for real use, delete _PULLUP
  pinMode(motorPin, INPUT_PULLUP);  //Vibration sensor in, for motor running detect,  for real use, delete _PULLUP (it is for test purpose, pullup resistor)
  pinMode(pwmPin, OUTPUT);          //Alternator pwm output
  pinMode(relayPin, OUTPUT);        //Ignition relay pin
  // Start Duty Cycle at 100 %, alternator electromagnet off, for starting the engine
  analogWrite(pwmPin, 255);
}

void motorRunning() {  //engine running function
  if (digitalRead(motorPin) == HIGH && motorStatus == 0) {
    if (millis() - lastTime >= 6000) {  //wait at least 6 seconds before ramping up pwn and so start charging
      motorStatus = 1;
    }
  } else if (motorStatus == 0) {
    lastTime = millis();
    lcd.setCursor(0, 0);  //On lcd print Finnish to start the engine
    lcd.print("K");
    lcd.print((char)0xe1);
    lcd.print("ynnist");
    lcd.print((char)0xe1);
    lcd.print("   ");
    lcd.setCursor(0, 1);
    lcd.print("moottori");
  }
}

void rampUp() {  //rampup pwm
  // Ramp pwm up
  if (motorStatus == 1) {
    analogWrite(pwmPin, 24);
    delay(1000);
    analogWrite(pwmPin, 41);
    delay(1000);
    analogWrite(pwmPin, 58);
    delay(1000);
    analogWrite(pwmPin, 77);  //Duty Cycle at 30 percent
    motorStatus = 2;
  }
}

//void shutDown() {  //engine shutdown, execute relay
// If the charging current drops below five amperes
// start the shutdown function and turn off the relay
// if (current >= 0 && current < 5 && motorStatus == 2) {
// digitalWrite(relayPin, LOW);
// delay(1000); //give engine time to stall down
//  analogWrite(pwmPin, 255); // Stop Duty Cycle at 100 %, alternator electromagnet off
//lcd.clear();
// lcd.setCursor(0, 0);
// lcd.print("Sammutus");

// motorStatus = 3;
//  } else {
//   digitalWrite(relayPin, HIGH);  //else, keep relay on
// }
//}

void showCurrent() {  //show current and voltage on lcd only when normal running state

  if (motorStatus == 2) {
    lcd.setCursor(0, 0);
    lcd.print("Virta:");
    lcd.setCursor(0, 1);
    lcd.print((float)current);
    lcd.print(" ");
    lcd.setCursor(5, 1);
    lcd.print(" A");
    lcd.setCursor(8, 0);
    lcd.print("J");
    lcd.print((char)0xe1);
    lcd.print("nnite:");
    lcd.setCursor(8, 1);
    lcd.print((float)sensVoltage);
    lcd.print(" ");
    lcd.setCursor(13, 1);
    lcd.print(" V");
  }
}




void loop() {
  //calculate current from shunt reading
  // Calculate the charging current from the average and display it on the LCD screen.
  // take N readings and store them in the array
  for (int i = 0; i < N; i++) {
    readings[i] = analogRead(currentPin);
    delay(5);  // wait for 5 milliseconds between readings
  }
  // calculate the average of the N readings
  float sum = 0;
  for (int i = 0; i < N; i++) {
    sum += readings[i];
  }
  float average = sum / N;
  float voltage = average * voltageFactor;  //  Convert ADC reading to voltage
  //OLD
  //current = voltage * currentFactor;  // Convert voltage to current
  //NEW
  current = (m * voltage + b) * currentCal;  // Convert voltage to current using the new linear equation

  //calculate high voltage from voltage divider input
  // Calculate the charging voltage from the average and display it on the LCD screen.
  // take Y readings and store them in the array
  for (int j = 0; j < Y; j++) {
    readingsV[j] = analogRead(voltagePin);
    delay(5);  // wait for 5 milliseconds between readings
  }
  // calculate the average of the N readings
  float sumV = 0;
  for (int j = 0; j < Y; j++) {
    sumV += readingsV[j];
  }
  float averageV = sumV / Y;
  float voltageV = averageV * voltageFactor;  //  Convert ADC reading to voltage
  sensVoltage = voltageV * sensVfactor;  // Convert voltage to real voltage

  motorRunning();
  rampUp();
  //shutDown();
  showCurrent();
  Serial.print("Jannite: ");
  Serial.print((float)sensVoltage);
  Serial.println();
  Serial.print("Virta: ");
  Serial.print((float)current);
  Serial.println();
}
 
Viimeksi muokattu:
En tiedä miltä se ajantasainen koodi näyttää, mutta sivulta 6 löytyi joku rimpsu. Mielestäni tuota delaytä ei pitäisi käyttää mihinkään vaan tehdä niistä silmukoista non-blocking. Itse määritän yleensä pääsilmukalle jonkun suoritusajan, sanotaan vaikka 100ms. Kaikki muut taskit ajetaan tämän pääsilmukan sisällä niin että jos niissä on odottelua vaativaa toiminnallisuutta, niin funktiossa on laskuri ajan mittaamiseen ja funktio jatkaa tekemisiään kun laskurissa aika täynnä.

Jos koodia ja funktioita ei ole tuon enempää, niin sinähän voit helposti kokeilla kommentoida pois toimintoja yksi kerrallaan niin selviää mikä siellä vetää ohjelman jojoon. Ilmeisesti saat kuitenkin Arduinoon yhteyden kaapelilla, eli kyse ei ole siitä että joku komponentti tai virhekytkentä vetäisi Arduinon käyttöjännitteen matalaksi?
 
@KanOl , joo tuo delay-funktion käyttäminen ei ole paras mahdollinen ratkaisu. Tässä vain täysin alkeisena "koodarina" on yritetty käyttää semmoisia funktioita, joita joten kuten saattaa ymmärtää. Eikä tätä olisi saanut mitenkään toimivaan kuntoon ilman ansiokkaiden ohjeiden apua ahkerilta käyttäjiltä kuten @ississ ja @Nasty76.

Sen ymmärrän, että tuo delayn käyttö estää kaiken muun tekemisen taustalla. Jos esim. kierroslukua pitäisi seurata yhtaikaa kun tuommoinen viive tarvitaan, eipä onnistuisi. Mutta tämä ei nyt ole tämän käsillä olevan haasteen kohdalla ratkaiseva asia. Koodista voi varmasti ajan mittaan hioa pois nuo delayt, mutta ensiksi pärjäisi tällä koodilla aika hyvin. Kunhan nyt testi selviäisi.

Arduinolla oli ihan ok 5 V jännite, ei siinä ongelmaa ainakaan. Yhteys Rduinoon onnistui hienosti, sillä ohjelma menee kyllä sisään ja sarjaportin testikoodikin toimi hyvin.
 
Lisäilet vaan Serial.print vähän joka paikkaan. Aloittaisin setupista, esim. heti Serial.begin jälkeen jotain kivaa ja samoin setupin loppuun, helpottaa muutenkin sit jatkossa debuggausta kun näkee heti et pääseekö ohjelma pääsilmukkaan. Jos sinne haluaa jättää debuggausta varten valmiit rivit niin ne voi deaktivoida esim. makroa käyttäen.

C:
#define DEBUG

void loop(){
    #ifdef DEBUG
    Serial.println("Tässä alkaa loop silmukka");
    #endif
}

Jolloin rivin Serial.println("Tässä alkaa loop silmukka"); tulostuksen voi deaktivoida kommentoimalla rivin #define DEBUG pois, eli näin
C:
//#define DEBUG
 
@KanOl , eli tarkoittaa sitä, että jos ko. kohtaan laitettu haluttu rimpsu (esim. "ramp-funktio aloitettu") tulostuu, niin silloin koodi on toiminut ainakin siihen ast?
 
Kyllä vain. Silloin jos käytössä ei ole mitään oikeaa debuggaus työkalua (esim. JTAG), niin sarjamonitoriin printtailu on ihan yleinen tapa diagnosoida huonosti käyttäytyvää koodia. Serial.print tulostaa sarjamonitoriin reaaliajassa, joten siitä näkee mihin asti suoritus onnistuu. Serial.print käytössä kannattaa muistaa että jos niitä printattavia rivejä tulee paljon, voi aikakriittisten toimintojen suorittaminen hankaloitua.

Heti Serial.begin rivin alapuolelle sijoitetulla print-rivillä näet jatkossa aina bootissa onko arduino hengissä.

C:
void setup() {
  Serial.begin(9600);  // Start the serial communication
  Serial.println("Olen elossa, tasta lahtee");
  // Initialize the LCD here
  // Give the screen time to boot
  delay(50);
  lcd.begin(16, 2);
  lcd.backlight();
  lcd.clear();
  // Change timers on pins to change PWM freq to 122 Hz
  // Pins D9 and D10 - 122 Hz
  TCCR1A = 0b00000001;  // 8bit
  TCCR1B = 0b00000100;  // x256 phase correct
  // Make pins output/input
  pinMode(currentPin, INPUT);       //Information on charging current
  pinMode(voltagePin, INPUT);       //information on voltage, for real use, delete _PULLUP
  pinMode(motorPin, INPUT_PULLUP);  //Vibration sensor in, for motor running detect,  for real use, delete _PULLUP (it is for test purpose, pullup resistor)
  pinMode(pwmPin, OUTPUT);          //Alternator pwm output
  pinMode(relayPin, OUTPUT);        //Ignition relay pin
  // Start Duty Cycle at 100 %, alternator electromagnet off, for starting the engine
  analogWrite(pwmPin, 255);
  Serial.println("Setup tuli valmiiksi, seuraavaksi loop silmukkaan");
}

ps. sarjamonitoriin printtailun ottamaa aikaa voi lyhentää kasvattamalla sarjaportin nopeutta, esim. 9600 -> 115200. Älä ala nyt säätämään sarjamonitorin nopeuksilla, mutta voit laittaa mietintämyssyyn.
 
@KanOl , joo tuo delay-funktion käyttäminen ei ole paras mahdollinen ratkaisu. Tässä vain täysin alkeisena "koodarina" on yritetty käyttää semmoisia funktioita, joita joten kuten saattaa ymmärtää. Eikä tätä olisi saanut mitenkään toimivaan kuntoon ilman ansiokkaiden ohjeiden apua ahkerilta käyttäjiltä kuten @ississ ja @Nasty76.

Sen ymmärrän, että tuo delayn käyttö estää kaiken muun tekemisen taustalla. Jos esim. kierroslukua pitäisi seurata yhtaikaa kun tuommoinen viive tarvitaan, eipä onnistuisi. Mutta tämä ei nyt ole tämän käsillä olevan haasteen kohdalla ratkaiseva asia. Koodista voi varmasti ajan mittaan hioa pois nuo delayt, mutta ensiksi pärjäisi tällä koodilla aika hyvin. Kunhan nyt testi selviäisi.

Muistaakseni tein yhden tilakone- mallisen koodin. Tietysti se ei ehkä ole niin helposti omaksuttava mutta ei tarvita myöskään delay- fuktioita.
Oikeasti kierrosluvun mittaus kannattaisi tehdä ajastimilla taustalla.

Sarjaporttiin 115200 tai 250000 niin ei hidasta niin paljoa. Ja kannattaa välttää myös pitkiä tulostuksia.
Mutta kuten jo edellä mainittiin niin kaikki tulostukset vaikuttaa nopeusiin ja toimintaan kun käytetään delay:tä. Varsinkin debug tuottaa aika paljon liikennettä sarjaporttiin ja kaikki ajastukset menevät todennäköisesti vähän pieleen.
 

Statistiikka

Viestiketjuista
264 218
Viestejä
4 575 881
Jäsenet
75 398
Uusin jäsen
xJuusox

Hinta.fi

Back
Ylös Bottom