Autolaturi mökille varavoimaksi Arduinon avulla

[Nasty76]

tosin tollasella systeemillä et voi käyttää ehkä esim monitoria joka vaatii 12v koska autosähkössä 12v on vain nimellisjännite ja todellisuudessa moottorin käydessä sen 13,8-14.4v uskoisin että autosähkökäyttöön olevat vehkeet kestää sen 16v vielä helposti, ja jos jotain elektroniikkaa pitää ajaa regu siellä olisi oltava.ja joo kyllä siellä pitäisi olla logiigga joka ei anna sammutus funktion ajaa pwm 100 jos moottori käy

 

[Tupsa]

@ississ, Joo tuohan oli hyvä. Eli periaatteessa kolmelta anturilta ikään kuin tuossa vahvistus ennen kuin palautetaan akkujännite lataussäätimeen.

Kysyit, että mitä muita laitteita järjestelmässä on. On perus mökkivarusteita: aurinkolataussäädin, radio, lamppuja, jääkaappi, tarpeen mukaan erikseen päälle kytkettävä 230 V invertteri.

Jääkaape on ainakin tarkoitettu karavaanikäyttöön, joten siinä ainakin lienee jännitteen yläraja korkeampi.

 

[TemeV]

@TemeV , mutta voiko jännite kuitenkin nousta 16 volttiin? Miten käy laitteille, jotka kytkettynä systeemiin, jossa jännite hetkellisesti 16 volttia?

Ei sen pitäisi pystyä noin korkealle hyppäämään sekuntien aikaskaalassa. Jos mietitään että latausvirta olisi vaikkapa 50A normaalisti. Jos saisit jollain erikoisella vikatilanteella nostettua vaikkapa 150 ampeeriin, akku latautuu ja jännite nousee siinä kahdessa sekunnissa saman verran kuin normaalisti kuudessa sekunnissa Eli ei juurikaan.

Johtojen resistanssit toki nostaa jännitettä laturin päässä ja siellä päässä saatettaisiin jo lähennellä sitä 16 volttia, riippuen johtojen paksuudesta ja liitosten laadusta. Jos kuitenkin laitteet on kytketty akkuun, eikä suoraan laturiin, ei ne näe sitä jännitettä. Akun resistanssi lienee joitain milliohmeja, ja tuo 150 ampeeria nostaisi siis jännitettä joitain satoja millivoltteja.

 

[Tupsa]

@TemeV , no tuolla perusteella, jos siis saa laitettua tuommoisen lisäturvapiirin katkaisemaan ohjauksen laturilta, niin riittäisi aivan ok tämän systeemiin suojaukseksi. Toki silti kannattaa tuossa nuo @ississ :n aiemmin mainitsemat jutut laittaa sinne koodiin.

Täytyy toki muistaa, että varmaan todennäköisyys tämmöiselle tapahtumalle on lähellä nollaa, mutta ei sitä varmaan liian varovainen tässä olla.

 

[Tupsa]

Tähän väliin sujuvasti koodikysymys taas. Voiko tuossa ajastuksissa käyttää tuota samaa lastTime -muuttuja vai pitääkö kaikille ajastuksille olla omat? Yritän saada noita delay() funktioita pois tuosta koodista, että olisi "nätimpi" koodi.

Näyttääkö toimivalta äkkiseltään katsottuna:

void shutDown() {  //engine shutdown, execute relay

  //If the charging current drops to 0 to 5 amperes and charging voltage is under 15 volts (safety) and motor is running
  // start the shutdown function and turn off the relay
  if (current >= 0 && current < 5 && sensVoltage < 15 && digitalRead(motorPin) == HIGH && motorStatus == 2) {
    digitalWrite(relayPin, LOW);

    if (millis() - lastTime >= 2000) {  //wait at least 2 seconds to engine stall down

      analogWrite(pwmPin, 255);  // Stop Duty Cycle at 100 %, alternator electromagnet off

      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Sammutus");

      motorStatus = 3;  //motor has run, to reset, switch power off, on next startup, it will be reset

#ifdef DEBUG
      Serial.println("Sammutettu.");
#endif
    }

  } else if (motorStatus == 2) {
    lastTime = millis();

    digitalWrite(relayPin, HIGH);  //else, keep relay on

#ifdef DEBUG
    Serial.println("Kaynnissa.");
#endif
  }
}

 

[Nasty76]

En nyt oo varma mutta jos tuo lasttime oon ns geneerinen muuttuja jota siis käytetään monessa void jotain se käsittääkseni pitäisi myös joka loop kierroksella päivittää tai se päivittää vain kun joku ajaa tuon

lastTime =millis();

jos sulla on void loop()

{

lastTime = millis();


}

niin silloin joka loop kierroksella sulla on tuo arvo johon voit verrata onko aika kulunut. mutta nyt pähkäilen kun tuossa esimerkissä päivität vain lastTimen jos motorstatus == 2 joten jos tuon lisää looppiin rikkooko se jonkun logiigan ? jos rikkoo niin teet toisen esim generallastmillis = millis(); johon vertaa yleismailmallisesti paljonko aikaa on kulunut.

 

[ississ]

Tähän väliin sujuvasti koodikysymys taas. Voiko tuossa ajastuksissa käyttää tuota samaa lastTime -muuttuja vai pitääkö kaikille ajastuksille olla omat? Yritän saada noita delay() funktioita pois tuosta koodista, että olisi "nätimpi" koodi.

Näyttääkö toimivalta äkkiseltään katsottuna:

void shutDown() {  //engine shutdown, execute relay

  //If the charging current drops to 0 to 5 amperes and charging voltage is under 15 volts (safety) and motor is running
  // start the shutdown function and turn off the relay
  if (current >= 0 && current < 5 && sensVoltage < 15 && digitalRead(motorPin) == HIGH && motorStatus == 2) {
    digitalWrite(relayPin, LOW);

    if (millis() - lastTime >= 2000) {  //wait at least 2 seconds to engine stall down

      analogWrite(pwmPin, 255);  // Stop Duty Cycle at 100 %, alternator electromagnet off

      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Sammutus");

      motorStatus = 3;  //motor has run, to reset, switch power off, on next startup, it will be reset

#ifdef DEBUG
      Serial.println("Sammutettu.");
#endif
    }

  } else if (motorStatus == 2) {
    lastTime = millis();

    digitalWrite(relayPin, HIGH);  //else, keep relay on

#ifdef DEBUG
    Serial.println("Kaynnissa.");
#endif
  }
}

Samaa muuttujaa voi käyttää jos ei ole vaaraa että eri viiveet menee päällekkäin.
Tarkoittaa siis sitä että todennäköisesti joillakin muilla muuttujilla pitää tallentaa tilatieto missä ollaan ja sen mukaan tulkita ajastuksia.

Seurannan kannalta voisi olla parempi määrittää nuo motorstatus- arvot nimillä eikä numeroilla. Koodina ihan sama asia mutta silmälle helpompi kun ei tarvitse muistaa mikä tila oli 2 ja mikä 3.
Esimerkiksi

#define MOTOR_OFF 0
#define MOTOR_STARTING 1
#define MOTOR_RUNNING 2
#define MOTOR_STOPPING 3

ja koodissa:

int motorStatus = MOTOR_OFF;

Ja muista varmistaa että tilat/ehdot ovat sellaisia ettei mene vahingossa ohi tai suoriteta liian monta kertaa.
Oikeastaan niin että kun ehto täyttyy niin tila vaihtuu ja silloin on muut ehdot, tarvitset siis ainakin "ajossa" -> "sammumassa" -> "sammutettu" jolloin ajossa tutkitaan virtarajat jne.
Kun pitää aloittaa sammutus niin silloin asettaa lastTime, sammutusrele, jne ja seuraava tila.
"Sammumassa"- tilassa sitten tutkitaan sitä aikaa eikä enää välitetä virroista (ehkä kannattaa asettaa myös pwm minimiin edellä) ja taas asetetaan seuraava tila kun aikaraja täyttyy.

Näin varmistat myös sen että lastTime (tai muu vastaava) joka tässä on "tapahtuman alkuhetki" päivittyy vain tilan vaihdossa silloin kun kyseinen tapahtuma oikeasti alkaa.
Asettamalla jokaisella kierroksella lastTime = millis() kun kone on käynnissä on tavallaan ihan turhaa ja varsinkin silloin sitä ei voi uusiokäyttää.

Jotain tähän tyyliin siis. Ei takeita toiminnasta.

void shutDown() {

  if ( motorStatus == MOTOR_RUNNING ) {
    // Käynnissä
    if ( ( current >= 0 ) && ( current < 5 ) && ( sensVoltage < 15 ) && ( digitalRead(motorPin) == HIGH ) ) {
      //  ehdot täyttyy -> pitää sammuttaa

      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Sammutus alkaa");

#ifdef DEBUG
      Serial.println("Sammutus alkaa");
#endif
      // Ehkä myös tämä
      //analogWrite(pwmPin, 15);  // 5% pwm
      digitalWrite(relayPin, LOW);
      motorStatus = MOTOR_STOPPING;
      lastTime = millis();
    }
  } else if ( motorStatus == MOTOR_STOPPING ) {
    // Sammutus menossa
    if ( ( millis() - lastTime ) >= 2000 ) {
      // Aika täynnä

      if ( [ tähän rpm/tärinä luku -> onko moottori oikeasti sammunut ? ] ) {
        // Ehkä varmuuden vuoksi tarkastaa latausvirta ja jännite myös ennen pwm- asetusta
        // Sammunut
        analogWrite(pwmPin, 255);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Sammutettu");

#ifdef DEBUG
        Serial.println("Sammutettu");
#endif
        motorStatus = MOTOR_OFF;
        // Sammutusrele pitäisi voida palauttaa jo tässä (koska tarkastettu että sammui)
        // tai sillä missä pitäisi olla silloin kun tehdään seuraava startti.
        //digitalWrite(relayPin, HIGH);
      }
    }
  }

}

 

[Tupsa]

No niin, eilisen ja tämän päivän aloin tuota koodia ähräämään ja löysin muutamankin ajastinkirjaston, kun en vieläkään tajua tuota millis() funktion käyttöä sen sijaan, että käyttäisi yksinkertaista, mutta muun toiminnan pysäyttävää delay() -funktiota. Löysin kirjastot BlockNot ja Neotimer, josta jälkimmäisen sain nähtävästi toimimaan tekoälykoodin avustuksella.

Periaatteessa tuossa BlockNotissa olisi kai vielä yksinkertaisempi käyttö ollut, mutta jotain siinä missasin, kun funktio suoritettiin heti. Varmaankin ajastin lähti käyntiin aina heti koodin alussa kutsumisesta, mutta Neotimerin avulla siis nyt näyttäisi nuo aikapohjaiset jutut toimivan ilman, että mikään muu keskeytyy. Tämän näkee hyvin sarjaportin tulosta, että tilat vaihtuvat hienosti ajastimen mukaan.

Sen verran tässä on jo kuitenkin "osannut", että pystyy nyt liittämään koodia, ilman että punaista tekstiä on ruutu täynnä!

P.S. Tuskinpa tämä nyt näin meni, sanoo perus pessimisti. Vielä pitää testata, ja katsoa, mikä on esim. ulostulo, toimiiko PWM-portaat odotetusti.

#define DEBUG  //Serial debug, comment to disable
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

#include <neotimer.h>  //Timer from Neotimer library
Neotimer motorTime = Neotimer(6000);  // 6 second timer for startup detection
Neotimer stepTime = Neotimer(1000);   // 1 second timer for PWM step interval
Neotimer shutTime = Neotimer(2000);   // 2 second timer for engine shutdown (wait before switching PWM back to 100 %, electromagnet off)

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

// 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 the 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 pwmValues[] = { 24, 41, 58, 77 };  // PWM duty cycle steps, 77 = ~30 %
int currentPwmStep = 0;
// int lcdStep;                      //0=current display, 1=voltage display

void setup() {
  Serial.begin(250000);  // Start the serial communication
#ifdef DEBUG
  Serial.println("Setup...");
#endif
  Wire.begin();
  // Check if the LCD is connected
  Wire.beginTransmission(0x27);
  if (Wire.endTransmission() == 0) {
    // LCD is connected, proceed with initialization
    delay(50);
    lcd.begin(16, 2);
    lcd.backlight();
    lcd.clear();
  } else {
    // LCD is not connected, continue without initializing the LCD
#ifdef DEBUG
    Serial.println("Ei LCD:ta. Ohitus.");
#endif
  }
  // 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);
#ifdef DEBUG
  Serial.println("Setup ok.");
#endif
}

void motorRunning() {  //engine running function
  if (digitalRead(motorPin) == HIGH && motorStatus == 0) {
#ifdef DEBUG
    Serial.println("Kayntitieto...");
#endif
    if (!motorTime.started()) {  // Start the motorTime timer only, if it has not been started yet
      motorTime.start();         // Start the motorTime timer if it hasn't started yet
    }
    if (motorTime.done()) {  // Wait for motorTime to be done before moving to ramping up PWM
      motorStatus = 1;
#ifdef DEBUG
      Serial.println("Kaynnistetty.");
#endif
    }
  } else if (motorStatus == 0) {
    motorTime.stop();  // Stop the timer if motorPin is not high
#ifdef DEBUG
    Serial.println("Kaynnistys...");
#endif
    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) {
    if (stepTime.repeat()) {
      analogWrite(pwmPin, pwmValues[currentPwmStep]);
      currentPwmStep++;
#ifdef DEBUG
      Serial.println("Ramp up...");
#endif
      if (currentPwmStep >= sizeof(pwmValues) / sizeof(pwmValues[0])) {  //checking the pwm step count
        motorStatus = 2;
      }
    }
  }
}

void shutDown() {  //engine shutdown, execute relay
  //If the charging current drops to 0 to 5 amperes and charging voltage drops under 14 volts and motor is running
  // start the shutdown function and turn off the relay
  if (current >= 0 && current < 5 && sensVoltage < 15 && digitalRead(motorPin) == HIGH && motorStatus == 2) {
    digitalWrite(relayPin, LOW);
    analogWrite(pwmPin, 15);  // Duty Cycle to 5 % before running down engine
    if (!shutTime.started()) {  //wait for shutDelay time to engine have time to stall down
      shutTime.start();
    }
    if (shutTime.done()) {
      analogWrite(pwmPin, 255);  // Stopped Duty Cycle at 100 %, alternator electromagnet off
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Sammutus");
      motorStatus = 3;  //motor has run, to reset, switch power off, on next startup, it will be reset
#ifdef DEBUG
      Serial.println("Sammutettu.");
#endif
    }
  } else if (motorStatus == 2) {
    motorTime.stop();              // Stop the timer if motor is in state 2 (normal running) not high
    digitalWrite(relayPin, HIGH);  //else, keep relay on and don't
#ifdef DEBUG
    Serial.println("Kaynnissa.");
#endif
  }
}

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");
#ifdef DEBUG
    Serial.println("Virta LCD.");
#endif
  }
}

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

  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();
  Serial.print("Tila: ");
  Serial.print(motorStatus);
  Serial.println();
}

 

[Nasty76]

tota siis en itse käytä kyllä timer kirjastoja kun se onnistuu siis logiigalla jos sulla on esim rampup mitä ajetaan jossa nyt on delya(xxxX) niin mä teen esim long rampuptimer
sitten siellä void rampup

if(millis<millis()+1000)
{
#tää ajetaan silloin kun 1000ms eli sekunti onkulunut ja silloin se päivittää tuon rampuptimering.
rampuptimer = millis();
}

tossa vielä joku webppi sivu jossa tuota selostetaan.

Arduino Tutorial: Using millis() Instead of delay() – Norwegian Creations

www.norwegiancreations.com

 

[ississ]

No niin, eilisen ja tämän päivän aloin tuota koodia ähräämään ja löysin muutamankin ajastinkirjaston, kun en vieläkään tajua tuota millis() funktion käyttöä sen sijaan, että käyttäisi yksinkertaista, mutta muun toiminnan pysäyttävää delay() -funktiota. Löysin kirjastot BlockNot ja Neotimer, josta jälkimmäisen sain nähtävästi toimimaan tekoälykoodin avustuksella.

Joskus kirjastot on ihan ok. Se mikä noiden kanssa voi tulla aika nopeastikin vastaan on koodin koko, kirjastot kun tuppaa tekemään kaikenlaista mitä itse ei tarvitsisikaan. Tuo nyt ei vielä ole kovin iso mutta kannattaa pitää mielessä.

 

[Hyrava]

Joskus kirjastot on ihan ok. Se mikä noiden kanssa voi tulla aika nopeastikin vastaan on koodin koko, kirjastot kun tuppaa tekemään kaikenlaista mitä itse ei tarvitsisikaan. Tuo nyt ei vielä ole kovin iso mutta kannattaa pitää mielessä.

No, nykypäivänä jollakin arduinolla ei pitäisi ihan yhdellä tai kahdella kirjastolla tulla muisti sentään täyteen ellei oma koodi ole jo todella iso, toki osa kirjastoista on melkoista bloattia. Itse kyllä muistan kun joskus vuosia sitten tein olikohan se joku ATtiny tai vastaavan pienen kontrollerin kanssa projektia. Kontrollerissa tilaa oli olikohan 2 vai peräti 4 kilotavua, siinä sai jo välillä repiä kirjastoja riekaleiksi ja koittaa saada muutamia tavuja sieltä sun täältä säästettyä että koodi mahtui kontrolleriin. Ainakin HD44780-LCD:lle tein minimaalisen version josta oli kaikki turha poistettu, samoin DS18B20-onewire-kirjastolle tuli tehtyä vastaava "laihdutusleikkaus".

 

[Tupsa]

