Micros(), counting time for engine simulation

[darkorg69]

Hello to everyone. I need some help with programming my project. So I'm doing a engine simulation with Arduino Uno. The whole idea is to simulate an engine running via setting predefined RPM by a potentiometer, when the engine is "running" the uno should count the time passed since the engine has started, and at the end of each loop update the crankshaft angle as precise as it could be. At this particular moment the logic is to store the time each loop starts with ~
micros(), then see where the crankshaft is, activate ignition and injection signals. (I'm basically simulating fuel injection and fuel ignition). After all the logic I update the crank angle (between 0.00 and 720.00) based on the microseconds passed.

The problem I have is, when I set the RPM at 60. Meaning 1 full rotation for 1 second, the controller does a full rotation for something like 5-6 seconds. What I do is calculate the revolutions per microsecond (currentRPM/60/1000/1000) and then multiply by 360 and the microseconds passed. The whole thing I have simplified to currentRPM * (0.000006) * microsPassed which I believe is mathematically right, but the uno seems to not care. I do know time counting is hard especially with such slow processors, but it's 4-5 times slower than expected even on 4us resolution. Am I making a mistake somewhere with my maths or there some other error.

I can't upload the code right now as I am not from my PC, but I will make sure to update the thread once I get home.

Thanks to everyone in advance.

#Edit: I got home so...

I've uploaded my repo on Github!

[noiasca]

@darkorg69

The problem I have is, when I set the RPM at 60. Meaning 1 full rotation for 1 second, the controller does a full rotation for something like 5-6 seconds.

then your program does something wrong, but we can't see your program.

In general I would expect that you have a sensor for the top dead center and use that signal as reference when to fire which spark and activate which injection depending on the order of the cylinder.

[DrDiettrich]

@darkorg69

revolutions per microsecond (currentRPM/60/1000/1000)

This will most probably result in zero rev's, due to integer arithmetic. use float(currentRPM) or 60.0 to enable floating point arithmetic.

[darkorg69]

I have simplified currentRPM/60/1000/1000*360 to currentRPM*0.000006.

I'm using floating point arithmetic.

Could the fact that currentRPM is uint16_t cause such a problem? I'm gonna try casting it first then calculating.

[darkorg69]

I only have 3 ignition coils and 3 injectors. I don't have a real engine. Also no sensors, just a on/off switch and potentiometer to control the RPM.

I must simulate a engine ignition and fuel system, it's for a university project. I already have the hardware working, but I can't figure out the crank rotation simulation.

[DrDiettrich]

@darkorg69

I'm using floating point arithmetic.

How do you know? The target type is unimportant for the calculations.

[noiasca]

@darkorg69

I must simulate a engine ignition and fuel system,

Then you also have to simulate the tdc sensor. That is your first task.

[alto777]

@darkorg69

I will make sure to update the thread once I get home.

I am looking forward to that.

Describe how much of a simulation this is and is not.

Please outline the real hardware that will be part of the demonstration, like motors or whatever.

a7

[darkorg69]

@noiasca

Then you also have to simulate the tdc sensor. That is your first task.

You probably mean crank or cam position/speed sensor, which sends information to the ECM about the position and or the speed of the crankshaft or camshafts.

All this sensor does is tell the ECM at what rotation between 0-720 degrees the crankshaft is at, which is the same thing I'm trying to simulate. By knowing the position of the crankshaft you can then find absolutely everything else, cam position, piston position, at which stroke a cylinder is...

Also spark signals should be sent earlier, before TDC, as you need like 3ms because of the coil dwell time, if you interrupt the signal earlier this will cause little or no spark on the spark plug.

You can check my repo, I've uploaded my code now.

[darkorg69]

The real hardware is as it goes:
-12V battery, connected to a COP (coil on plug), triggered directly by the Arduino.

MOSFET Module (IRF520), powering my injector through the 12V battery.
The injector needs 12V and has 14.6Ohm of resistance, so it will draw like 0.86A (~1A).

The simulation is very very simple, just set the RPM by the potentiometer.

If the RPM signal is more than ENGINE_START_RPM the engines starts, from 0 degrees of the crankshaft, then it counts time at each loop and updates the crankshaft position based on the time passed and the currentRPM set by the potentiometer. Each loop it checks if the crankshaft is at certain angle based on the engine parameters like number of cylinders, firing order etc... and determines which signals to send, likecylinder to ignite or inject.

Currently I have only 1 coil and 1 injector, but later I will use 3, as I have to simulate a 3 cylinder engine, but for sake of simplicity before I solder everything in I want to make sure I have a working software, because if it can control 1 coil and 1 injector it should also control 3 with no problems.

[darkorg69]

@Delta_G

Why don't you post it here. Most folks won't follow you offsite to get it.

Here you go.

//// MACROS
/// PINS
// Analog Input
#define RPM_ANALOG_INPUT A0
// PWM Ignition Output
#define IGN_OUTPUT_0 3
#define IGN_OUTPUT_1 5
#define IGN_OUTPUT_2 6
// PWM Injection Output
#define INJ_OUTPUT_0 9
#define INJ_OUTPUT_1 10
#define INJ_OUTPUT_2 11

//// ENGINE
// Parameters
#define ENGINE_STROKES 4
#define ENGINE_CYLINDERS 1
#define DEGREES_PER_STROKE 180
#define DEGREES_PER_CYCLE (ENGINE_STROKES * DEGREES_PER_STROKE)
#define OPTIMAL_FIRING_ANGLE (DEGREES_PER_CYCLE / ENGINE_CYLINDERS)
// RPM
#define ENGINE_STALL_RPM 550
#define ENGINE_START_RPM 600
#define ENGINE_IDLE_RPM 650
#define ENGINE_LIMIT_RPM 6300
// Ignition and fuel injection timing [Degrees° before TDC]
#define INJ_START 90
#define INJ_END 45
#define IGNITION_ADVANCE 25

const bool debugEnabled = true; //change to false to disable serial monitoring

//// GLOBAL CONSTANTS (These should get manually updated based on macros)
// Unmodifiable array to store engine firing order
const uint8_t engineFiringOrder[ENGINE_CYLINDERS] = { 0 };
// Unmodifiable array to loop through ignition signal pins
const uint8_t ignitionSignalPins[ENGINE_CYLINDERS] = { IGN_OUTPUT_0 };
//const uint8_t ignitionSignalPins[ENGINE_CYLINDERS] = { IGN_OUTPUT_0, IGN_OUTPUT_1, IGN_OUTPUT_2 };
// Unmodifiable array to loop through injection signal pins
const uint8_t injectionSignalPins[ENGINE_CYLINDERS] = { INJ_OUTPUT_0 };
//const uint8_t injectionSignalPins[ENGINE_CYLINDERS] = { INJ_OUTPUT_0, INJ_OUTPUT_1, INJ_OUTPUT_2 };

//// PROGRAM VARIABLES
// Variable to store when each loop starts (Used to update crankshaft angle)
uint32_t loopStartTime = 0;

//// GLOBAL VARIABLES
// Variable to store the current RPM signal (pin A0)
uint16_t rpmSignal = 0;
// Variable to store the current mapped RPM signal (static current rpm)
uint16_t rpmSignalMapped = 0;

//// ENGINE VARIABLES
// Variable to store the current engine state
bool engineIsRunning = false;
//Variable to track if the engine should start
bool engineShouldStart = false;
//Variable to track if the engine should stall
bool engineShouldStall = false;
// Variable to store the current engine rpm
uint16_t currentRPM = 0;
// Variable to store the current crankshaft angle
double crankshaftAngle = 0.0;
//Variable to track which cylinder is at compression stroke
uint8_t currentCylinder = 0;
/// Array to track cylinders spark ignition
uint8_t cylinderIgnition[ENGINE_CYLINDERS] = { LOW };
/// Array to track cylinder fuel injection
uint8_t cylinderInjection[ENGINE_CYLINDERS] = { LOW };

void setup() {
  //Put your setup code here, to run once:
  Serial.begin(9600);

  //Initialize ignition pin modes
  pinMode(IGN_OUTPUT_0, OUTPUT);
  pinMode(IGN_OUTPUT_1, OUTPUT);
  pinMode(IGN_OUTPUT_2, OUTPUT);
  //Initialize injection pin modes
  pinMode(INJ_OUTPUT_0, OUTPUT);
  pinMode(INJ_OUTPUT_1, OUTPUT);
  pinMode(INJ_OUTPUT_2, OUTPUT);
}

//like `%` but for doubles
double doubleModulus(double value, double divisor) {
  uint32_t timeSpent = micros();
  while (value >= divisor) {
    value -= divisor;
  }
  return value;
  Serial.print("Time spent on doubleModulus: ");
  Serial.print(timeSpent);
  Serial.print("\n");
}


void startEngine() {
  engineIsRunning = true;
  crankshaftAngle = 0.0;
  currentRPM = rpmSignalMapped;
  loopStartTime = micros();
}

void stallEngine() {
  engineIsRunning = false;
  crankshaftAngle = 0.0;
  currentRPM = 0;
}

uint32_t lastIgnitionCoilSignal = 0;
uint32_t lastInjectorSignal = 0;

void updateSignals() {
  for (uint8_t i = 0; i < ENGINE_CYLINDERS; i++) {
    digitalWrite(ignitionSignalPins[i], cylinderIgnition[i]);
    digitalWrite(injectionSignalPins[i], cylinderInjection[i]);
  }
}

void loop() {
  loopStartTime = micros();

  uint16_t rpmSignalNew = analogRead(RPM_ANALOG_INPUT);

  if (rpmSignal != rpmSignalNew) {
    rpmSignal = rpmSignalNew;
    //rpmSignalPrint(rpmSignal);

    rpmSignalMapped = map(rpmSignal, 0, 1023, 0, ENGINE_LIMIT_RPM);
    //rpmSignalMappedPrint(rpmSignalMapped);

    engineShouldStart = !engineIsRunning && (rpmSignalMapped >= ENGINE_START_RPM);
    engineShouldStall = engineIsRunning && (rpmSignalMapped <= ENGINE_STALL_RPM);

    if (engineShouldStart) {
      startEngine();
    }

    if (engineShouldStall) {
      stallEngine();
    }
  }

  if (engineIsRunning) {
    currentRPM = rpmSignalMapped;

    if (debugEnabled) {
      Serial.print(currentRPM);
      Serial.print("\n");
    }

    currentCylinder = crankshaftAngle / OPTIMAL_FIRING_ANGLE;

    if (doubleModulus(crankshaftAngle, DEGREES_PER_STROKE) + IGNITION_ADVANCE >= DEGREES_PER_STROKE) {
      cylinderIgnition[engineFiringOrder[currentCylinder]] = HIGH;
    } else {
      for (unsigned char i = 0; i < ENGINE_CYLINDERS; i++) {
        cylinderIgnition[i] = LOW;
      }
    }

    if (doubleModulus(crankshaftAngle, DEGREES_PER_STROKE) + INJ_START >= DEGREES_PER_STROKE) {
      cylinderInjection[engineFiringOrder[currentCylinder]] = HIGH;
    }

    if (doubleModulus(crankshaftAngle, DEGREES_PER_STROKE) + INJ_END >= DEGREES_PER_STROKE) {
      cylinderInjection[engineFiringOrder[currentCylinder]] = LOW;
    }

    updateSignals();
    crankshaftAngle = doubleModulus(crankshaftAngle + (currentRPM * 0.000006 * (micros() - loopStartTime)), DEGREES_PER_CYCLE);
  }
}

[alto777]

I can't run your code yet, but I already want to change how you track time and accumulate a crankshaft angle.

You capture the loopStartTime, then do some calculations, then calculate an elapsed time and exit the loop.

I want to see how long those calculations take, and how long it takes to come around again.

I would have less trouble and fewer questions with

    static unsigned long lastAccTime;
    unsinged long now = micros();

    crankshaftAngle = doubleModulus(crankshaftAngle + (currentRPM * 0.000006 * (now - lastAccTime)), DEGREES_PER_CYCLE);

    lastAccTime = now;

which uses only one call to micros() each pass, eliminating any possibility of time leakage.

a7

[DrDiettrich]

@alto777

I want to see how long those calculations take

That's unimportant in a simulation. Have virtual time bound to the RPM and crankshaftAngle. If you know at which angle increment the next event occurs then simply set the virtual time for that angle, handle the event and go on to the next event.

[alto777]

@DrDiettrich

That's unimportant in a simulation.

Yes, but I am curious because of the separation of taking the time for figuring elapsed time is just the calculations, and the time to exit and return to the loop is unaccounted for.

Yes, still unimportant. I might as well say why use micros() or any reference to real time at all?

It would make more sense to me to simply say that the loop can get around to doing the calculations and setting the outputs at some fixed frequency, which would be some fixed period.

With the loop as it is, I'd like to see where the time is getting spent is all.

a7

[noiasca]

for the 4 stroke motor timing calculation I would use a 720 cylce, not the crankshaft angle.
millis/mircros is just used to slow down the simulation (=throttle)

engine_4stroke - Wokwi ESP32, STM32, Arduino Simulator

I didn't do a RPM calculation, because I wanted to stay within 42 lines of code (should be quite easy when you devide the cylce by 2 and then calculate how many rotation passed per minute) - and it's not my homework.

[darkorg69]

@noiasca

for the 4 stroke motor timing calculation I would use a 720 cylce, not the crankshaft angle.

Sadly, with this software the coil will not produce any spark or will produce very weak one.

I have to wait atleast 3ms before turning the coil signal off, because the primary coil needs to "charge up" before discharging, else the secondary coil will not induce enough high voltage from the collapsing electromagnetic field to produce a good spark.

This is one of the main reasons I need the actual crank position, because based on the currentRPM, I have to calculate the dwellAngle (The angle at which I should send the trigger signal, so it has enough time to charge before I discharge it).

[hallowed31]

Are you not allowed to just use a crank position sensor, or equivalent and some spinning disk affixed to an electric motor with a known (calibrated) RPM controlled by the potentiometer?

Quick story: the local Hyundai stealership tried to rip me off when I asked them to replace the crank sensor on my 2012 Santa Fe. I dropped it off for other work like an oil change and said there was a problem I think is the crank sensor (long time to turnover, brand new battery and such, plus my OBDII reader indicated a possible faulty crank sensor).
Long story short, after they lied to me about replacing it, I went to Napa and bought a new one. I went home, took out the sensor that was obviously not new and connected it to my scope and tested it against an old hole saw drill bit that I dremeled a couple of the teeth out of to simulate how a crank sensor is used. Then I compared it to the new one, obviously the dead one was noise on the scope at even 0.2 (iirc) volts/division whereas the new one gave me nice square waves at 5V per division. Then I returned to the stealership but that's another story.

Point (question I guess) is, would something like the test rig I cooked up to catch those lying b*****ds work for your project?

[DaveX]

It's unclear what is hardware or not in your setup, but with this baud rate:

@darkorg69

void setup() {
  //Put your setup code here, to run once:
  Serial.begin(9600);

...taken with all the Serial.prints(), it could be slowing down your simulation significantly.

[darkorg69]

Adapting my code like this managed to fix the time problem, now time leakage is not noticable.

At 60 RPM one 360 degree cycle takes around 1 sec ± 1-2ms, but now to the next problem - my loop takes significantly more time, like 1 loop takes up 15 ms which is too slow to run at more than 60 RPM.

I need to make it somehow run at 6300 RPM

[alto777]

@noiasca

it's not my homework.

Thanks for sharing. See if the next thing I do is add a ring of neopixels to that. Or just some extra LEDs for the other two strokes.

@darkorg69

make it somehow run at 6300 RPM

OK, that's a 10 millisecond loop time. An eternity!

Bump the printing to 115200 or even higher as @DaveX pointed out. Or lose 99 percent of it: anything you are over with for informational purposes can just be // commented out. Anything you do need printed could be made shorter. Consider LEDs for feedback instead &c.

There are ways of doing better than floating point, but I don't know at a glance if that's a or the problem.

a7