@Nasty76 , tuttu sivu! Lueskelin jo tuota aiemmin monta kertaa läpi, mutta ei vain mennyt kaaliin, miten tuo homma tapahtuu.

@ississ, joo tuossa katsoinkin tuota "Dynamic Memory" -kohtaa, jossa tuli tätä kirjastoa käyttäen 39 % käyttöön, ilman tätä jäi muistaakseni selvästi alle 30 prosenttiin.. Liekö käytönaikainen muistinkäyttö sitten vielä enempi? Parempihan se varmaan olisi käyttää mahdollisimman vähän kirjastoja, jolloin säästettäisiin resursseja. Kaipa se hidasteleva käyttökokemus monissa nykyvermeissä osin johtuu kirjastojen käytöstä. Ainakin varmaan yksi syy. Turhaa hommaa prosessorilla?

@Hyrava, kaikkea sitä pystyy tekemään, kun osaa! On nämä ohjelmointihommat mulle melkein täyttä hepreaa, monesti jokaisesta kirjaimesta tulee mieleen 10 kysymystä, eikä mistään löydä selkeää vastausta. Parempi olisi katsoa vaikka vuoden ajan päivittäin näitä hommia niin, että joku aina on neuvomassa oikeaan suuntaan, mutta ei nyt sellaisia ole lähipiirissä, eteenpäin on päästy varsinkin tämän ketjun vinkeillä. Koodia en osaa kirjoittaa paljon ollenkaan, mutta pianolla pystyn tekemään pari kolme biisiä päivässä.

Tähän ketjuun on jo osallistunut uskomattoman auttavaisia henkilöitä, ja olen jo aikaisemminkin varmaan kiitellyt, mutta mitäpä suotta jarruttelemaan, niin kiitos nyt vaan taas. Homma etenee hitaasti, mutta välillä vakaasti!

 

[Nasty76]

Tosin kirjoitin näemmä ihan höpöhöpö esimerkin. piti oikeen ihmetellä arduino online emulaattorilla miten oon ton ite tehny joten tähän selkeä lukunen esimerkki miten noilla millis arvoilla voidaan tehdä non block ajoa.

int period = 1000; //Tämä on viive joka odotetaan
unsigned long ramptimer = 0; // tämä on muuttuja esim jos ajetaan ramppia ylös tms tämä esimerkki tulostaa kerran sekunnissa tuon hello n

 
void setup() {
    Serial.begin(115200);
}
 
void loop() {
    
  
  
   if(ramptimer + period  <millis())
   {
    ramptimer=millis();
       Serial.println("Hello");
    }
}

 

[ississ]

No, nykypäivänä jollakin arduinolla ei pitäisi ihan yhdellä tai kahdella kirjastolla tulla muisti sentään täyteen ellei oma koodi ole jo todella iso, toki osa kirjastoista on melkoista bloattia. Itse kyllä muistan kun joskus vuosia sitten tein olikohan se joku ATtiny tai vastaavan pienen kontrollerin kanssa projektia. Kontrollerissa tilaa oli olikohan 2 vai peräti 4 kilotavua, siinä sai jo välillä repiä kirjastoja riekaleiksi ja koittaa saada muutamia tavuja sieltä sun täältä säästettyä että koodi mahtui kontrolleriin. Ainakin HD44780-LCD:lle tein minimaalisen version josta oli kaikki turha poistettu, samoin DS18B20-onewire-kirjastolle tuli tehtyä vastaava "laihdutusleikkaus".

Joo, 44780 ja ds- koodia on myös puukotettu mahtumaan pienempiin piireihin.
Olen käyttänyt enemmän atmega48/88/168 ja attiny13/15/25 kuin noita isompia, siksi tulee helposti mietittyä ensin myös koon puolesta.

@Nasty76 , tuttu sivu! Lueskelin jo tuota aiemmin monta kertaa läpi, mutta ei vain mennyt kaaliin, miten tuo homma tapahtuu.

@ississ, joo tuossa katsoinkin tuota "Dynamic Memory" -kohtaa, jossa tuli tätä kirjastoa käyttäen 39 % käyttöön, ilman tätä jäi muistaakseni selvästi alle 30 prosenttiin.. Liekö käytönaikainen muistinkäyttö sitten vielä enempi? Parempihan se varmaan olisi käyttää mahdollisimman vähän kirjastoja, jolloin säästettäisiin resursseja. Kaipa se hidasteleva käyttökokemus monissa nykyvermeissä osin johtuu kirjastojen käytöstä. Ainakin varmaan yksi syy. Turhaa hommaa prosessorilla?

@Hyrava, kaikkea sitä pystyy tekemään, kun osaa! On nämä ohjelmointihommat mulle melkein täyttä hepreaa, monesti jokaisesta kirjaimesta tulee mieleen 10 kysymystä, eikä mistään löydä selkeää vastausta. Parempi olisi katsoa vaikka vuoden ajan päivittäin näitä hommia niin, että joku aina on neuvomassa oikeaan suuntaan, mutta ei nyt sellaisia ole lähipiirissä, eteenpäin on päästy varsinkin tämän ketjun vinkeillä. Koodia en osaa kirjoittaa paljon ollenkaan, mutta pianolla pystyn tekemään pari kolme biisiä päivässä.

Tähän ketjuun on jo osallistunut uskomattoman auttavaisia henkilöitä, ja olen jo aikaisemminkin varmaan kiitellyt, mutta mitäpä suotta jarruttelemaan, niin kiitos nyt vaan taas. Homma etenee hitaasti, mutta välillä vakaasti!

Hidastelu riippuu kovasti siitä mitä kaikkea taustalla tehdään.
Hyvä esimerkki on arduino-framen digitalWrite(), jokaisella kutsukerralla se päättelee asioita annetun pinnin numeron perusteella (tämä tarvitaan että toimii kätevästi eri alustoilla), poistaa pwm:n käytöstä (= jos pinnille ei käytetä pwm:ää niin ei tarvitsisi), tallentaa avr- status- rekisterin ja poistaa keskeytykset käytöstä. Vasta sitten asetetaan lähtö ja palautetaan statusrekisteri ja keskeytykset.
Eli silloin kun tiedetään että joku pinni on vain digilähtö niin suurin osa tuosta on tavallaan turhaa ja voisi vaan kääntää portin oikeaan asentoon...

Ja kun aiemmin mainitsit koodin ymmärtämisestä siihen kuuluu yhtenä osana myös helppolukuisuus.
Kannattaa siis vaihtaa ne motorStatus = 2 -->> motorStatus = MOTOR_ON niin ei tarvitse muistaa mikä numero on mikä, antaa vaan jokaiselle numerolle selkeän tekstin.
Tiedoston alkuun vaan jonnekin #define MOTOR_ON 2 ja kaikki muut vastaavat myös, helpottaa lukemista huomattavasti eikä kuluta muistia yhtään koska kääntäjä käyttää suoraan noita numeroita.

Tosin kirjoitin näemmä ihan höpöhöpö esimerkin. piti oikeen ihmetellä arduino online emulaattorilla miten oon ton ite tehny joten tähän selkeä lukunen esimerkki miten noilla millis arvoilla voidaan tehdä non block ajoa.

int period = 1000; //Tämä on viive joka odotetaan
unsigned long ramptimer = 0; // tämä on muuttuja esim jos ajetaan ramppia ylös tms tämä esimerkki tulostaa kerran sekunnissa tuon hello n

 
void setup() {
    Serial.begin(115200);
}
 
void loop() {
   
 
 
   if(ramptimer + period  <millis())
   {
    ramptimer=millis();
       Serial.println("Hello");
    }
}

Ajan vertailu pitäisi tehdä (millis() - alkuaika) ja vertaamalla sitä rajaan, muuten tulee epämääräisiä aikoja kun millis vuotaa yli (n. 50 päivän välein). Eli mieluummin aina näin:

if ( ( millis() - ramptimer ) > period ) {
  ramptimer = millis();
  Serial.print("Hello");
}

Täältä lukemista jos kaipaa varmistusta: Arduino Tutorial: Avoiding the Overflow Issue When Using millis() and micros() – Norwegian Creations , How can I handle the millis() rollover?

Ja kyllä, jos oletetaan että systeemi ei koskaan ole ~50 päivää käytössä niin ei väliä. Mutta jos aina tekee samalla tavalla oikein niin sitten ei tarvitse miettiä miten pitää tehdä jos tarvitseekin pidempiä käyntiaikoja vaan menee heti oikein.

 

[Nasty76]

Joo totta enpä ole ajatellut omissa sovelluksissa tuota millis ympäri pyörähdystä tulipa itsekkin opittua taas jotain uutta

 

[Tupsa]

No niin, tässä söhläsin taas hieman noita testejä, nyt oskilloskoopin kanssa, niin kylläpä nuo ajastukset näyttää odotetusti toimivan! Tilat vaihtuu hienosti ja PWM:n työsuhde on oikein. Huippujännite Arduinon PWM-pinniltä vaan on nyt jostain syystä n. 2,7 volttia, johtunee siitä, kun Arduino kortti on pohjakortilla, mutta pohjakortti ei saa mistään virtaan. En olisi tästä nyt hirveän huolissaan. Kunhan saadaan kaikki osat kotiin, niin voidaan testata ihan 12 voltin virtalähteellä koko hässäkkää.

Tässäpä kuvia nyt hieman jälkijättöisesti projektista.

1. Testikokoonpano laturilla ja moottorilla. Tämä jää pois, kun on päätetty hankkia kuitenkin vaaka-akselimoottori. Uusiokäytetään tosta ainakin laturin kiinnitysvarsi ja perusrunko. Vaakamoottorilla systeemin saa merkittävästi matalammaksi.







2. Pohjakortin valmistelua

 

[Tupsa]

Joo, tässäpä taas vähän päivitystä koodiin. Siinä olisi nyt sähköstarttaus ja RPM-mittaus mukana. Tuon starttausfunktion sain kohtuudella testattua, että se meni 5. yritykseen asti, jolloin siirrytään moottorin tilaan 5 (virhe).

Tärkeä toiminto tuostakin vielä puuttuu, eli se on kyllä ajastimeen määritelty, mutta pitää vielä lisätä siihen, eli tauko starttausyrityksen jälkeen.

Nyt koodi ei kuitenkaan enää toimi oikein, kun kokeilin saada tuota odotusaika timeria tuohon. Se jää startTry == 0, eli ei etene ekasta yrityksestä. Eli joku ongelma tuossa varmastikin on nyt logiikassa ehkä niin, että ajastin ei pääse käynnistymään (reset loopilla) tai muuta vastaavaa. Saa tutkia jos kiinnostaa!

BTW voisiko olla tämä kohta:

 } else if (startTry == 0) {  // If attempt not done yet
        crankWait.stop();          // stop wait timer

Tuo on kyllä minun maallikkoymmärryksen mukaan toisen funktion sisällä, mutta toimiiko kuitenkin niin, että estää ajastimen käynnistymisen?

BTW koodissa on jotkut kommentit väärin, koska jonkin verran on testiä varten muutoksia, esim. voltageWait timer, on lyhennetty 2 sekuntiin.

#define DEBUG  // Serial debug, comment to disable

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <neotimer.h>  // Timer from Neotimer library

Neotimer motorTime = Neotimer(10000);   // 10 second timer for startup detection
Neotimer stepTime = Neotimer(1000);     // 1 second timer for PWM step interval
Neotimer shutTime = Neotimer(10000);    // 10 second timer for engine shutdown (wait before switching PWM back to 100 %, electromagnet off)
Neotimer crankTime = Neotimer(4000);    // 4 second timer, if problems to start, try at most 4 seconds cranking
Neotimer crankWait = Neotimer(5000);    // 5 second timer, if crack failed, wait 5 seconds before a new try
Neotimer voltageWait = Neotimer(2000);  // 60 seconds timer, how long to wait with assigned conditions, before the starting function executes

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 (vibration sensor), HIGH = motor running, TEST purpose LOW
const int pwmPin = 9;       // PWM output pin
const int relayPin = 4;     // Shutdown relay control pin
const int rpmPin = 11;      // RPM Hall Sensor input pin
const int starterPin = 3;   // Starter relay control pinn

// Current and voltage calculation
float voltageFactor = 5.00 / 1023.00;  // Factor to convert ADC reading to voltage

// 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 the 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

// PWM
int pwmValues[] = { 24, 41, 58, 77 };  // PWM duty cycle steps, 77 = ~30 %
int currentPwmStep = 0;

// Motor state, starting and shutting down
int motorStatus;            // 0=stopped, waiting for low voltage 1=not running, deary for cranking, 2=started, 3=ramping up pwm, 4=running, 5=system or engine malfuntion, stopped
int startTry;               // 0=not tried to start yet, 1=first try done, 2=second, 3=third, 4=fourth, 5=fifth
float startVoltage = 11.9;  // Volts, under what voltage the starting function will execute
float shutCurrent = 5;      // Amperes, below what charging current to execute the shutdown function
float upVoltage = 15;       // Volts, max allowed voltage
float rpmTH = 300;          // Revolutions per minute, rpm threshold greater than this to stop cranking (assume motor is started rpms over the threshold)
float rpmRun = 1800;        // Revolutions per minute, the rpm greater than this is accounted as motor normal running

//RPM Calculation
unsigned long rpm = 0;   // Variable to store rpm value
unsigned long duration;  // Sensor pulse in duration

// int lcdStep;                      //0=current display, 1=voltage display, not used at the time

void setup() {

  Serial.begin(250000);  // Start the serial communication

#ifdef DEBUG
  Serial.println("Setup...");
#endif

  Wire.begin();
  // Check if the LCD is connected
  Wire.beginTransmission(0x27);
  if (Wire.endTransmission() == 0) {
    // LCD is connected, proceed with initialization
    delay(50);
    lcd.begin(16, 2);
    lcd.backlight();
    lcd.clear();
  } else {
    // LCD is not connected, continue without initializing the LCD

#ifdef DEBUG
    Serial.println("Ei LCD:ta. Ohitus.");
#endif
  }

  // 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
  pinMode(rpmPin, INPUT_PULLUP);    // RPM sensing pin
  pinMode(starterPin, OUTPUT);      // Engine starter relay pin

  // Start Duty Cycle at 100 %, alternator electromagnet off, for starting the engine
  analogWrite(pwmPin, 255);

#ifdef DEBUG
  Serial.println("Setup ok.");
#endif
}


void motorCrankState() {  // Detection of undervoltage to trigger motor cranking function

  if (motorStatus == 0 && sensVoltage < startVoltage) {  // If motorStatus is 0 and sensed voltage is less than start voltage, trigger cranking function

#ifdef DEBUG
    Serial.println("Jannitekynnys kaynnistykseen!");
#endif

    if (!voltageWait.started()) {  // Start the voltageWait timer only, if it has not been started yet
      voltageWait.start();         // Start the voltageWait timer if it hasn't started yet
    }

    if (voltageWait.done()) {  // Wait for voltageWait to be done before moving to the cranking of the engine
      motorStatus = 1;
      voltageWait.reset();  // Reset timer
    }

  } else if (motorStatus == 0) {
    voltageWait.stop();  // Else, stop timer
    voltageWait.reset();
  }
}


void Crank1() {  // Engine start first attempt

  if (motorStatus == 1 && startTry == 0 && rpm == 0) {  // If conditions are met, start executing

    if (rpm <= rpmTH) {  // If motor runs slower than the threshold, switch starter relay on
      digitalWrite(starterPin, LOW);

      if (!crankTime.started()) {  // Start the crankTime timer only, if it has not been started yet
        crankTime.start();         // Start the crankTime timer if it hasn't started yet
      }

      if (crankTime.done()) {            // If motor did not start during the crankTime, stop starting
        digitalWrite(starterPin, HIGH);  // Switch starter relay off
        crankTime.reset();               // Reset timer

        // Waiting time between starting attempts
        if (!crankWait.started()) {
          crankWait.start();
        }

        if (crankWait.done()) {  // If waiting time full
          startTry = 1;          // attempt done
          crankWait.reset();     // Reset timer
        }

      } else if (startTry == 0) {  // If attempt not done yet
        crankWait.stop();          // stop wait timer
              
      }

    } else if (rpm > rpmTH) {  // If motor runs faster than the threshold, switch starter relay off
      digitalWrite(starterPin, HIGH);
      crankTime.stop();
      startTry = 1;
      motorStatus = 2;
      crankTime.reset();  // Reset timer
    }
  }
}

void Crank2() {  // Engine start second attempt

  if (motorStatus == 1 && startTry == 1 && rpm == 0) {  // If conditions are met, start executing

    if (rpm <= rpmTH) {  // If motor runs slower than the threshold, switch starter relay on
      digitalWrite(starterPin, LOW);

      if (!crankTime.started()) {  // Start the crankTime timer only, if it has not been started yet
        crankTime.start();         // Start the crankTime timer if it hasn't started yet
      }

      if (crankTime.done()) {            // If motor did not start during the crankTime, stop starting
        digitalWrite(starterPin, HIGH);  // Switch starter relay off
        crankTime.reset();               // Reset timer

        // Waiting time between starting attempts
        if (!crankWait.started()) {
          crankWait.start();
        }

        if (crankWait.done()) {  // If waiting time full
          startTry = 2;          // attempt done
          crankWait.reset();     // Reset timer
        }

      } else if (startTry == 1) {  // If attempt not done yet
        crankWait.stop();          // stop wait timer
      
      }

    } else if (rpm > rpmTH) {  // If motor runs faster than the threshold, switch starter relay off
      digitalWrite(starterPin, HIGH);
      crankTime.stop();
      startTry = 2;
      motorStatus = 2;
      crankTime.reset();  // Reset timer
    }
  }
}


void Crank3() {  // Engine start third attempt

  if (motorStatus == 1 && startTry == 2 && rpm == 0) {  // If conditions are met, start executing

    if (rpm <= rpmTH) {  // If motor runs slower than the threshold, switch starter relay on
      digitalWrite(starterPin, LOW);

      if (!crankTime.started()) {  // Start the crankTime timer only, if it has not been started yet
        crankTime.start();         // Start the crankTime timer if it hasn't started yet
      }

      if (crankTime.done()) {            // If motor did not start during the crankTime, stop starting
        digitalWrite(starterPin, HIGH);  // Switch starter relay off
        crankTime.reset();               // Reset timer

        // Waiting time between starting attempts
        if (!crankWait.started()) {
          crankWait.start();
        }

        if (crankWait.done()) {  // If waiting time full
          startTry = 3;          // attempt done
          crankWait.reset();     // Reset timer
        }

      } else if (startTry == 2) {  // If attempt not done yet
        crankWait.stop();          // stop wait timer
      
      }

    } else if (rpm > rpmTH) {  // If motor runs faster than the threshold, switch starter relay off
      digitalWrite(starterPin, HIGH);
      crankTime.stop();
      startTry = 3;
      motorStatus = 2;
      crankTime.reset();  // Reset timer
    }
  }
}

void Crank4() {  // Engine start fourth attempt

  if (motorStatus == 1 && startTry == 3 && rpm == 0) {  // If conditions are met, start executing

    if (rpm <= rpmTH) {  // If motor runs slower than the threshold, switch starter relay on
      digitalWrite(starterPin, LOW);

      if (!crankTime.started()) {  // Start the crankTime timer only, if it has not been started yet
        crankTime.start();         // Start the crankTime timer if it hasn't started yet
      }

      if (crankTime.done()) {            // If motor did not start during the crankTime, stop starting
        digitalWrite(starterPin, HIGH);  // Switch starter relay off
        crankTime.reset();               // Reset timer

        // Waiting time between starting attempts
        if (!crankWait.started()) {
          crankWait.start();
        }

        if (crankWait.done()) {  // If waiting time full
          startTry = 4;          // attempt done
          crankWait.reset();     // Reset timer
        }

      } else if (startTry == 3) {  // If attempt not done yet
        crankWait.stop();          // stop wait timer
      
      }

    } else if (rpm > rpmTH) {  // If motor runs faster than the threshold, switch starter relay off
      digitalWrite(starterPin, HIGH);
      crankTime.stop();
      startTry = 4;
      motorStatus = 2;
      crankTime.reset();  // Reset timer
    }
  }
}

void Crank5() {  // Engine start fifth attempt

  if (motorStatus == 1 && startTry == 4 && rpm == 0) {  // If conditions are met, start executing

    if (rpm <= rpmTH) {  // If motor runs slower than the threshold, switch starter relay on
      digitalWrite(starterPin, LOW);

      if (!crankTime.started()) {  // Start the crankTime timer only, if it has not been started yet
        crankTime.start();         // Start the crankTime timer if it hasn't started yet
      }

      if (crankTime.done()) {            // If motor did not start during the crankTime, stop starting
        digitalWrite(starterPin, HIGH);  // Switch starter relay off
        motorStatus = 5;                 // Fault state
        crankTime.reset();               // Reset timer

        // Waiting time between starting attempts
        if (!crankWait.started()) {
          crankWait.start();
        }

        if (crankWait.done()) {  // If waiting time full
          startTry = 5;          // attempt done
          crankWait.reset();     // Reset timer
        }

      } else if (startTry == 4) {  // If attempt not done yet
        crankWait.stop();          // stop wait timer
      
      }

    } else if (rpm > rpmTH) {  // If motor runs faster than the threshold, switch starter relay off
      digitalWrite(starterPin, HIGH);
      crankTime.stop();
      startTry = 5;
      motorStatus = 2;
      crankTime.reset();  // Reset timer
    }
  }
}


void motorRunning() {  // Engine running detection

  if ((motorStatus == 2) && digitalRead(motorPin) == HIGH || rpm > rpmRun) {  // If engine runs faster than rpmRun value (revolution per minute) assume motor is running normally

    motorTime.reset();  // Reset the timer

#ifdef DEBUG
    Serial.println("Kayntitieto!");
#endif

    if (!motorTime.started()) {  // Start the motorTime timer only, if it has not been started yet
      motorTime.start();         // Start the motorTime timer if it hasn't started yet
    }

    if (motorTime.done()) {  // Wait for motorTime to be done before moving to ramping up PWM

      motorStatus = 3;

#ifdef DEBUG
      Serial.println("Kay.");
#endif
    }

  } else if (motorStatus == 0 || motorStatus == 1) {
    motorTime.stop();  // Stop the timer if motor is not running before ramping up state

#ifdef DEBUG
    Serial.println();
    Serial.println("Kaynnistys...");
#endif

    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() {  // Ramping up PWM

  //Ramp pwm up
  if (motorStatus == 3) {
    stepTime.reset();  // Reset the timer
    if (stepTime.repeat()) {
      analogWrite(pwmPin, pwmValues[currentPwmStep]);
      currentPwmStep++;

#ifdef DEBUG
      Serial.println("Ramp up...");
#endif

      if (currentPwmStep >= sizeof(pwmValues) / sizeof(pwmValues[0])) {  //Checking the pwm step count

        motorStatus = 4;  // Motor running on normal charging state
      }
    }
  }
}


void shutDown() {  // Engine shutdown, execute relay

  // If the charging current drops to 0 to shutCurrent and charging voltage is under upVoltage and motor is running
  // start the shutdown function and turn off the relay
  if (current >= 0 && current < shutCurrent && sensVoltage < upVoltage && digitalRead(motorPin) == HIGH && motorStatus == 4) {

    shutTime.reset();  // Reset the timer
    digitalWrite(relayPin, LOW);
    analogWrite(pwmPin, 15);  // Duty Cycle to 5 % before running down engine

    if (!shutTime.started()) {  // Wait for shutDelay time to engine have time to stall down
      shutTime.start();
    }

    if (shutTime.done()) {
      analogWrite(pwmPin, 255);  // Stopped Duty Cycle at 100 %, alternator electromagnet off
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Sammutus");

      motorStatus = 0;  // Motor has run, battery is full, go back to waiting voltage

#ifdef DEBUG
      Serial.println("Sammutettu.");
#endif
    }

  } else if (motorStatus == 4) {
    motorTime.stop();              // Stop the timer if motor is in state 4 (normal running)
    digitalWrite(relayPin, HIGH);  // Else, keep relay on

#ifdef DEBUG
    Serial.println("Kaynnissa.");
#endif
  }
}


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

  if (motorStatus == 4) {

    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");

#ifdef DEBUG
    Serial.println("Virta LCD.");
#endif
  }
}


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


  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


  // RPM Calculation from Hall Sensor input
  {
    duration = pulseIn(rpmPin, FALLING, 500000);  // Times the amount of microseconds the motor is not timing IR, Times out after 100000 uS. Raise the timeout for slower RPM readings. .5 second
    rpm = 60000.0 / duration * 1000;              // See above
  }

  motorCrankState();
  Crank1();
  Crank2();
  Crank3();
  Crank4();
  Crank5();
  motorRunning();
  rampUp();
  shutDown();
  showCurrent();

  //Debug
#ifdef DEBUG
  Serial.print("Jannite: ");
  Serial.print((float)sensVoltage);
  Serial.println();
  Serial.print("Virta: ");
  Serial.print((float)current);
  Serial.println();
  Serial.print("Tila: ");
  Serial.print(motorStatus);
  Serial.println();
  Serial.print("Start tila: ");
  Serial.print(startTry);
  Serial.println();
#endif
}

 

[ississ]

Joo, tässäpä taas vähän päivitystä koodiin. Siinä olisi nyt sähköstarttaus ja RPM-mittaus mukana. Tuon starttausfunktion sain kohtuudella testattua, että se meni 5. yritykseen asti, jolloin siirrytään moottorin tilaan 5 (virhe).

Tärkeä toiminto tuostakin vielä puuttuu, eli se on kyllä ajastimeen määritelty, mutta pitää vielä lisätä siihen, eli tauko starttausyrityksen jälkeen.

Nyt koodi ei kuitenkaan enää toimi oikein, kun kokeilin saada tuota odotusaika timeria tuohon. Se jää startTry == 0, eli ei etene ekasta yrityksestä. Eli joku ongelma tuossa varmastikin on nyt logiikassa ehkä niin, että ajastin ei pääse käynnistymään (reset loopilla) tai muuta vastaavaa. Saa tutkia jos kiinnostaa!

BTW voisiko olla tämä kohta:

 } else if (startTry == 0) {  // If attempt not done yet
        crankWait.stop();          // stop wait timer

Tuo on kyllä minun maallikkoymmärryksen mukaan toisen funktion sisällä, mutta toimiiko kuitenkin niin, että estää ajastimen käynnistymisen?

crankWait on määritetty koodin alussa ja se on globaali muuttuja, on siis olemassa kaikkialla ja siten voi vaikuttaa.

Ihan ensin kannattaa viimeistään tässä vaiheessa muuttaa nuo motorStatus- arvot #define teksteiksi koska tiloja muistettavaksi tulee lisää.

Et tarvitse 5 yritykselle viittä funktiota. Yksi riittää koska kaikki muuttujat ovat globaaleja. Pitää vain kasvattaa yritysten lukumäärää ja lopettaa kun raja tulee vastaan. Vähemmän samanlaista koodia tehtäväksi ja testattavaksi.

Ja ehkä mieluummin niin että tiloja on enemmän, se ei maksa mitään koska muuttuja on jo olemassa. Näin saat helpommin hoidettua tilat
"ei käy" -> "odotus kun matala jännite havaittiin" -> "käynnistys" -> "odotus jos käynnistys ei onnistunut" sekä "käy" ja "virhe".

- Käynnistä ajastin vain silloin kun tiedät että on tietty tilan vaihto seuraavaan.
- Sammuta edellinen ajastin aina kun sen aika täyttyy
- Kirjastosta riippuen ajastimen reset() joko juuri ennen aloitusta tai lopetuksen jälkeen
- On helpompi lisätä uusi tila tarvittaessa kuin päätellä jossain pitikö nyt odottaa vai ei
- Koska startTry on globaali muuttuja, riittää että kutsuu yhtä funktiota ja tutkii muuttujan arvoa. Jos liian suuri niin tuli virhe ja vaihdetaan tila sen mukaan. Jos ei vielä liian suuri niin kasvatetaan yhdellä ja yritetään uudelleen (eli tilan vaihto sopivasti).
- Käytä sopivasti nimettyjä muuttujia tai mieluummin vakioita (#define) silloin kun arvot eivät muutu koodin suorituksen aikana, helputtaa lukemista ja sitä kautta ymmärtämistä
- Kannattaa välttää else- haarassa tekemistä, varsinkin jos ehdot eivät ole täysin yksiselitteiset
- Tunnista se ehto jonka seurauksena pitää vaihtaa tilasta toiseen. Ja juuri siinä kohdassa tehdään ne asiat jotka pitää tehdä vain kerran (ajastimen sammutus/aloitus, tulostus, jne)

En testannut mitenkään, mutta ehkä tähän tyyliin (huom: switch-case toimii kuten if () else if () else if () jne), se on vaan omasta mielestäni näppärämpi kirjoittaa. Ja tässä motorState- numeroarvoilla ei oikeasti ole merkitystä koska käytetään loogisia nimiä. Järjestyksellä ei siis myöskään ole merkitystä.

#define MOTOR_OFF                0
#define MOTOR_RUNNING            1
#define MOTOR_STARTING           2
#define MOTOR_START_WAIT         3
#define MOTOR_START_RETRY_WAIT   4
#define MOTOR_START_FAILED       5

#define MOTOR_RUNNING_MIN_RPM    300
#define START_VOLTAGE            11.9


void motorCrank() {

    switch (motorStatus ) {

    case MOTOR_OFF:
        // Ei käynnissä -> käynnistetään jos jännite tarpeeksi matala
        if ( sensVoltage < START_VOLTAGE ) {
            motorStatus = MOTOR_START_WAIT;   // Seuraava tila -> odotetaan ennen käynnistystä
            voltageWait.reset();    // Ajastuksen aloitus
            voltageWait.start();
            Serial.println("Jännite matala -> odotus ja käynnistys");
        } // else: ei käynnissä ja jännite riittävä
        break;

    case MOTOR_START_WAIT:
        // Käynnistysviive matalan jännitteen havaitsemisen jälkeen
        if ( voltageWait.done() ) {  // Odotusaika meni -> käynnistetään
            voltageWait.stop();      // Ajastin seis
            voltageWait.reset();
            motorStatus = MOTOR_STARTING;   // Seuraava tila -> startti
            digitalWrite(starterPin, LOW);  // Startti päälle
            crankTime.reset();       // Ajastuksen aloitus
            crankTime.start();
            Serial.println("Jännite matala -> odotus ohi -> käynnistys");
        } // else: odotetaan että aika kuluu ennen starttia
        break;

    case MOTOR_STARTING:
        // Käynnistys menossa
        if ( rpm > MOTOR_RUNNING_MIN_RPM ) {
            // Käynnistyi ennen ajastinta -> startti pois ja ok
            digitalWrite(starterPin, HIGH);   // Startti pois
            crankTime.stop();       // Ajastuksen lopetus
            crankTime.reset();
            motorStatus = MOTOR_RUNNING;   // Seuraava tila -> käy
            Serial.println("Käynnistetty");
        } else if ( crankTime.done() ) {
            // Ei käynnistynyt ennen ajastuksen loppua -> odotus ja uusi yritys
            digitalWrite(starterPin, HIGH);        // Startti pois
            motorStatus = MOTOR_START_RETRY_WAIT;  // Seuraava tila: odotetaan yritysten välissä
            crankTime.stop();       // Ajastuksen lopetus
            crankTime.reset();
            crankWait.reset();       // Ajastuksen aloitus
            crankWait.start();
            Serial.println("Käynnistys ei onnistunut -> odotus ja uusi yritys");
        } // else: odotellaan että aika kuluu
        break;

    case MOTOR_START_RETRY_WAIT:
        // Käynnistysyrityksen jälkeinen odotus menossa
        if ( crankWait.done() ) {
            // Odotus meni, yritetään käynnistää eli palataan alkuun
            motorStatus = MOTOR_OFF;  // Seuraava tila -> sammutettu, ei käynnistynyt niin jännite- ehto aloittaa seuraavan yrityksen
            startTry += 1;            // Yritysten lukumäärä +1
            Serial.print("Käynnistys ei onnistunut -> odotus meni -> yritys "); Serial.println(startTry);
            crankWait.stop();         // Ajastuksen lopetus
            crankWait.reset();
            if ( startTry > START_COUNT_LIMIT ) {
                // Jos yrityksiä on enemmän kuin sallitaan, vaihdetaan tilaksi virhe
                Serial.println("Käynnistys epäonnistui -> jäädään virheeseen");
                motorStatus = MOTOR_START_FAILED;
            }
        } // else: odotellaan että aika kuluu

        break;

    case MOTOR_RUNNING:
        // Jos pitää tehdä jotain käydessä, joka loop() kierroksella
        break;


    case MOTOR_START_FAILED:
        // Jos pitää tehdä jotain virhetilassa, joka loop() kierroksella
        break;

    }

}

 

[Tupsa]

On tuo @ississ :n koodi kyllä taas hieno.

Sain tämmöisellä sähellyksellä toimimaan tuon, eli koodi myös lyheni aika paljon, on vain kolme funktiota viiden sijaan. Uudet ovat tuo Waiter(), jossa tehdään se odottelu sekä lyhyt startFail(), joka muuttaa moottorin tilan 5:een (virhe), jos käynnistys ei onnistu.

Ihan varmasti olisi parempia, nätimpiä tapoja tehdä tämä, mutta yritän tässä samalla opetella koodauksen alkeita. Näihin muutoksiin käytin hyvin vähän tekoälyn apuja, että kai sitä edes sen verran on oppinut, että jotenkin pysyy tuollaisessa rumassa koodissa selvillä, mitä se tekee.

Kun nuo jännite- ja virtatulot nyt kelluu kätevästi testaamista ajatellen, pystyin testaamaan tämän starttifunktion siltä osin, että kännistys ei onnistu. Tilat vaihtuu oikein.

Nyt jos viitsii, pitäisi testailla ehkä kolmella potikalla koko koodin toimintaa. Mutta minulla ei ole kuin yksi potentiometri ja kytkennästä tulisi hirmuinen hässäkkä. Jännitettä ja virtaa pystyy suoraan potikalla ohjaamaan, mutta tuo rpm-anturikoodi on netistä tällaiselle anturille tarkoitettu: A3144

Tuota sisääntuloa ei voine suoraan potikalla simuloida.

#define DEBUG  // Serial debug, comment to disable

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <neotimer.h>  // Timer from Neotimer library

Neotimer motorTime = Neotimer(10000);   // 10 second timer for startup detection
Neotimer stepTime = Neotimer(1000);     // 1 second timer for PWM step interval
Neotimer shutTime = Neotimer(10000);    // 10 second timer for engine shutdown (wait before switching PWM back to 100 %, electromagnet off)
Neotimer crankTime = Neotimer(4000);    // 4 second timer, if problems to start, try at most 4 seconds cranking
Neotimer crankWait = Neotimer(5000);    // 5 second timer, if crank failed, wait 5 seconds before a new try
Neotimer voltageWait = Neotimer(2000);  // 60 seconds timer, how long to wait with assigned conditions, before the starting function executes

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 (vibration sensor), HIGH = motor running, TEST purpose LOW
const int pwmPin = 9;       // PWM output pin
const int relayPin = 4;     // Shutdown relay control pin
const int rpmPin = 11;      // RPM Hall Sensor input pin, sensor type: 3144
const int starterPin = 3;   // Starter relay control pinn

// Current and voltage calculation
float voltageFactor = 5.00 / 1023.00;  // Factor to convert ADC reading to voltage

// 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 the 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

// PWM
int pwmValues[] = { 24, 41, 58, 77 };  // PWM duty cycle steps, 77 = ~30 %
int currentPwmStep = 0;

// Motor state, starting and shutting down
int motorStatus;            // 0=stopped, waiting for low voltage 1=not running, ready for cranking, 2=started, 3=ramping up pwm, 4=running, 5=system or engine malfuntion, stopped
int startTry;               // 0=not tried to start yet, 1=first try done, 2=second, 3=third, 4=fourth, 5=fifth
int startInterval;          // 0=not waiting after start attempt, 1 = start waiting running
float startVoltage = 11.9;  // Volts, under what voltage the starting function will execute
float shutCurrent = 5;      // Amperes, below what charging current to execute the shutdown function
float upVoltage = 15;       // Volts, max allowed voltage
float rpmTH = 300;          // Revolutions per minute, rpm threshold greater than this to stop cranking (assume motor is started rpms over the threshold)
float rpmRun = 1800;        // Revolutions per minute, the rpm greater than this is accounted as motor normal running

//RPM Calculation
unsigned long rpm = 0;   // Variable to store rpm value
unsigned long duration;  // Sensor pulse in duration

// int lcdStep;                      //0=current display, 1=voltage display, not used at the time


void setup() {

  Serial.begin(250000);  // Start the serial communication

#ifdef DEBUG
  Serial.println("Setup...");
#endif

  Wire.begin();
  // Check if the LCD is connected
  Wire.beginTransmission(0x27);
  if (Wire.endTransmission() == 0) {
    // LCD is connected, proceed with initialization
    delay(50);
    lcd.begin(16, 2);
    lcd.backlight();
    lcd.clear();
  } else {
    // LCD is not connected, continue without initializing the LCD

#ifdef DEBUG
    Serial.println("Ei LCD:ta. Ohitus.");
#endif
  }

  // 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
  pinMode(rpmPin, INPUT_PULLUP);    // RPM sensing pin
  pinMode(starterPin, OUTPUT);      // Engine starter relay pin

  // Start Duty Cycle at 100 %, alternator electromagnet off, for starting the engine
  analogWrite(pwmPin, 255);

#ifdef DEBUG
  Serial.println("Setup ok.");
#endif
}


void motorCrankState() {  // Detection of undervoltage to trigger motor cranking function

  if (motorStatus == 0 && sensVoltage < startVoltage) {  // If motorStatus is 0 and sensed voltage is less than start voltage, trigger cranking function

#ifdef DEBUG
    Serial.println("Jannitekynnys kaynnistykseen!");
#endif

    if (!voltageWait.started()) {  // Start the voltageWait timer only, if it has not been started yet
      voltageWait.start();         // Start the voltageWait timer if it hasn't started yet
    }

    if (voltageWait.done()) {  // Wait for voltageWait to be done before moving to the cranking of the engine
      motorStatus = 1;
      voltageWait.reset();  // Reset timer
    }

  } else if (motorStatus == 0) {
    voltageWait.stop();  // Else, stop timer
    voltageWait.reset();
  }
}


void crank() {  // Engine starting function

  if (motorStatus == 1 && (startTry >= 0 && startTry <= 4) && startInterval == 0 && rpm == 0) {  // If conditions are met, start executing

    if (rpm <= rpmTH) {  // If motor runs slower than the threshold, switch starter relay on
      digitalWrite(starterPin, LOW);

      if (!crankTime.started()) {  // Start the crankTime timer only, if it has not been started yet
        crankTime.start();         // Start the crankTime timer if it hasn't started yet
      }

      if (crankTime.done()) {            // If motor did not start during the crankTime, stop starting
        digitalWrite(starterPin, HIGH);  // Switch starter relay off
        crankTime.reset();               // Reset timer
        startTry += 1;                   // Add one attempt
        startInterval = 1;               // Start waiting time function after starting attempt
      }

    } else if (rpm > rpmTH) {  // If motor runs faster than the threshold, switch starter relay off
      digitalWrite(starterPin, HIGH);
      crankTime.stop();
      startTry = 0;
      motorStatus = 2;
      crankTime.reset();  // Reset timer
    }
  }
}


void Waiter() {  // Wait after starting attempt

  if (motorStatus == 1 && (startTry >= 0 && startTry <= 4) && startInterval == 1 && rpm == 0) {  // If conditions are met, start executing

    if (!crankWait.started()) {  // Start the crankWait timer only, if it has not been started yet
      crankWait.start();         // Start the crankWait timer if it hasn't started yet
    }

    if (crankWait.done()) {  // If timer is done
      crankWait.reset();     // reset timer
      startInterval = 0;     // revert to state 0 (waiting time after start attempt ready)
    }

  } else if (startInterval == 0) {  // Else
    crankWait.stop();               // stop timer
    crankWait.reset();              // Reset timer
  }
}


void startFail() {  // If engine did not start put motor status to state 5 (malfunction)

  if (startTry == 5) {
    motorStatus = 5;
  }
}


void motorRunning() {  // Engine running detection

  if ((motorStatus == 2) && digitalRead(motorPin) == HIGH || rpm > rpmRun) {  // If engine runs faster than rpmRun value (revolution per minute) assume motor is running normally

    motorTime.reset();  // Reset the timer

#ifdef DEBUG
    Serial.println("Kayntitieto!");
#endif

    if (!motorTime.started()) {  // Start the motorTime timer only, if it has not been started yet
      motorTime.start();         // Start the motorTime timer if it hasn't started yet
    }

    if (motorTime.done()) {  // Wait for motorTime to be done before moving to ramping up PWM

      motorStatus = 3;

#ifdef DEBUG
      Serial.println("Kay.");
#endif
    }

  } else if (motorStatus == 0 || motorStatus == 1) {
    motorTime.stop();  // Stop the timer if motor is not running before ramping up state

#ifdef DEBUG
    Serial.println();
    Serial.println("Kaynnistys...");
#endif

    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() {  // Ramping up PWM

  //Ramp pwm up
  if (motorStatus == 3) {
    stepTime.reset();  // Reset the timer
    if (stepTime.repeat()) {
      analogWrite(pwmPin, pwmValues[currentPwmStep]);
      currentPwmStep++;

#ifdef DEBUG
      Serial.println("Ramp up...");
#endif

      if (currentPwmStep >= sizeof(pwmValues) / sizeof(pwmValues[0])) {  //Checking the pwm step count

        motorStatus = 4;  // Motor running on normal charging state
      }
    }
  }
}


void shutDown() {  // Engine shutdown, execute relay

  // If the charging current drops to 0 to shutCurrent and charging voltage is under upVoltage and motor is running
  // start the shutdown function and turn off the relay
  if (current >= 0 && current < shutCurrent && sensVoltage < upVoltage && digitalRead(motorPin) == HIGH && motorStatus == 4) {

    shutTime.reset();  // Reset the timer
    digitalWrite(relayPin, LOW);
    analogWrite(pwmPin, 15);  // Duty Cycle to 5 % before running down engine

    if (!shutTime.started()) {  // Wait for shutDelay time to engine have time to stall down
      shutTime.start();
    }

    if (shutTime.done()) {
      analogWrite(pwmPin, 255);  // Stopped Duty Cycle at 100 %, alternator electromagnet off
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Sammutus");

      motorStatus = 0;  // Motor has run, battery is full, go back to waiting voltage

#ifdef DEBUG
      Serial.println("Sammutettu.");
#endif
    }

  } else if (motorStatus == 4) {
    motorTime.stop();              // Stop the timer if motor is in state 4 (normal running)
    digitalWrite(relayPin, HIGH);  // Else, keep relay on

#ifdef DEBUG
    Serial.println("Kaynnissa.");
#endif
  }
}


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

  if (motorStatus == 4) {

    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");

#ifdef DEBUG
    Serial.println("Virta LCD.");
#endif
  }
}


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


  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


  // RPM Calculation from Hall Sensor input
  {
    duration = pulseIn(rpmPin, FALLING, 500000);  // Times the amount of microseconds the motor is not timing IR, Times out after 100000 uS. Raise the timeout for slower RPM readings. .5 second
    rpm = 60000.0 / duration * 1000;              // See above
  }

  motorCrankState();
  crank();
  Waiter();
  startFail();
  motorRunning();
  rampUp();
  shutDown();
  showCurrent();

  //Debug
#ifdef DEBUG
  Serial.print("Jannite: ");
  Serial.print((float)sensVoltage);
  Serial.println();
  Serial.print("Virta: ");
  Serial.print((float)current);
  Serial.println();
  Serial.print("Tila: ");
  Serial.print(motorStatus);
  Serial.println();
  Serial.print("Start tila: ");
  Serial.print(startTry);
  Serial.println();
  Serial.print("Odotus: ");
  Serial.print(startInterval);
  Serial.println();
#endif
}

 

[ississ]

On tuo @ississ :n koodi kyllä taas hieno.

Sain tämmöisellä sähellyksellä toimimaan tuon, eli koodi myös lyheni aika paljon, on vain kaksi funktiota viiden sijaan. Se toinen uusi on tuo Waiter(), jossa tehdään se odottelu.

Kun nuo jännite- ja virtatulot nyt kelluu kätevästi testaamista ajatellen, pystyin testaamaan tämän starttifunktion siltä osin, että kännistys ei onnistu. Tilat vaihtuu oikein.

Nyt jos viitsii, pitäisi testailla ehkä kolmella potikalla koko koodin toimintaa. Mutta minulla ei ole kuin yksi potentiometri ja kytkennästä tulisi hirmuinen hässäkkä. Jännitettä ja virtaa pystyy suoraan potikalla ohjaamaan, mutta tuo rpm-anturikoodi on netistä tällaiselle anturille tarkoitettu: Hall-virta-anturi ACS712 5A | ihmevekotin.fi .

Tuota sisääntuloa ei voine suoraan potikalla simuloida.

Hommaa lisää potikoita tai säädettäviä jännitelähteitä, muuten ei simulointi onnistu.
Tietysti kiinteät vastuksetkin käyvät jos tarvitaan vain muutama eri jännite.

Rpm- simulointiin tarvitset toisen arduinon (tai muu kanttiaaltogeneraattori) jolla tuottaa sopivaa signaalia.
Tässä tapauksessa jos on yksi anturi eli pulssi/kierros niin pwm- suhde on muutama %. Ja datalehden mukaan niin päin että normaalisti ylhäällä ja vaan käy alhaalla. Eli pitää varmistaa että pulsein() osaa tulkata alhaalla käyvän pulssin, muuten se odottaa turhaan koko sen ajan kun moottori kiertää yhden kierroksen eikä sen ajan jonka anturi kulkee magneetin ohi.

 

[Tupsa]

En onnistunut tähän löytämään nettistä selvää vastausta. En nyt viitsi tähän taas liittää koko koodia, mutta lyhyt pätkä. Miten TAI kirjoitetaan tuohon koodiin tai onko tuossa jokin muu vialla? Eli sellainen ehto olisi haussa, että jos | | -merkin kumpi puoli tahansa tahansa tai kumpikin täyttyy, suoritetaan funktio. Nyt vaikka tuossa tuo | | -merkintä on, niin se selvästi suoritetaan silti JA ehdolla eli molempien ehtojen on täytyttävä. Vai lieneekö vika sulkujen käytössä?

Koko koodia muuten sai testailtua aika pitkälle ilman mitään potikoitakaan, kun muutti tuon rpm:än kiinteäksi vaikkapa 500 rpm:ään. Hyvin se näytti pelittävän, joitakin reset(); komentoja oli ajastimelle väärin niin niitä jo tuli korjailtua. Parempi olisi toki suorittaa testi myös niin, että kierroslukua voi hallita. Ehkäpä se onnistuisi jotenkin sarjaportin kautta? Toki koodia tulisi muuttaa niin, että vaikkapa näppäinten 1, 2, ja 3 painallukset vastaisivat esim. 0, 500 ja 2000 rpm jne.

Lopullinen testi olisi sitten SpaceX-tyyliin kaikki romppeet valmiiksi ja radalle, räjähti tai ei.

EDIT: Jaa sieltähän se tekoälyltä tuli suoraan toimiva koodinpätkä tuohon testiin. Ja niin se tosiaan tuo alempi kohta koodista toimii, että oikeammaisinkin osa pitää toteutua, jotta koodi etenee.

void motorRunning() {  // Engine running detection

  if ((motorStatus == 2) && digitalRead(motorPin) == HIGH || rpm > rpmRun)

 

[ississ]

En onnistunut tähän löytämään nettistä selvää vastausta. En nyt viitsi tähän taas liittää koko koodia, mutta lyhyt pätkä. Miten TAI kirjoitetaan tuohon koodiin tai onko tuossa jokin muu vialla? Eli sellainen ehto olisi haussa, että jos | | -merkin kumpi puoli tahansa tahansa tai kumpikin täyttyy, suoritetaan funktio. Nyt vaikka tuossa tuo | | -merkintä on, niin se selvästi suoritetaan silti JA ehdolla eli molempien ehtojen on täytyttävä. Vai lieneekö vika sulkujen käytössä?

Koko koodia muuten sai testailtua aika pitkälle ilman mitään potikoitakaan, kun muutti tuon rpm:än kiinteäksi vaikkapa 500 rpm:ään. Hyvin se näytti pelittävän, joitakin reset(); komentoja oli ajastimelle väärin niin niitä jo tuli korjailtua. Parempi olisi toki suorittaa testi myös niin, että kierroslukua voi hallita. Ehkäpä se onnistuisi jotenkin sarjaportin kautta? Toki koodia tulisi muuttaa niin, että vaikkapa näppäinten 1, 2, ja 3 painallukset vastaisivat esim. 0, 500 ja 2000 rpm jne.

Lopullinen testi olisi sitten SpaceX-tyyliin kaikki romppeet valmiiksi ja radalle, räjähti tai ei.

EDIT: Jaa sieltähän se tekoälyltä tuli suoraan toimiva koodinpätkä tuohon testiin. Ja niin se tosiaan tuo alempi kohta koodista toimii, että oikeammaisinkin osa pitää toteutua, jotta koodi etenee.

void motorRunning() {  // Engine running detection

  if ((motorStatus == 2) && digitalRead(motorPin) == HIGH || rpm > rpmRun)

Kannattaa AINA käyttää sulkeita niin tietää tasan mitä itse haluaa ilmaista ilman että olettaa kääntäjän oletuksen olevan oikein (sen kannalta mitä pitää saada aikaan).

Edit: Vähintään näin:

if ( ( motorStatus == 2 ) && ( digitalRead(motorPin) == HIGH ) || ( rpm > rpmRun ) )

Mutta vielä mieluummin

if ( ( ( motorStatus == 2 ) && ( digitalRead(motorPin) == HIGH ) ) || ( rpm > rpmRun ) )

if ( ( motorStatus == 2 ) && ( ( digitalRead(motorPin) == HIGH ) || ( rpm > rpmRun ) ) )

Kumpi sitten onkaan se oikea ehto

 

[Tupsa]

@ississ , joo eli matikan tunneiltakin tuttua (pitäisi ainakin olla!).

Mutta siis mulla itsellä taisi vain ajatuskatkos tuossa tulla, sehän taitaakin silti toimia oikein, kun vain toinen ehto toteutuu, testissä rpm, niin ajetaan ylös. Toinen ehto on se motorPin, eli siis tärinäanturi, jota simuloidaan testissä kytkimellä, ja sitä ei käytetty testissä. Testaillaan vielä lisää...

Mutta kyllä varmaan nämä testit voi tehdä siis ilman kytkentöjäkin. Voisi laittaa samalla kaavalla myös jännitteen ja virran testimielessä näppäinten taakse, esim. a=3 A; b=30 A ja z=11.5 V; x=13.0 V.

Lopullinen testi ja kalibrointi tehdään sitten valmiilla systeemillä, missä nyt minkään ei pitäisi oikeasti hajota. Jännitteen kalibrointi tehdään ennen kuin edes moottori käy ja aloittaa latauksen oikein pienillä tehoilla varmuuden vuoksi.

 

[ississ]

@ississ , joo eli matikan tunneiltakin tuttua (pitäisi ainakin olla!).

Mutta siis mulla itsellä taisi vain ajatuskatkos tuossa tulla, sehän taitaakin silti toimia oikein, kun vain toinen ehto toteutuu, testissä rpm, niin ajetaan ylös. Toinen ehto on se motorPin, eli siis tärinäanturi, jota simuloidaan testissä kytkimellä, ja sitä ei käytetty testissä. Testaillaan vielä lisää...

Mutta kyllä varmaan nämä testit voi tehdä siis ilman kytkentöjäkin. Voisi laittaa samalla kaavalla myös jännitteen ja virran testimielessä näppäinten taakse, esim. a=3 A; b=30 A ja z=11.5 V; x=13.0 V.

Lopullinen testi ja kalibrointi tehdään sitten valmiilla systeemillä, missä nyt minkään ei pitäisi oikeasti hajota. Jännitteen kalibrointi tehdään ennen kuin edes moottori käy ja aloittaa latauksen oikein pienillä tehoilla varmuuden vuoksi.

Kysymys kuuluukin pitääkö oikeasti olla näin, tämä on siis tuo alempi vaihtoehto että tila pitää olla 2 ja sen jälkeen toinen (tai molemmat) ehdoista pitää täyttyä (pinni tai kierrokset) ?

if ( motorStatus == 2) {
    // Oliko tämä nyt moottori käynnistymässä vai mikä tila ?
    // Nyt se teksti tuon numeron 2 tilalla auttaisi ymmärtämään lukematta koko koodia jostain historiasta...

    if ((digitalRead(motorPin) == HIGH) || (rpm > rpmRun)) {
        // tärinäanturin mukaan moottori käy
        // tai kierrokset on yli rajan
        // -->> todetaan että moottori käy jos jompikumpi ehto toteutuu
    }
}

 

[TemeV]

En nyt viitsi tähän taas liittää koko koodia...

Laita se koodi vaikka Githubiin. Sieltä voi laittaa linkin tietylle riville, mitä kysymys koskee. Ongelmallinen kohta kannattaa toki pasteta silti tänne, niin keskustelua on mukavampi seurata. Ei tarvi kuitenkaan niin pitkiä pätkiä pasteta, koska vastaajat voi käydä katsomassa kontekstin Githubista, jos sille on tarvetta.

 

[Tupsa]

Kysymys kuuluukin pitääkö oikeasti olla näin, tämä on siis tuo alempi vaihtoehto että tila pitää olla 2 ja sen jälkeen toinen (tai molemmat) ehdoista pitää täyttyä (pinni tai kierrokset) ?

if ( motorStatus == 2) {
    // Oliko tämä nyt moottori käynnistymässä vai mikä tila ?
    // Nyt se teksti tuon numeron 2 tilalla auttaisi ymmärtämään lukematta koko koodia jostain historiasta...

    if ((digitalRead(motorPin) == HIGH) || (rpm > rpmRun)) {
        // tärinäanturin mukaan moottori käy
        // tai kierrokset on yli rajan
        // -->> todetaan että moottori käy jos jompikumpi ehto toteutuu
    }
}

Tuo on juuri oikein ymmärretty.

Mulla varmaan tuo numerokoodien käyttö on tuon next-level tason koodin käyttämisen pelkoa, mutta ennen kaikkea, kun on mehtäalalla tottunut enemmän tai vähemmän noihin numeroihin. Puulajeissa 1=mänty, 2=kuusi, 3=rauduskoivu jne.. Metsikön ravinteisuutta kuvaavat tunnukset: 1=lehto, 2=lehtomainen kangas, 3=tuore kangas, 4=kuivahko kangas jne..

 

[ississ]

Tuo on juuri oikein ymmärretty.

Mulla varmaan tuo numerokoodien käyttö on tuon next-level tason koodin käyttämisen pelkoa, mutta ennen kaikkea, kun on mehtäalalla tottunut enemmän tai vähemmän noihin numeroihin. Puulajeissa 1=mänty, 2=kuusi, 3=rauduskoivu jne.. Metsikön ravinteisuutta kuvaavat tunnukset: 1=lehto, 2=lehtomainen kangas, 3=tuore kangas, 4=kuivahko kangas jne..

Niin, onhan se hankalaa laitta numeron tilalle helppolukuinen teksti...
Tässä ei ole mitään next level- koodausta vaan ainoastaan vakioiden määrittelyä.
Enemmän next level voisi olla vaikka asioiden tekeminen itse (esim ilman digitalwrite()), keskeytykset, osoittimet ja vastaavat.

Tuolla logiikalla pitää sitten koodista vaihtaa TRUE -> 1 ja FALSE -> 0. Samoin digitalWrite/read kanssa käytettävät LOW -> 0 ja HIGH -> 1 ?
Minä taas en missään nimessä viitsi muistaa mikä numero on mikäkin tila koska sen voi nähdä suoraan tekstinäkin ja on huomattavasti luotettavampi.

Eihän funktioitakaan kannata nimetä f1(), f2(), f3() jne vaikka sekin olisi teknisesti ihan toimiva tapa.
Järkevät nimet muuttujille, funktioille ja vakioarvoille ovat kaikki yhtä tärkeitä auttamaan koodin ymmärtämistä ja helppolukuisuutta.

Niin kauan kuin teet jotain asiaa vain yksin niin on ihan sama mutta jos tekijöitä on 2 tai yli niin nimeäminen ja muotoilu muuttuu aina vaan tärkeämmäksi. Virheet vähenee ja on helpompi ymmärtää. Ja keskitytään olennaiseen (= itse koodin logikka eikä muistella oliko "moottori käy" tieto 3 vai 245)

 

[Nasty76]

Mä yleensä arduinoa testailessa teen koodin joka lukee sarjaportia ja splittaa tarvittavat muuttujat oikeisiin paikkoihin ja voin serialmonitorilla lähettää esim v13 A5 jonka Arduino muuttaisi voltit 13 ja ampeerit 5 silleen voi antaa koodin rullailla ja laitella eri tiloja sinne niin näkee toimiiko kaikki kuten tarkoitettu ja kyllä noi numerot on hyvä korvata nimellä niin itsellekin helpompi kun tietää heti mitä koitetaan tehdä

 

[Hyrava]

Itsekin kyllä suosittelen noita vakioiden määrittelyä vaikka koodailisi ihan yksin omaksi ilokseen. Sitten kun joku projekti toimii ja koodi jää "pöytälaatikkoon" vuodeksi-pariksi ja yhtäkkiä tuleekin tarve pitkän ajan päästä tehdä joku muutos koodiin niin on huomattavasti helpompi lukea jotain MOTOR_RUNNING kuin jotain random-numeroa. Tuo tietty edellyttää että nuo vakioiden nimet ovat kuvaavia. Itsekin tuon olen oppinut kantapään kautta kun joskus on tullut tapauksia että on muistanut että jossain on likipitäen valmis koodi jostain aiemmasta projektista ja sitten kun on jotain numeerisia tiloja ruvennut ihmettelemään ja kiroilemaan muokatessaan koodia uuteen projektiin sopivaksi. Nykyään tulee oikeastaan aina laitettua jotain kuvaavia nimiä numeroiden tilalle ainakin jos tiloja on enemmän kuin 2kpl. Samoin jos esimerkiksi pitkin koodia on vaikkapa samaa viivearvoa useammassa paikassa niin sekin on kätevä korvata tuollaisella vakiolla niin kaikki voi kerralla muuttaa joka paikkaan.

 

[Tupsa]

Päätin laittaa nyt tämän koko koodin taas tähän, kun siinä on nyt jonkin verran muutoksia. Laitoin nuo @ississ :n ja kumppaneiden suosittelemat selkokieliset tilat ja lisäksi olisi tarkoitus hidastaa tuota sarjaportin tulostusta, ei siitä kerkeä nyt näkemään mitään.

Lisäksi löytyihän sieltä ainakin yksi toimimaton funktio, sammutus ei mene päälle. Luulen, että tuossa on joku kämmi tuon timerin kanssa. Voi olla, että se nollaa timeria nyt koko ajan, jolloin ajastus ei pääse alkamaan.

Sama homma täytyy olla myös tuolla koodin loppupään DEBUG tulostuksen kanssa. Kokeilin varuiksi myös ilman #ifdef... makroja, niin ei sillä ollut vaikutusta. Jotain en nyt vain saa toimimaan tuossa Neotimer kirjaston käytössä. Tosi helppokäyttöinen sen pitäisi ohjeidensakin mukaan olla. Vastaava kohta kuitenkin tuolla rampup -funktiossa (repeat ()) toimii oikein hienosti. Eli nyt, kun laittaa esim. tuon repeatin tuhon tulostukseen, ei tulostu mitään. Samoin kävi kokeillessa start()-stop() -käytöntöä.

Saa tutkia taas koodia, jos kiinnostelee...

Lisäksi olisi koodin ulkopuolinen kysymys. Sopisikohan tuohon hall-sensoriksi TLE4905L? Ainakin tämänkin pitäisi olla samantyyppinen, pulsseista triggeröityvä digitaalinen (on-off) anturi. Tuossa koodissa on käytetty anturi tyypiltään 3144.

// Generator control system for car alternator (Ford with PWM controlled charging voltage) and small engine

#define DEBUG  // Serial debug, comment to disable

// System status variables (motorStatus)
#define WAITING 0
#define STARTING 1
#define STARTED 2
#define RAMP_UP 3
#define RUNNING 4
#define FAIL 5

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <neotimer.h>  // Non-blocking timer from Neotimer library

Neotimer motorTime = Neotimer(10000);   // 10 second timer for startup detection
Neotimer stepTime = Neotimer(1000);     // 1 second timer for PWM step interval
Neotimer shutTime = Neotimer(10000);    // 10 second timer for engine shutdown (wait before switching PWM back to 100 %, electromagnet off)
Neotimer crankTime = Neotimer(4000);    // 4 second timer, if problems to start, try at most 4 seconds continuous cranking
Neotimer crankWait = Neotimer(5000);    // 5 second timer, if crank failed, wait 5 seconds before a new try
Neotimer voltageWait = Neotimer(2000);  // 60 seconds timer, how long to wait with undervoltage & other assigned conditions, before the starting function executes
Neotimer serDelay = Neotimer(1000);     // For serial print interval

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 (vibration sensor), HIGH = motor running, TEST purpose LOW
const int pwmPin = 9;       // PWM output pin
const int relayPin = 4;     // Shutdown relay control pin
const int rpmPin = 11;      // RPM Hall Sensor input pin, sensor type: 3144
const int starterPin = 3;   // Starter relay control pinn

// Current and voltage calculation
float voltageFactor = 5.00 / 1023.00;  // Factor to convert ADC reading to voltage

// 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 the 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, actual value
int current;  // For current testing, serial input
//float sensVoltage;                   // Store sensed voltage, actual value
int sensVoltage = 13;  // For voltage testing, serial input
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

// PWM
int pwmValues[] = { 24, 41, 58, 77 };  // PWM duty cycle steps (ramp up), 77 = ~30 %, you can add steps, if needed
int currentPwmStep = 0;

// Motor state, starting and shutting down
int motorStatus;            // 0=waiting, for low voltage 1=starting, 2=started, 3=ramping up pwm, 4=running, 5=system or engine malfuntion, stopped
int startTry;               // 0=not tried to start yet, 1=first try done, 2=second, 3=third, 4=fourth, 5=fifth
int startInterval;          // 0=not waiting after start attempt, 1=waiting after start attempt
float startVoltage = 11.9;  // Volts, under what voltage the starting function will execute
float shutCurrent = 5;      // Amperes, below what charging current to execute the shutdown function
float upVoltage = 15;       // Volts, max allowed voltage
float rpmTH = 300;          // Revolutions per minute, rpm threshold greater than this to stop cranking (assume motor is started rpms over the threshold)
float rpmRun = 1800;        // Revolutions per minute, the rpm greater than this is accounted as motor normal running

//RPM Calculation
int rpm = 0;             //unsigned long rpm = 0;   // Variable to store rpm value
unsigned long duration;  // Sensor pulse in duration

// int lcdStep;                      //0=current display, 1=voltage display, not used at the time


void setup() {

  Serial.begin(250000);  // Start the serial communication

#ifdef DEBUG
  Serial.println("Setup...");
#endif

  Wire.begin();
  // Check if the LCD is connected
  Wire.beginTransmission(0x27);
  if (Wire.endTransmission() == 0) {
    // LCD is connected, proceed with initialization
    delay(50);
    lcd.begin(16, 2);
    lcd.backlight();
    lcd.clear();
  } else {
    // LCD is not connected, continue without initializing the LCD

#ifdef DEBUG
    Serial.println("Ei LCD:ta. Ohitus.");
#endif
  }

  // 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
  pinMode(rpmPin, INPUT_PULLUP);    // RPM sensing pin
  pinMode(starterPin, OUTPUT);      // Engine starter relay pin

  // Start Duty Cycle at 100 %, alternator electromagnet off, for starting the engine
  analogWrite(pwmPin, 255);

#ifdef DEBUG
  Serial.println("Setup ok.");
#endif
}


void motorCrankState() {  // Detection of undervoltage to trigger motor cranking function

  if (motorStatus == WAITING && sensVoltage < startVoltage) {  // If motorStatus is WAITING and sensed voltage is less than start voltage, trigger cranking function

#ifdef DEBUG
    Serial.println("Jannitekynnys kaynnistykseen!");
#endif

    if (!voltageWait.started()) {  // Start the voltageWait timer only, if it has not been started yet
      voltageWait.start();         // Start the voltageWait timer if it hasn't started yet
    }

    if (voltageWait.done()) {  // Wait for voltageWait to be done before moving to the cranking of the engine
      motorStatus = STARTING;
      voltageWait.reset();  // Reset timer
    }

  } else if (motorStatus == WAITING) {
    voltageWait.stop();  // Else, stop timer
    voltageWait.reset();
  }
}


void crank() {  // Engine starting function

  if (motorStatus == STARTING && (startTry >= 0 && startTry <= 4) && startInterval == 0 && rpm == 0) {  // If conditions are met, start executing

    if (rpm <= rpmTH) {  // If motor runs slower than the threshold, switch starter relay on
      digitalWrite(starterPin, LOW);

      if (!crankTime.started()) {  // Start the crankTime timer only, if it has not been started yet
        crankTime.start();         // Start the crankTime timer if it hasn't started yet
      }

      if (crankTime.done()) {            // If motor did not start during the crankTime, stop starting
        digitalWrite(starterPin, HIGH);  // Switch starter relay off
        crankTime.reset();               // Reset timer
        startTry += 1;                   // Add one attempt
        startInterval = 1;               // Start waiting time function after starting attempt
      }

    } else if (rpm > rpmTH) {  // If motor runs faster than the threshold, switch starter relay off
      digitalWrite(starterPin, HIGH);
      crankTime.stop();
      startTry = 0;
      motorStatus = STARTED;
      crankTime.reset();  // Reset timer
    }
  }
}


void Waiter() {  // Wait after starting attempt

  if (motorStatus == STARTING && (startTry >= 0 && startTry <= 4) && startInterval == 1 && rpm == 0) {  // If conditions are met, start executing

    if (!crankWait.started()) {  // Start the crankWait timer only, if it has not been started yet
      crankWait.start();         // Start the crankWait timer if it hasn't started yet
    }

    if (crankWait.done()) {  // If timer is done
      crankWait.reset();     // reset timer
      startInterval = 0;     // revert to state 0 (waiting time after start attempt ready)
    }

  } else if (startInterval == 0) {  // Else
    crankWait.stop();               // stop timer
    crankWait.reset();              // Reset timer
  }
}


void startFail() {  // If engine did not start put system status to state 5 (malfunction)

  if (startTry == 5) {
    motorStatus = FAIL;

#ifdef DEBUG
    Serial.println("Kaynnistysvirhe!");
#endif

    lcd.setCursor(0, 0);  // On lcd print "Engine start failed"
    lcd.print("K");
    lcd.print((char)0xe1);
    lcd.print("ynnistys      ");
    lcd.setCursor(0, 1);
    lcd.print("ep");
    lcd.print((char)0xe1);
    lcd.print("onnistui     ");
  }
}

void overvoltage() {  // If voltage is over max voltage put motor status to FAIL (malfuntion) and shut down the ignition relay

  if (sensVoltage >= upVoltage) {
    motorStatus = FAIL;
    digitalWrite(relayPin, LOW);

#ifdef DEBUG
    Serial.println("Ylijannite!");
#endif

    lcd.setCursor(0, 0);  // On lcd print "Overvoltage"
    lcd.print("Ylij");
    lcd.print((char)0xe1);
    lcd.print("nnite      ");
    lcd.setCursor(0, 1);
    lcd.print("                ");
  }
}


void motorRunning() {  // Engine running detection

  if ((motorStatus == STARTED) && digitalRead(motorPin) == HIGH || rpm > rpmRun) {  // If engine runs faster than rpmRun value (revolution per minute) assume motor is running normally

#ifdef DEBUG
    Serial.println("Kayntitieto!");
#endif

    if (!motorTime.started()) {  // Start the motorTime timer only, if it has not been started yet
      motorTime.start();         // Start the motorTime timer if it hasn't started yet
    }

    if (motorTime.done()) {  // Wait for motorTime to be done before moving to ramping up PWM

      motorStatus = RAMP_UP;

      motorTime.stop();   // Stop the timer
      motorTime.reset();  // Reset the timer

#ifdef DEBUG
      Serial.println("Kay.");
#endif
    }

  } else if (motorStatus == WAITING || motorStatus == STARTING) {
    motorTime.stop();   // Stop the timer if motor is not running before ramping up state
    motorTime.reset();  // Reset the timer

#ifdef DEBUG
    Serial.println();
    Serial.println("Kaynnistys...");
#endif

    lcd.setCursor(0, 0);  // On lcd print "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() {  // Ramping up PWM

  //Ramp pwm up
  if (motorStatus == RAMP_UP) {
    if (stepTime.repeat()) {
      analogWrite(pwmPin, pwmValues[currentPwmStep]);
      currentPwmStep++;

#ifdef DEBUG
      Serial.println("Ramp up...");
#endif

      if (currentPwmStep >= sizeof(pwmValues) / sizeof(pwmValues[0])) {  //Checking the pwm step count

        motorStatus = RUNNING;  // Motor running on normal charging state
        stepTime.stop();
        stepTime.reset();  // Reset the timer
      }
    }
  }
}


void shutDown() {  // Engine shutdown, execute relay

  // If the charging current drops to 0 to shutCurrent and charging voltage is under upVoltage and motor is running
  // start the shutdown function and turn off the relay
  if (current >= 0 && current < shutCurrent && sensVoltage < upVoltage && motorStatus == RUNNING) {
    // if (digitalRead(motorPin) == HIGH) { // Vibration sensor

    digitalWrite(relayPin, LOW);  // Switch relay on
    analogWrite(pwmPin, 15);      // Duty Cycle to 5 % before running down engine

    if (!shutTime.started()) {  // Wait for shutDelay time to engine have time to stall down
      shutTime.start();
    }

    if (shutTime.done()) {
      analogWrite(pwmPin, 255);  // Stopped Duty Cycle at 100 %, alternator electromagnet off

      lcd.setCursor(0, 0);
      lcd.print("Sammutus        ");  // Print on lcd "Shutdown"
      lcd.setCursor(0, 1);
      lcd.print("                ");

      motorStatus = WAITING;  // Motor has run, battery is full, go back to waiting voltage

      shutTime.reset();  // Reset the timer

#ifdef DEBUG
      Serial.println("Sammutettu.");
#endif
    }
  } else if (motorStatus == RUNNING) {
    digitalWrite(relayPin, HIGH);  // Else, keep relay off
    shutTime.stop();               // Stop the timer if motor is in state 4 (normal running)
    shutTime.reset();              // Reset the timer

#ifdef DEBUG
    Serial.println("Kaynnissa.");
#endif
  }
}
//}


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

  if (motorStatus == RUNNING) {

    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");

#ifdef DEBUG
    Serial.println("Virta LCD.");
#endif
  }
}


void loop() {
  // Calculate current from sensor 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(1);  //Wait for a millisecond 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


  //  current = (m * voltage + b) * currentCal;  // Convert voltage to current using the linear equation, correct with current calibration value if needed


  // 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(1);  // Wait for a millisecond 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


// RPM Calculation from Hall Sensor input
// {
//   duration = pulseIn(rpmPin, FALLING, 500000);  // Times the amount of microseconds the motor is not timing IR, Times out after 100000 uS. Raise the timeout for slower RPM readings. .5 second
//    rpm = 60000.0 / duration * 1000;              // See above
//  }

//Serial key input test code, write to various variables
#ifdef DEBUG
  if (Serial.available() > 0) {
    char input = Serial.read();

    switch (input) {
      case '1':
        rpm = 0;
        break;
      case '2':
        rpm = 500;
        break;
      case '3':
        rpm = 2000;
        break;
      case 'a':
        current = 2;
        break;
      case 'b':
        current = 20;
        break;
      case 'c':
        current = 80;
        break;
      case 'z':
        sensVoltage = 11.5;
        break;
      case 'x':
        sensVoltage = 14.5;
        break;
      case 'y':
        sensVoltage = 15.5;
        break;
      default:
        Serial.println("Invalid input.");
        return;
    }
  }
#endif

  motorCrankState();
  crank();
  Waiter();
  startFail();
  overvoltage();
  motorRunning();
  rampUp();
  shutDown();
  showCurrent();

  //Debug
#ifdef DEBUG
  if (serDelay.repeat()) {
    Serial.print("Jannite: ");
    Serial.print((float)sensVoltage);
    Serial.println();
    Serial.print("Virta: ");
    Serial.print((float)current);
    Serial.println();
    Serial.print("Tila: ");
    Serial.print(motorStatus);
    Serial.println();
    Serial.print("Start tila: ");
    Serial.print(startTry);
    Serial.println();
    Serial.print("Odotus: ");
    Serial.print(startInterval);
    Serial.println();
    Serial.print("RPM: ");
    Serial.print(rpm);
    Serial.println();
#endif
  }
}

 

[ississ]

Päätin laittaa nyt tämän koko koodin taas tähän, kun siinä on nyt jonkin verran muutoksia. Laitoin nuo @ississ :n ja kumppaneiden suosittelemat selkokieliset tilat ja lisäksi olisi tarkoitus hidastaa tuota sarjaportin tulostusta, ei siitä kerkeä nyt näkemään mitään.

Lisäksi löytyihän sieltä ainakin yksi toimimaton funktio, sammutus ei mene päälle. Luulen, että tuossa on joku kämmi tuon timerin kanssa. Voi olla, että se nollaa timeria nyt koko ajan, jolloin ajastus ei pääse alkamaan.

Sama homma täytyy olla myös tuolla koodin loppupään DEBUG tulostuksen kanssa. Kokeilin varuiksi myös ilman #ifdef... makroja, niin ei sillä ollut vaikutusta. Jotain en nyt vain saa toimimaan tuossa Neotimer kirjaston käytössä. Tosi helppokäyttöinen sen pitäisi ohjeidensakin mukaan olla. Vastaava kohta kuitenkin tuolla rampup -funktiossa (repeat ()) toimii oikein hienosti. Eli nyt, kun laittaa esim. tuon repeatin tuhon tulostukseen, ei tulostu mitään. Samoin kävi kokeillessa start()-stop() -käytöntöä.

Saa tutkia taas koodia, jos kiinnostelee...

Lisäksi olisi koodin ulkopuolinen kysymys. Sopisikohan tuohon hall-sensoriksi TLE4905L? Ainakin tämänkin pitäisi olla samantyyppinen, pulsseista triggeröityvä digitaalinen (on-off) anturi. Tuossa koodissa on käytetty anturi tyypiltään 3144.

Loopissa ei kannata jatkuvasti tulostaa, tarvitset sillekin yhden ajastuksen, esim max sekunnin tai muutaman välein jos jatkuvasti pitää tulostaa jotain (esim jännite/virta/jne voi olla kätevä).
Ja kaikki muut tulostukset vain tilan vaihdossa kuten tuossa jo aiemmin mainitsin.
Else- haaran tulostukset on pahimpia jos tulee joka kierroksella, silloin ne vaan haittaa koska tärkeät viestit hukkuu massaan.

Lisäksi kannattaa ehkä käyttää sellaista sarjaterminaalia joka osaa lokittaa kaiken tiedostoon niin voi sitten massastakin seuloa mitä tapahtui vaikka ei ehtinyt nähdä. Esimerkiksi putty tai jokin vastaava on yleensä kätevämpi kuin arduino-iden sarjamonitori.
Tähän liittyy myös debug/release käännös. Debug tarjoilee aika paljon kaikenlaista sarjaporttiin joten se on yleisesti huono juttu jos asioita on tehty siten että tulostukset vaikuttavat ajastuksiin yms.
Olen alkanut käyttää suoraan release käännöstä ja niissä kohdissa joissa aika kiinnostaa niin tulostaa itse millis() + tarvittava teksti niin jää aikaleimat lokiin.

#ifdef ... on koodin käännösaikainen juttu. Jos siis on määritetty DEBUG (= debug- käännös valittuna) niin silloin "#ifdef DEBUG" ja ilman sitä on sama asia lopputuloksen kannalta.
Jos valitaan release- käännös niin silloin "#ifdef DEBUG" kanssa tulosteet eivät enää päädy mukaan koodiin.


Tuohon "joku kämmi timerin kanssa" ongelmaan suosittelen ensimmäiseksi muuttamaan koodin niin että asiat tapahtuvat vain tilanvaihdossa.
Siis tällaiset kannattaisi purkaa pois:

  if (motorStatus == WAITING && sensVoltage < startVoltage) {  // If motorStatus is WAITING and sensed voltage is less than start voltage, trigger cranking function

#ifdef DEBUG
    Serial.println("Jannitekynnys kaynnistykseen!");
#endif

    if (!voltageWait.started()) {  // Start the voltageWait timer only, if it has not been started yet
      voltageWait.start();         // Start the voltageWait timer if it hasn't started yet
    }

    if (voltageWait.done()) {  // Wait for voltageWait to be done before moving to the cranking of the engine
      motorStatus = STARTING;
      voltageWait.reset();  // Reset timer
    }

  } else if (motorStatus == WAITING) {
    voltageWait.stop();  // Else, stop timer
    voltageWait.reset();
  }

Jos tila on WAITING ja jännite tarpeeksi korkea niin jokaisella kutsulla timer sammutetaan ja resetoidaan. Pitäisi riittää tehdä vain kerran silloin kun on tarve eikä jokaisella kutsulla.
Kun on useita asioita joita tehdään tällä tavalla niin nuo "tämä tehdään joka kierroksella" tuottavat herkästi virheitä jos ei ole todella tarkkana mitä joka kierroksella tehdään.
Tässä siis kierros on loop()- funktion kutsu.

Eli sellainen malli jossa on jokainen eri tila if-then-else avulla ensin ja jokaisen tilan "sisällä" tutkitaan siinä tilassa tarpeelliset ehdot tekemisille on huomattavasti helpompi. Samoin itse tekemiset (ajastinten sammutus/käynnistys/pinnien heiluttelu) pitäisi tehdä vain silloin kun ollaan jossakin tietyssä tilassa ja ehto seuraavaan tilaan siirtymiselle täyttyy, silloin se tekeminen suoritetaan vain kerran ja saadaan myös järkevä tulostus sarjaporttiin koska tulostetaan vain silloin kun jotain tapahtuu eikä jatkuvasti.

 

[Tupsa]

@ississ , taas annos asiaa. Pitää ajatuksella lukea tuota läpi.

Tein testiksi pelkästään tuo ajastimen sisältävän testikoodin. Siinä ajastus toimi täysi oikein, 1 sekunnin välein tulosti sarjaporttiin kaikki rivit. Eli joku ihme homma tuossa nyt on, alan jo miettiä, onko tuossa kirjastossa jokin raja ajastimien määrälle...

 

[ississ]

@ississ , taas annos asiaa. Pitää ajatuksella lukea tuota läpi.

Tein testiksi pelkästään tuo ajastimen sisältävän testikoodin. Siinä ajastus toimi täysi oikein, 1 sekunnin välein tulosti sarjaporttiin kaikki rivit. Eli joku ihme homma tuossa nyt on, alan jo miettiä, onko tuossa kirjastossa jokin raja ajastimien määrälle...

Koska sitä käytetään noin kuten käytetään eli "Neotimer motorTime = Neotimer(10000);" niin jokaisesta tulee uusi objekti jolla ei ole yhteyttä toisiin.
Ennemmin veikkaisin että jossain menee muuttujat sekaisin tai logiikka on väärin (ehkä joku else- haara/vastaava).
Voi myös olla että nuo reset() jne menee sopivasti ristiin logaakan kannalta.


Jos kirjasto epäilyttää niin aina tuon saman voi tehdä yhdellä muuttujalla/ajastus ja millis()- funktiolla.
Lisää iltalukemista.

Esimerkkinä tulostus sekunnin välein:

#define PRINT_INTERVAL 1000  // 1 sek

unsigned long lastPrintTime = 0;

void setup() {
    Serial.begin(115200);
    Serial.print("ajastusdemo");
    lastPrintTime = millis();
}


void loop() {

    // (millis() - lastPrintTime) vastaa kysymykseen "kuinka paljon aikaa on kulunut aloituksesta millisekunteina"
    if ( (millis() - lastPrintTime) > PRINT_INTERVAL ) {
        // Sekunti kulunut, tulostetaan
        Serial.print(millis());
        Serial.println(" ms");
        // Asetetaan aloitusaika
        lastPrintTime = millis();
    }
    
}

Jos taas tarvitaan "ajastimen käynnistys" ja "onko ajastin käynnissä" tiedot niin sekin onnistuu helposti, vaikka näin:

#define TIMER_INVERTVAL 1000  // 1 sek

unsigned long lastTime = 0;

void setup() {
    // ....
}


void loop() {

    if ( [joku tarvittava ehto täyttyy] ) {
        // Jossain kohtaa koodissa ajastin käynnistetään asettamalla lastTime joksikin muuksi kuin nollaksi, käytännössä millis()
        lastTime = millis();
        // nyt lastTime > 0 ja vasta silloin alla (tai yllä, ei väliä)
        // voidaan tutkia onko aika kulunut ja sen perusteella tehdään asioita.
    }
    
    // "> 0"- testi vastaa loogisesti samaa kuin "onko ajastin käynnissä ?"
    if (lastTime > 0) {
        // Sama "aika kulunut" ehto kuin ylemmässä esimerkissä
        if ( (millis() - lastTime) > TIMER_INTERVAL ) {
            Serial.println("Aika täynnä, odotellaan seuraavaa käynnistysehdon täyttymistä");
            // Tässä tapauksessa ajan kuluttua asetetaankin lastTime = 0 eli "sammutetaan" ajastin.
            lastTime = 0;
            // Koska lastTime = 0 niin koko tänne haaraan ei tulla ellei ensin käynnistysehto ole täyttynyt
        }
    }
    
}

Ja niin kauan kuin nuo lastXxxTime- muuttujat ovat globaaleja, siis määritetty funktioiden ulkopuolella niitä voidaan käyttää missä tahansa funktiossa.

 

[Tupsa]

Okei, eli nyt selvisi logeja tutkimalla sen verran, että tila menee WAITING, jos rpm laskee nollaan. Hmm, kyllä tuossa jotain logiikkaongelmaa varmaan on. Nyt muuten sekunnin välein tapahtuva tulostuskin alkoi onnistumaan, kun poistin noista else -ehdoista tulostuksia kokonaan.

Tarkempaa tietoa tulee. Eli tila WAITING palautuu vain, jos myös virta menee alle kynnyksen. Eli jostain syystä nyt vaaditaan myös kierrosten laskeminen nollaan (väärin), jotta sammutusfunktio käynnistyy.

EDIT: Löytyi myös uusi ongelma. Onko edes mahdollista käyttää useampaa kuin yhtä #define-ifdef makroa? Olisin laittanut toisen, DEBUG_2 -määritteen, jotta olisin voinut testimielessä disabloida kaikki tulostukset sarjaporttiin pääfunktioista, mutta kun lisäsin tuon, tulee seuraava herja:

fatal error: Wire.h: No such file or directory
#include <LiquidCrystal_I2C.h>
^~~~~~~~
compilation terminated.
exit status 1

Compilation error: Wire.h: No such file or directory

 

[KanOl]

EDIT: Löytyi myös uusi ongelma. Onko edes mahdollista käyttää useampaa kuin yhtä #define-ifdef makroa? Olisin laittanut toisen, DEBUG_2 -määritteen, jotta olisin voinut testimielessä disabloida kaikki tulostukset sarjaporttiin pääfunktioista, mutta kun lisäsin tuon, tulee seuraava herja:

Mitähän tarkalleen ottaen tarkoitat? Esim. näin voi tehdä, auttaako pohdintaasi?

#include <stdio.h>
#include <stdint.h>

#define DEBUG
#define TOINENDEBUG
//#define KOLMASDEBUG

int main(void){
        printf("Hello world\n");
        #ifdef DEBUG
        printf("Tama on debug\n");
        #endif

        #ifdef TOINENDEBUG
        printf("tama on toinen debug\n");
        #ifdef KOLMASDEBUG
        printf("tama on kolmas debug\n");
        #endif
        #endif
        return 0;
}

Koodailua voi testata helposti ilman arduinoakin. Esim. tuon koodin voi kääntää gcc:llä (tai jollain muulla c-compilerilla) ja sit ajaa ohjelman terminaalissa. Jos linux käytössä niin gcc löytyy usein valmiiksi, jolloin terminaaliin voi yksinkertaisimmillaan kirjoittaa gcc ./minun-c-tiedosto.c, joka kääntää koodin ohjelmaksi, jonka voi sit käynnistää yksinkertaisimmillaan komennolla ./a.out . Windowsissa oli jotain omia jippoja, googlesta löytynee valmiit ohjeet.

 

[Hyrava]

Mitähän tarkalleen ottaen tarkoitat? Esim. näin voi tehdä, auttaako pohdintaasi?

#include <stdio.h>
#include <stdint.h>

#define DEBUG
#define TOINENDEBUG
//#define KOLMASDEBUG

int main(void){
        printf("Hello world\n");
        #ifdef DEBUG
        printf("Tama on debug\n");
        #endif

        #ifdef TOINENDEBUG
        printf("tama on toinen debug\n");
        #ifdef KOLMASDEBUG
        printf("tama on kolmas debug\n");
        #endif
        #endif
        return 0;
}

Koodailua voi testata helposti ilman arduinoakin. Esim. tuon koodin voi kääntää gcc:llä (tai jollain muulla c-compilerilla) ja sit ajaa ohjelman terminaalissa. Jos linux käytössä niin gcc löytyy usein valmiiksi, jolloin terminaaliin voi yksinkertaisimmillaan kirjoittaa gcc ./minun-c-tiedosto.c, joka kääntää koodin ohjelmaksi, jonka voi sit käynnistää yksinkertaisimmillaan komennolla ./a.out . Windowsissa oli jotain omia jippoja, googlesta löytynee valmiit ohjeet.

Ja sittenhän on ihan online-simulaattoreitakin joissa voi nappeja, potikoita sun muita simuloida Arduinon (tai muun kontrollerin ohessa). Itse en ole vielä kokeillut mutta yksi tuttu heitti joku aika sitten linkin:

Wokwi - World's most advanced ESP32 Simulator

IoT and Embedded System Simulator: ESP32, STM32, Arduino, Raspberry Pi Pico, displays, sensors, motors and WiFi simulation.

wokwi.com

Ja joista #defineistä sun muista, niiden nimeäminen kannattaa miettiä ettei tee mitään DEBUG, DEBUG2, DEBUG3 jne vaan mieluummin DEBUG_MAIN, DEBUG_MOTOR, DEBUG_TIMING, DEBUG_ENABLESERIALPRINT tms että ei tarvitse selailla koodia kun ihmettelee mitä nuo eri debugit taas tekikään. Nuo nimet kun eivät vaikuta lopullisen koodin kokoon niin niihin kannattaa kirjoitella vähän jotain viittausta mihin nuo liittyvät niin on helpompi pysyä kärryillä.

 

[Tupsa]

Joo, nyt toimi. #define :ssä ei saanut näköjään olla numeroa tyyliin DEBUG_2. Kun laitoin DEBUG_STATUS ja DEBUG_MAIN, niin koodi meni kääntäjästä läpi.

Ilouutinen on, että koodi toimii ainakin tilanvaihtojen suhteen lähes täysin oikein, kun sain tuon hirmuisen tulostuksen yo. mukaan kuriin! Ainoa on, että jos kierrosluku jää ylhäälle sammutuksen jälkeen (käytännön toiminnassa mahdoton tilanne), niin ajastimen jälkeen hommaa aletaan taas ajaa ylös palautuen taas tila tilan jälkeen WAITING tilaan. Jos taas kierroslukukin palautuu, niin ohjelma jää odottamaan WAITING tilaan, kuten kuuluu.

Mutta nyt näyttää ainakin siltä, että seuraavaksi voisi testata jopa moottorin kanssa. Se ei ihan heti tule tapahtumaan. Moottori on tullut tupaan ja runkoa suunnitellaan. Hihnapyöriä pitää käyttää työstettävänä, jotta saadaan Voortin laturi naitettua näppärästi kiinanpojan moottorin kanssa.

Tulen kaikesta huolimatta vielä tutkimaan mahdollisuutta hyödyntää Arduino simulaattoria, mikäli sen ylössaaminen ei ole aivan hirmuisen työn takana.

EDIT: Noo niin, otetaas vähän takaisin. Tuo Arduino simulaattori olikin aika helppo pistää pystyyn, ja siinä sai näyttöäkin jo viriteltyä sopivasti näyttämään nuita asioita. Mutta selvisihän siinä, että myös koodissa on vielä tekemistä. Eli tila vaihtelee nyt 3 ja 4 välillä, eli rampupin ja runningin välillä. Pitäisiköhän siis yrittää noita else if -ehtoja poistaa? Laittaa peräkkäin if-ehtoja?

EDIT2: Aika monta else if -ehtoa poistin tuosta, koodi näyttäisi edelleen toimivan paitsi tuo 3 ja 4 vaihtelu ei muuttunut. Muilta osin koodi toiminee, en toki ihan varma ole. Täytyy tsekata vielä PWM skoopilla ja releet.

EDIT3: No joo, testailin skoopilla, niin ei tuo koodi toimi juuri lainkaan. PWM pysyy jonkin aikaa esim. 30 prosentissa, mutta sitten menee nolliin ja onkin seuraavaksi yli 80 %. Eli täysin hasardi koodi on. Täytynee kirjoittaa tuo koko looppi uusiksi alusta alkaen, pl. jotkut pätkät, esim. virran ja jännitteen laskenta. Siinähän sitä harjoitusta tulee.

 

[Tupsa]

No joo, testailin skoopilla, niin aika kehvelisti tuo koodi pelittää. PWM pysyy jonkin aikaa esim. 30 prosentissa, mutta sitten menee nolliin ja onkin seuraavaksi yli 80 %. Eli hieman hasardi koodi on!

No ehkei sentään koko koodia kannata kirjoittaa uusiksi, vika täytyy löytyä jostain, joka laittaa tilan 3 ja 4 välillä. Alkutila näyttää toimivan oikein, PWM pysyy nollissa, eikä lähde tilasta pois.

Starttaus näyttää toimivan ihan ok. PWM pysyi myös maksimissa tilaan 5 saakka, eli virhetilaan, kun moottori ei käynnisty.
Kun moottori ei pyöri ja PWM on maksimissa, laturi pysyy magnetoimattomana. Simulaattorilla testailtuani, myös tila 2 toimii oikein. Mitään ei tapahdu, jos mootttorin kierrosluku ei nouse yli normaalin raja-arvon (tällä hetkellä koodissa 1800 rpm).

Sammutusfunktio näyttää myös toimivan, mutta se vaatii että kierrokset laskevat nollaan. Ja tämä myös tapahtuu, koska sytytysvirta rele pysyy pois päältä. Voidaan siis vetää johtopäätös, että ongelma on tiloissa 3 ja 4. Keskittyen PWM:ään ja näiden tilojen hallitsemattomaan vaihteluun. Enpä tiedä voisiko ongelmana olla tuo ajastimen repeat() funktio. Sen voisi poistaa ja laittaa tilalle sen aikaisemman koodiversion tyylinen toteutus, eli että PWM-askeleet ovat tuon "hienon" koodin sijaan vain siinä viiveiden välillä. Joskin viive tietenkin tällä ajastinkirjastolla, eikä estävällä Delay()-funktiolla.

Alhaalla myös tämän hetkinen koodi tutkittavaksi, jos kiinnostaa.

Tilat:

0	Odotus (WAITING) Ei tule sekoittaa kuvan Odotus: 1, kohtaan, joka on käynnistysintervallin päällä olon ilmaiseva muuttuja	1	Käynnistys (STARTING)
2	Käy (STARTED)	3	Rampup (RAMP_UP)
4	Käy (lataa) [RUNNING]	5	Virhe (FAIL)

// Generator control system for car alternator (Ford with PWM controlled charging voltage) and small engine

#define DEBUG_STATUS  // Serial debug, comment to disable, downmost values
//#define DEBUG_MAIN //Serial debug, comment to disable, uppermost main function values

// System status variables (motorStatus)
#define WAITING 0
#define STARTING 1
#define STARTED 2
#define RAMP_UP 3
#define RUNNING 4
#define FAIL 5

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <neotimer.h>  // Non-blocking timer from Neotimer library

Neotimer motorTime = Neotimer(10000);   // 10 second timer for startup detection
Neotimer stepTime = Neotimer(1000);     // 1 second timer for PWM step interval
Neotimer shutTime = Neotimer(15000);    // 15 second timer for engine shutdown (wait before switching PWM back to 100 %, electromagnet off)
Neotimer crankTime = Neotimer(4000);    // 4 second timer, if problems to start, try at most 4 seconds continuous cranking
Neotimer crankWait = Neotimer(5000);    // 5 second timer, if crank failed, wait 5 seconds before a new try
Neotimer voltageWait = Neotimer(2000);  // 60 seconds timer, how long to wait with undervoltage & other assigned conditions, before the starting function executes
Neotimer serDelay = Neotimer(1000);     // For serial print interval

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 (vibration sensor), HIGH = motor running, TEST purpose LOW
const int pwmPin = 9;       // PWM output pin
const int relayPin = 4;     // Shutdown relay control pin
const int rpmPin = 11;      // RPM Hall Sensor input pin, sensor type: 3144
const int starterPin = 3;   // Starter relay control pinn

// Current and voltage calculation
float voltageFactor = 5.00 / 1023.00;  // Factor to convert ADC reading to voltage

// 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 the 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, actual value
int current;  // For current testing, serial input
//float sensVoltage;                   // Store sensed voltage, actual value
int sensVoltage = 13;  // For voltage testing, serial input
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

// PWM
int pwmValues[] = { 24, 41, 58, 77 };  // PWM duty cycle steps (ramp up), 77 = ~30 %, you can add steps, if needed
int currentPwmStep = 0;

// Motor state, starting and shutting down
int motorStatus;            // 0=waiting, for low voltage 1=starting, 2=started, 3=ramping up pwm, 4=running, 5=system or engine malfuntion, stopped
int startTry;               // 0=not tried to start yet, 1=first try done, 2=second, 3=third, 4=fourth, 5=fifth
int startInterval;          // 0=not waiting after start attempt, 1=waiting after start attempt
float startVoltage = 11.9;  // Volts, under what voltage the starting function will execute
float shutCurrent = 5;      // Amperes, below what charging current to execute the shutdown function
float upVoltage = 15;       // Volts, max allowed voltage
float rpmTH = 300;          // Revolutions per minute, rpm threshold greater than this to stop cranking (assume motor is started rpms over the threshold)
float rpmRun = 1800;        // Revolutions per minute, the rpm greater than this is accounted as motor normal running

//RPM Calculation
int rpm = 0;             //unsigned long rpm = 0;   // Variable to store rpm value
unsigned long duration;  // Sensor pulse in duration

// int lcdStep;                      //0=current display, 1=voltage display, not used at the time


void setup() {

  Serial.begin(250000);  // Start the serial communication

#ifdef DEBUG_MAIN
  Serial.println("Setup...");
#endif

  Wire.begin();
  // Check if the LCD is connected
  Wire.beginTransmission(0x27);
  if (Wire.endTransmission() == 0) {
    // LCD is connected, proceed with initialization
    delay(50);
    lcd.begin(16, 2);
    lcd.backlight();
    lcd.clear();
  } else {
    // LCD is not connected, continue without initializing the LCD

#ifdef DEBUG_MAIN
    Serial.println("Ei LCD:ta. Ohitus.");
#endif
  }

  // 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
  pinMode(rpmPin, INPUT_PULLUP);    // RPM sensing pin
  pinMode(starterPin, OUTPUT);      // Engine starter relay pin

  // Start Duty Cycle at 100 %, alternator electromagnet off, for starting the engine
  analogWrite(pwmPin, 255);

#ifdef DEBUG_MAIN
  Serial.println("Setup ok.");
#endif
}


void motorCrankState() {  // Detection of undervoltage to trigger motor cranking function

  if (motorStatus == WAITING && sensVoltage < startVoltage) {  // If motorStatus is WAITING and sensed voltage is less than start voltage, trigger cranking function

#ifdef DEBUG_MAIN
    Serial.println("Jannitekynnys kaynnistykseen!");
#endif

    if (!voltageWait.started()) {  // Start the voltageWait timer only, if it has not been started yet
      voltageWait.start();         // Start the voltageWait timer if it hasn't started yet
    }

    if (voltageWait.done()) {  // Wait for voltageWait to be done before moving to the cranking of the engine
      motorStatus = STARTING;
      digitalWrite(relayPin, HIGH);  // Switch ignition relay on
      voltageWait.reset();           // Reset timer
    }
  }
}


void crank() {  // Engine starting function

  if (motorStatus == STARTING && (startTry >= 0 && startTry <= 4) && startInterval == 0 && rpm == 0) {  // If conditions are met, start executing

    if (rpm <= rpmTH) {  // If motor runs slower than the threshold, switch starter relay on
      digitalWrite(starterPin, HIGH);

      if (!crankTime.started()) {  // Start the crankTime timer only, if it has not been started yet
        crankTime.start();         // Start the crankTime timer if it hasn't started yet
      }

      if (crankTime.done()) {           // If motor did not start during the crankTime, stop starting
        digitalWrite(starterPin, LOW);  // Switch starter relay off
        crankTime.stop();
        crankTime.reset();  // Reset timer
        startTry += 1;      // Add one attempt
        startInterval = 1;  // Start waiting time function after starting attempt
      }
    }


  } else if (rpm > rpmTH) {         // If motor runs faster than the threshold, switch starter relay off
    digitalWrite(starterPin, LOW);  // Switch starter pin off
    startTry = 0;
    motorStatus = STARTED;
    crankTime.stop();
    crankTime.reset();  // Reset timer
  }
}



void Waiter() {  // Wait after starting attempt

  if (motorStatus == STARTING && (startTry >= 0 && startTry <= 4) && startInterval == 1 && rpm == 0) {  // If conditions are met, start executing

    if (!crankWait.started()) {  // Start the crankWait timer only, if it has not been started yet
      crankWait.start();         // Start the crankWait timer if it hasn't started yet
    }

    if (crankWait.done()) {  // If timer is done
      crankWait.reset();     // reset timer
      startInterval = 0;     // revert to state 0 (waiting time after start attempt ready)
    }
  }
}


void startFail() {  // If engine did not start put system status to state 5 (malfunction)

  if (startTry == 5) {
    motorStatus = FAIL;
    digitalWrite(starterPin, LOW);  // Starter relay off
    digitalWrite(relayPin, LOW);    // Ignition switch relay off

#ifdef DEBUG_MAIN
    Serial.println("Kaynnistysvirhe!");
#endif

    lcd.setCursor(0, 0);  // On lcd print "Engine start failed"
    lcd.print("K");
    lcd.print((char)0xe1);
    lcd.print("ynnistys      ");
    lcd.setCursor(0, 1);
    lcd.print("ep");
    lcd.print((char)0xe1);
    lcd.print("onnistui     ");
  }
}

void overvoltage() {  // If voltage is over max voltage put motor status to FAIL (malfuntion) and shut down the ignition relay

  if (sensVoltage >= upVoltage) {
    motorStatus = FAIL;
    digitalWrite(relayPin, LOW);

#ifdef DEBUG_MAIN
    Serial.println("Ylijannite!");
#endif

    lcd.setCursor(0, 0);  // On lcd print "Overvoltage"
    lcd.print("Ylij");
    lcd.print((char)0xe1);
    lcd.print("nnite      ");
    lcd.setCursor(0, 1);
    lcd.print("                ");
  }
}


void motorRunning() {  // Engine running detection

  if ((motorStatus == STARTED) && digitalRead(motorPin) == HIGH || rpm > rpmRun) {  // If engine runs faster than rpmRun value (revolution per minute) assume motor is running normally

#ifdef DEBUG_MAIN
    Serial.println("Kayntitieto!");
#endif

    if (!motorTime.started()) {  // Start the motorTime timer only, if it has not been started yet
      motorTime.start();         // Start the motorTime timer if it hasn't started yet
    }

    if (motorTime.done()) {  // Wait for motorTime to be done before moving to ramping up PWM

      motorStatus = RAMP_UP;

      motorTime.stop();   // Stop the timer
      motorTime.reset();  // Reset the timer

#ifdef DEBUG_MAIN
      Serial.println("Kay.");
#endif
    }
  }

  if (motorStatus == WAITING || motorStatus == STARTING) {
    lcd.setCursor(0, 0);  // On lcd print "Waiting"
    lcd.print("Odotetaan...    ");
    lcd.setCursor(0, 1);
    lcd.print("J");
    lcd.print((char)0xe1);
    lcd.print("nnite: ");
    lcd.print((float)sensVoltage);
    lcd.print(" V");
  }
}


void rampUp() {  // Ramping up PWM

  //Ramp pwm up
  if (motorStatus == RAMP_UP) {
    if (stepTime.repeat()) {
      analogWrite(pwmPin, pwmValues[currentPwmStep]);
      currentPwmStep++;

#ifdef DEBUG_MAIN
      Serial.println("Ramp up...");
#endif

      if (currentPwmStep >= sizeof(pwmValues) / sizeof(pwmValues[0])) {  //Checking the pwm step count

        motorStatus = RUNNING;  // Motor running on normal charging state
        stepTime.stop();
        stepTime.reset();  // Reset the timer
      }
    }
  }
}


void shutDown() {  // Engine shutdown, execute relay

  // If the charging current drops to 0 to shutCurrent and charging voltage is under upVoltage and motor is running
  // start the shutdown function and turn off the relay
  if (current >= 0 && current < shutCurrent && sensVoltage < upVoltage && motorStatus == RUNNING) {
    // if (digitalRead(motorPin) == HIGH) { // Vibration sensor

    digitalWrite(relayPin, LOW);  // Switch relay off
    analogWrite(pwmPin, 15);      // Duty Cycle to 5 % before running down engine

    if (!shutTime.started()) {  // Wait for shutDelay time to engine have time to stall down
      shutTime.start();
    }

    if (shutTime.done()) {
      analogWrite(pwmPin, 255);  // Stopped Duty Cycle at 100 %, alternator electromagnet off

      lcd.setCursor(0, 0);
      lcd.print("Sammutus        ");  // Print on lcd "Shutdown"
      lcd.setCursor(0, 1);
      lcd.print("                ");

      motorStatus = WAITING;  // Motor has run, battery is full, go back to waiting voltage

      shutTime.stop();   // Reset the timer
      shutTime.reset();  // Reset the timer

#ifdef DEBUG_MAIN
      Serial.println("Sammutettu.");
#endif
    }
  }
}
//}


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

  if (motorStatus == RUNNING) {

    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 ");

#ifdef DEBUG_MAIN
    Serial.println("Virta LCD.");
#endif
  }
}


void loop() {
  // Calculate current from sensor 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(1);  //Wait for a millisecond 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


  //  current = (m * voltage + b) * currentCal;  // Convert voltage to current using the linear equation, correct with current calibration value if needed


  // 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(1);  // Wait for a millisecond 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


// RPM Calculation from Hall Sensor input
// {
//   duration = pulseIn(rpmPin, FALLING, 500000);  // Times the amount of microseconds the motor is not timing IR, Times out after 100000 uS. Raise the timeout for slower RPM readings. .5 second
//    rpm = 60000.0 / duration * 1000;              // See above
//  }

//Serial key input test code, write to various variables
#ifdef DEBUG_STATUS
  if (Serial.available() > 0) {
    char input = Serial.read();

    switch (input) {
      case '1':
        rpm = 0;
        break;
      case '2':
        rpm = 500;
        break;
      case '3':
        rpm = 2000;
        break;
      case 'a':
        current = 2;
        break;
      case 'b':
        current = 20;
        break;
      case 'c':
        current = 80;
        break;
      case 'z':
        sensVoltage = 11.5;
        break;
      case 'x':
        sensVoltage = 14.5;
        break;
      case 'y':
        sensVoltage = 15.5;
        break;
      default:
        Serial.println("Invalid input.");
        return;
    }
  }
#endif

  motorCrankState();
  crank();
  Waiter();
  startFail();
  overvoltage();
  motorRunning();
  rampUp();
  shutDown();
  showCurrent();

  //Debug
#ifdef DEBUG_STATUS
  if (!serDelay.started()) {  // Wait for shutDelay time to engine have time to stall down
    serDelay.start();
  }
  if (serDelay.done()) {
    Serial.print("Jannite: ");
    Serial.print((float)sensVoltage);
    Serial.println();
    Serial.print("Virta: ");
    Serial.print((float)current);
    Serial.println();
    Serial.print("Tila: ");
    Serial.print(motorStatus);
    Serial.println();
    Serial.print("Start tila: ");
    Serial.print(startTry);
    Serial.println();
    Serial.print("Odotus: ");
    Serial.print(startInterval);
    Serial.println();
    Serial.print("RPM: ");
    Serial.print(rpm);
    Serial.println();

    serDelay.reset();
  }
#endif
}

 

[Tupsa]

No niin, ei valitettavasti saanut toimimaan tuota koodia oikein. Koodi ei toiminut jostain syystä juuri lainkaan kokeillessani rampup funktion muuttamista aika-askeleiksi, eli että analogWrite funktioiden väliin tulisi stepTime ajastus + nollaus. Mutta nyt jostain syystä ongelmia ilmenee aikaisemmallakin koodilla, ei myöskään mene eteenpäin STARTED tilasta.

Onko tilojen sisällä asian tutkiminen sitä että if-funktiot ketjutetaan "toistensa sisään" eikä peräkkäin? Eli ylimpänä on tilavaatimus ja muut jutut tulee sitten tämän ehdon alle? Vaikea selittää, kun ei ihan ole kartalla, mutta toivottavasti tästä saa selvää.

Koodi on tuo sama, joka oli edellisessä viestissä. En tietääkseni muuttanut siitä mitään, mutta ei siis tosiaan etene STARTED tilasta eteenpäin. Toimivaa joka tapauksessa on WAITING, STARTING, STARTED ja FAIL. Ongelmat löytyvät tiloista RAMP_UP ja RUNNING tai niihin johtavista funktioista.

Harmillista, kun niin lähellä toimivaa luultavasti olisi. Miksi epäilen tuota ajastinkirjastoa, olisko mitään järkeä lähteä kokeilemaan koodia käyttämällä manuaalisesti millis() ajastuksia? Niitä en käsitä, mutta pitää lähteä yhdellä erillisellä harjoitusprojektilla vaikka liikkeelle, jos ei muuten saada.

Sitä alkaa epäillä jokaista riviä, mitä kauemmin rivejä katsoo, mutta lopulta en näe mitään, joka selittäisi tuon, ettei koodi etenekään seuraavaan kohtaan. Jos funktiossa on määrätyt ehdot ja se asettaa tilan seuraavaan, miksi seuraava funktio ei saa siitä "koppia"? Toki sekin varmaan voi olla mahdollista, että joku asettaa sitä tilaa koko ajan siihen aiempaan. Tällainen tilannehan ymmärtääkseni oli/on tuossa RAMP_UPIN ja RUNNINGIN kohdalla, kun PWM oli/on virheellistä ja tila vaihtelee hallitsemattomasti.

 

[ississ]

Onko tilojen sisällä asian tutkiminen sitä että if-funktiot ketjutetaan "toistensa sisään" eikä peräkkäin? Eli ylimpänä on tilavaatimus ja muut jutut tulee sitten tämän ehdon alle? Vaikea selittää, kun ei ihan ole kartalla, mutta toivottavasti tästä saa selvää.


Harmillista, kun niin lähellä toimivaa luultavasti olisi. Miksi epäilen tuota ajastinkirjastoa, olisko mitään järkeä lähteä kokeilemaan koodia käyttämällä manuaalisesti millis() ajastuksia? Niitä en käsitä, mutta pitää lähteä yhdellä erillisellä harjoitusprojektilla vaikka liikkeelle, jos ei muuten saada.

Kyllä, sisäkkäiset if- lauseet joista uloin on se tila.

Voihan se vika olla kirjastossakin, ei olisi ensimmäinen kerta sekään.
Yksi vaihtoehto on että tuo tarvittava toiminnallisuus ei ole suoraan kirjaston esimerkkinä vaan se pitääkin tehdä vähän eri tavalla kirjaston toteutuksesta riippuen.
Mutta ehkä ennemmin pitäisi tarkastaa tilat ja niiden välisten siirtymien ehdot.

Ja ennen kaikkea ne joissa on iso ehto ja else, ensin muutos malliin joka on kaikkien ehtojen osalta varmasti yksiselitteinen.

 

[Tupsa]

@ississ, tulisiko if-funktioiden mennä alla olevaan tyyliin, eli aina edellisen alle seuraava vai "samalla tasolla"? Ymmärtääkseni jos ne olisivat samalla tasolla ylimmän funktion alla, ne suoritettaisiin periaatteessa yhtaikaa? Ja jos ne ovat toisten alla, ylemmän pitää ensin toteutua, ennen kuin alempi ajetaan.

if(x == y) {
    if (a + c = d) {
        digitalWrite(pin);       
        if() {
            if() {
                
            }
        }
        
    }
}

 

[Nasty76]

Kyllä juuri noin ensimmäisen if lauseen sisään ne pitää laittaa jos halutaan että niitä ajetaan vain jos se ylin ehto on tosi.jos lähtevät samalta tasolta ne ajetaan peräkanaa välittämättä ylimmästä ehdoista

If(jotain)
{ Tee jotain}
If(toinen jotain)
{Tee toinen jotain}

Tuo esimerkki ajetaan aina välittämättä ylemmästä ehdoista eli sun on oikein mutta pitää huomata että yksikin {} merkin puute saattaa rikkoa idean mitä ajetaan vaikka kääntäjä ei erroria anna

 

[TemeV]

Pari suositusta koodiin:
Itse laittaisin "tilakoneen" tuonne looppiin. Eli loopissa jotain tämän tapaista:

switch (motorStatus) {
  case RAMP_UP:
    motorRampup();
   break;
  case STARTED:
    motorRunning();
    break;
}

Ja sitten noiden funktioiden sisältä tietysti tilojen tarkastelu pois, kun se tehdään siellä loopissa jo. Tällöin näet helpommin mitä koodia suoritetaan missäkin tilassa ja pääset helpommin perille siitä, missä kohtaa tila menee väärin.

Jätä nuo #ifdef DEBUG jutut pois. Tämän tyyppisissä softissa tahtoo helposti käydä niin, että kun sitten käännät sen koodin ilman noita debug-printtejä, ajoitukset muuttuu eikä koodi toimikkaan enää. Toki siinä on kyseessä silloin bugi, printit ei saisi vaikuttaa ajoituksiin. Jos se kuitenkin toimii, vaikkakin vain sen takia että printtaus tekee johonkin kohtaan viivettä, niin mitä sitten. Jos ei ole hyvää syytä miksi se laite ei saisi normaalissakin käytössä työntää printtejä sarjaporttiin, niin kannattaa antaa niiden vain mennä sinne. Eipä tarvi sitten erikseen flashata sinne debug-versiota, jos tarvii debugata.

Kuten tuolla jo aiemminkin suositeltiin niin laita näihin vaan rohkeasti lisää sulkuja:

if ((motorStatus == STARTED) && digitalRead(motorPin) == HIGH || rpm > rpmRun)

Ylläoleva on sama asia kuin

if (((motorStatus == STARTED) && digitalRead(motorPin) == HIGH) || rpm > rpmRun)

@ississ, tulisiko if-funktioiden mennä alla olevaan tyyliin, eli aina edellisen alle seuraava vai "samalla tasolla"? Ymmärtääkseni jos ne olisivat samalla tasolla ylimmän funktion alla, ne suoritettaisiin periaatteessa yhtaikaa? Ja jos ne ovat toisten alla, ylemmän pitää ensin toteutua, ennen kuin alempi ajetaan.

if(x == y) {
    if (a + c = d) {
        digitalWrite(pin);  
        if() {
            if() {
           
            }
        }
   
    }
}

Jos tulee kovin monta sisäkkäistä iffiä, niin kannattaa miettiä rakennetta uusiksi. Todennäköisesti asian voisi kirjoittaa selkeämminkin

Syntaksia voi nopesti harjoitella vaikka jollain tällaisella webbikilkkeellä:

Online C++ Compiler - Programiz

Write and run your C++ code using our online compiler. Enjoy additional features like code sharing, dark mode, and support for multiple programming languages.

www.programiz.com

Sinne kun laittaa jotain tämän tapaisia koodin pätkiä:

    bool a = true;
    bool b = false;
    bool c = false;
  
    if(a){
        std::cout << "A is true" << endl;
        if(b || c){
            std::cout << "B or C is true" << endl;
        }
    }

niin näkee nopeasti miten se toimii, kun vaihtelee vaan a:n b:n ja c:n arvoja.

 

[ississ]

@ississ, tulisiko if-funktioiden mennä alla olevaan tyyliin, eli aina edellisen alle seuraava vai "samalla tasolla"? Ymmärtääkseni jos ne olisivat samalla tasolla ylimmän funktion alla, ne suoritettaisiin periaatteessa yhtaikaa? Ja jos ne ovat toisten alla, ylemmän pitää ensin toteutua, ennen kuin alempi ajetaan.

if(x == y) {
    if (a + c = d) {
        digitalWrite(pin);      
        if() {
            if() {
               
            }
        }
       
    }
}

Justiinsa noin.
Ja @TemeV switch-case ja funktiot ehdotus on myös erittäin hyvä, noissa funktioissa sitten ehdot tilanvaihdolle jne.

// tämä on huono koska mahdollinen else ei todennäköisesti ole yksiselitteinen
if ((tila == 1) && ((read(pin) == HIGH) || (x < y))) { ... }

// tätä kannattaa käyttää, nyt ulomman else koskee vain tilaa ja sisemmän else toista ehtoa
if (tila == 1) {
  if ((read(pin) == HIGH) || (x < y)) { ... }
}

Koko koodi suoritetaan järjestyksessä ylhäältä alas, mikään ei mene rinnakkain.

Samalla tasolla olevat, siis esumerkiksi
if (tila ==1) { ... }
if ((tila == 1) && (x<y)) { ... }
Suoritetaan molemmat tuossa järjestyksessä jos tila pysyy arvossa 1 ja x<y.
Jos noissa olisi vielä else niin todennäköisesti päätyy ongelmiin, sitä helpommin mitä enemmän lisäehtoja on.

 

[Tupsa]

Tosia hyviä ohjeita!

Luonnollisesti olisi huomattavasti parempia tapoja kirjoittaa tämä ohjelma, mutta tällä hetkellä tavoitteena olisi vain saada se virheettömästi toimimaan, toki tuleehan siinä oppia. Kokeilin asetella funktioita "sisäkkäin", eli että ylimpänä oli ehto ja sen alle tulivat muut ehdot. Tuloksena valitettavasti se, että ohjelma ei etene. Startti jäi esimerkiksi pyörimään ikuisesti (simulaattori). Käynnistystilan ja käynnistyksen funktio eivät siis toimineet juuri lainkaan, mutta sillä alkuperäisessä if-else if -funktiolla ne toimivat. Ainakaan näihin kahteen en ehkä lähtisi tekemään muutoksia?

Tässä käynnistykseen asti toimivassa ohjelmassa jumittaa silti tilaan STARTED. Ongelma saattaa olla siinä, että kun moottorin kierrokset ovat yli rajan, else if-funktio asettaa loopilla tilaksi STARTED, eikä pääse etenemään? Toisaalta ymmärtääkseni tuokin ehto on ylimmän lausekkeen alla?
Probleema saattaa olla alla olevassa kohdassa.

If-funktion käyttäminen ei auttanut, eli että olisin korvan else if -funktion sillä.

void crank() {  // Engine starting function

  if (motorStatus == STARTING && (startTry >= 0 && startTry <= 4) && startInterval == 0 && rpm == 0) {  // If conditions are met, start executing

    if (rpm <= rpmTH) {  // If motor runs slower than the threshold, switch starter relay on
      digitalWrite(starterPin, HIGH);

      if (!crankTime.started()) {  // Start the crankTime timer only, if it has not been started yet
        crankTime.start();         // Start the crankTime timer if it hasn't started yet
      }

      if (crankTime.done()) {           // If motor did not start during the crankTime, stop starting
        digitalWrite(starterPin, LOW);  // Switch starter relay off
        crankTime.stop();
        crankTime.reset();  // Reset timer
        startTry += 1;      // Add one attempt
        startInterval = 1;  // Start waiting time function after starting attempt
      }
    }


  } else if (rpm > rpmTH) {         // If motor runs faster than the threshold, switch starter relay off
    digitalWrite(starterPin, LOW);  // Switch starter pin off
    startTry = 0;
    motorStatus = STARTED; // MITEN TÄMÄN SAISI NIIN, ETTÄ EI TEHDÄ KOKO AJAN???
    crankTime.stop();
    crankTime.reset();  // Reset timer
  }
}

 

[Hyrava]

Tuossa nyt haiskahtaisi esimerkiksi se että tuota crank-funktiota kutsuttaisiin muulloinkin kuin ollaan starttaamassa (STARTING). Jos sitä kutsutan muissa tiloissa ja moottori pyörii raja-arvoa nopeammin niin tuohan vaihtaa tilaksi STARTED. Purkkaviritys tuohon tietty olisi laittaa jotain tyyliin:

else if ((rpm > rpmTH) && (motorStatus == STARTING))

jolloin tuota ehtoa ei suoritettaisi kuin silloin kun ollaan starttaamassa. Toki parempi olisi tehdä tuo logiikka oikein, eli yhtäkkiä ajatellen esim siirtämällä tuo else if -lohko tavalliseksi if:ksi tuon ensimmäisen if:n sisään.

Mielestäni tuota moottorin STARTING-tilaa ei periaatteessa pitäisi edes tutkia crank-funktion sisällä vaan mieluummin sen ulkopuolella, eihän starttia haluta pyörittää kuin vain silloin kun halutaan käynnistää kone eli tila on STARTING.

En nyt jaksanut kaivella aiemmasta postauksesta koko koodia pähkäilyni pohjaksi mutta oma logiikka sanoisi vahvasti noin.

 

[Tupsa]

No nyt selvisi kyllä jännä juttu. Eli tuossa serial tulostuksessa on mulla ollut koko ajan tuo viive ilmeisesti estävä (blocking) vaikka onkin käytetty tuota ajastinkirjastoa, eli se pysäyttänyt aina muun toiminnan. Sen kyllä huomasi, kun otin pois kokonaan ne ajastukset. Simulaattori-ikkunan oikeassa yläkulmassa näkyvä prosentti tippu 20-30 %:iin, kun se oli ajastimen ollessa lähes koko ajan 100 %.

Ja selvisi vielä lisääkin, eli tuo näköjään hyvinkin hallitsemattomasti alkaa vaihtelemaan tiloja todella nopealla vauhdilla. En siis mitään näppäintä painanut, esim. 11 V, että olisi pitänyt vasta siirtyä STARTING tilaan. Eli tuo ihan itsestään alkaa hyppimään näköjään tuonne RUNNING ja RAMP_UP tiloihin.

 

[KrisG]

motorRunning funktion alussa on ehto
if ((motorStatus == STARTED) && digitalRead(motorPin) == HIGH || rpm > rpmRun)
mikä on siis tosi aina kun rpm > rpmRun. Seurauksena on samassa funktiossa tilan vaihto motorStatus = RAMP_UP. Ramp up pitäisi kuitenkin tehdä kerran käynnistyksen aikana.

Kannattaa tosiaan tehdä ensinnäkin koodista rakenteeltaan selkeä. Jos käyttää tilakonetta, niin kannattaa olla jokaisella tilalle oma funktio, ja pääloopissa sitten kutsutaan vain kyseisen hetken tilaa, käyttäen esimerkiksi switch(tila)-case -rakennetta. Tilan sisällä sitten tehdään tarvittavia asioita sekä tarkastellaan, että täyttyykö ehdot tilan vaihtamiseen.

Helpottaa myös jos piirtää logiikasta vuokaavion (esimerkkejä esim. haulla state machine flowchart), jolloin joku toinen koodia tarkasteleva henkilö voi verrata koodia kaavioon ja huomata koodin logiikkavirheet helpommin.

E:
void crank() { // Engine starting function
if (motorStatus == STARTING && (startTry >= 0 && startTry <= 4) && startInterval == 0 && rpm == 0)
rpm == 0 ehto vaikuttaa tässä järjettömältä. Moottori kun lähtee pyörimään, niin tuo ehto sitten estää heti tämän if:n toteutumisen. == vertailut ovat myös epäilyttäviä fyysisien sensorien ja liukulukujen kanssa, eli näissä kannattaa olla joku toleranssi, jonka sisällä arvon pitää olla.

 

[ississ]

Taitaa nyt olla kolmas kerta kun mainitsen tästä.

Pura pois koodista kaikki nuo yhdistelmä if- lauseet joissa on tila + jotain muuta.
Se tila kuuluu olla oma erillinen noista muista ehdoista.

Tällaisissa tapauksissa käy yleensä niin että toiminnallisuuksia lisätessä entisetkin lakkaa helposti toimimasta koska ehdot eivät ole yksiselitteisiä.

Eikä sekään ole harvinaista että koko homma pitää miettiä uudelleen ja ehkä koodatakin koska alkuperäinen ei ollutkaan korjattavissa.

 

[TemeV]

Tosia hyviä ohjeita!

Luonnollisesti olisi huomattavasti parempia tapoja kirjoittaa tämä ohjelma, mutta tällä hetkellä tavoitteena olisi vain saada se virheettömästi toimimaan, toki tuleehan siinä oppia

Voihan sen koodin toki bruteforcettaakin toimimaan oikein. Pienemmällä vaivalla sen kuitenkin saa toimimaan, kun tekee siihen järkevän rakenteen ja noudattaa edes joitain hyviä käytäntöjä.