Hi @dainoso ,
I have ported your sketch to Wokwi and added a function that simulates the encoder pulses (more or less).
You can check it out on Wokwi
https://wokwi.com/projects/440279150495983617
Feel free to find and read also some comments regarding your code that might be of interest for you:
/*
Forum: https://forum.arduino.cc/t/arduino-stop-working-or-automatic-reset/1404103
Wokwi: https://wokwi.com/projects/440279150495983617
2025/08/25
ec2021
The function simulateRPM() was added to simulate the encoder pulses that usually come from
a motor encoder.
This is a commented version
*/
#include <util/atomic.h>
#include <PinChangeInterrupt.h>
// As #defines can be redefined during the code without notice
// it is recommended to use const or constexpr variables instead
// of #define
#define ENCODEROUTPUT_MOTOR 48
#define EN_MOTOR 3
#define IN1_MOTOR 2
#define IN2_MOTOR 4
#define ENCA_MOTOR 10
#define ENCB_MOTOR 11
unsigned long prevT = 0;
unsigned long currT = 0;
int posPrev = 0; // posPrev is ment to hold the previous value of long pos_i
// therefore it must have the same type!
// The code runs into trouble as the following lines show
// when posPrev overflows:
/*
RPM:599.98
RPM:600.00
RPM:587.45
RPM:599.95
RPM:819603.25
RPM:819701.68
RPM:819787.50
RPM:819800.00
*/
volatile long pos_i = 0;// In the Arduino environment volatile is only required for hardware registers
// where the compiler cannot see any reason that the variable would change
// and its "optimization" would remove the variable access.
// The ATOMIC_BLOCK macro is exactly what's relevant here for two reasons:
// - It makes sure that the variable is read from memory (not from a procesor register)
// - Interrupts are disabled while reading the variable so that no other access can
// interfere with its content and interrupts are safely enabled again at the end of
// the macro
void setup() {
// Today Serial communication to a PC is better done with 115200 Bd
Serial.begin(9600);
// delay(5000);
pinMode(EN_MOTOR, OUTPUT);
pinMode(IN1_MOTOR, OUTPUT);
pinMode(IN2_MOTOR, OUTPUT);
pinMode(ENCA_MOTOR, INPUT_PULLUP);
pinMode(ENCB_MOTOR, INPUT_PULLUP);
attachPCINT(digitalPinToPCINT(ENCA_MOTOR), readEncoderMotor, RISING);
prevT = micros();
}
void loop() {
/****************************/
simulateRPM(600);
/****************************/
// As the value of pos_i is only relevant inside the function
// if (currT - prevT >= 100000) {}
// It does not make sense to copy pos_i here with each loop
// It is sufficient to call the ATOMIC_BLOCK copy function inside the following
// if-statement only every 100 ms
long pos;
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
pos = pos_i;
}
currT = micros();
// update after 100ms
if (currT - prevT >= 100000) { // 100000 us = 100 ms
float deltaT = (currT - prevT) / 1.0e6;
long deltaPos = pos - posPrev;
// currT - prevT must be always(!) greater or equal to 100000 at this line
// due to the if-statement above
// Therefore deltaT = (currT - prevT) / 1.0e6 = 100000/ 1.0e6 = 1.0e5/1.0e6 = 0.1
// 0.1 is always larger then 0.0001
// As the following if-statement will always be true (unless one reduces the timing interval)
// it could be removed
if (deltaT > 0.0001) {
float velocity = deltaPos / deltaT; //pulse/s
float v = velocity / ENCODEROUTPUT_MOTOR * 60.0; // RPM
Serial.print("RPM:");
Serial.println(v);
}
prevT = currT;
posPrev = pos;
}
// Calling the following function in every loop is wasting controller time
// as the data and therefore the behaviour of the motors do not change
// It would save valuable processor time if it was only called
// - once in the beginning (e.g. in setup())
// - once everytime when either direction or speed or both are changing
setMotor(1, 15, EN_MOTOR, IN1_MOTOR, IN2_MOTOR);
}
void setMotor(int dir, int pwmVal, int EN, int IN1, int IN2) {
analogWrite(EN, pwmVal);
if (dir == 1) {
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
} else if (dir == -1) {
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
} else {
digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
}
}
void readEncoderMotor() {
// This function is called on a RISING edge on pin ENCA_MOTOR but
// reads the state of ENCB_MOTOR
// There is no(!) synchronisation with ENCB_MOTOR!
// It would be pure coincidence if both encoders work synchronized
//
// If you change from ENCB_MOTOR to ENCA_MOTOR then
// ENCA_MOTOR must always be HIGH when this ISR function
// is called on a RISING edge. It would be different if it was called on FALLING or
// - for both possibilities - with CHANGE mode however than pos_i would
// count 1 up and down and always return zero
if (digitalRead(ENCB_MOTOR) == HIGH) {
pos_i++;
} else {
pos_i--;
}
}
/* The following function creates pulses in pulseOutPin that */
/* simulate the encoder pulses of a given motor */
void simulateRPM(uint16_t RPM) {
constexpr byte pulseOutPin {5};
static unsigned long lastPulse = 0;
if (lastPulse == 0) {
pinMode(pulseOutPin, OUTPUT);
digitalWrite(pulseOutPin, HIGH);
}
unsigned long noOfPulses = ENCODEROUTPUT_MOTOR * RPM / 60;
unsigned long microsInterval = 1000000UL / noOfPulses;
if (micros() - lastPulse >= microsInterval) {
lastPulse = micros();
digitalWrite(pulseOutPin, LOW);
delayMicroseconds(5);
digitalWrite(pulseOutPin, HIGH);
}
}
There is also a modified version of your sketch that includes the changes which I recommended.
See here https://wokwi.com/projects/440281601942207489
Modified Sketch
/*
Forum: https://forum.arduino.cc/t/arduino-stop-working-or-automatic-reset/1404103
Wokwi: https://wokwi.com/projects/440281601942207489
2025/08/25
ec2021
The function simulateRPM() was added to simulate the encoder pulses that usually come from
a motor encoder.
This is a version where the commented parts of
https://wokwi.com/projects/440279150495983617
have been changed.
*/
#include <util/atomic.h>
#include <PinChangeInterrupt.h>
constexpr uint16_t ENCODEROUTPUT_MOTOR {48};
constexpr uint8_t EN_MOTOR {3};
constexpr uint8_t IN1_MOTOR {2};
constexpr uint8_t IN2_MOTOR {4};
constexpr uint8_t ENCA_MOTOR {10};
constexpr uint8_t ENCB_MOTOR {11};
unsigned long prevT = 0;
unsigned long currT = 0;
long posPrev = 0;
long pos_i = 0;
void setup() {
Serial.begin(115200);
pinMode(EN_MOTOR, OUTPUT);
pinMode(IN1_MOTOR, OUTPUT);
pinMode(IN2_MOTOR, OUTPUT);
pinMode(ENCA_MOTOR, INPUT_PULLUP);
pinMode(ENCB_MOTOR, INPUT_PULLUP);
attachPCINT(digitalPinToPCINT(ENCA_MOTOR), readEncoderMotor, RISING);
prevT = micros();
setMotor(1, 15, EN_MOTOR, IN1_MOTOR, IN2_MOTOR);
}
void loop() {
/****************************/
simulateRPM(600);
/****************************/
currT = micros();
// update after 100ms
if (currT - prevT >= 100000) { // 100000 us = 100 ms
long pos;
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
pos = pos_i;
}
float deltaT = (currT - prevT) / 1.0e6;
long deltaPos = pos - posPrev;
float velocity = deltaPos / deltaT; //pulse/s
float v = velocity / ENCODEROUTPUT_MOTOR * 60.0; // RPM
Serial.print("RPM:");
Serial.println(v);
prevT = currT;
posPrev = pos;
}
}
void setMotor(int dir, int pwmVal, int EN, int IN1, int IN2) {
analogWrite(EN, pwmVal);
if (dir == 1) {
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
} else if (dir == -1) {
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
} else {
digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
}
}
void readEncoderMotor() {
pos_i++;
}
/* The following function creates pulses in pulseOutPin that */
/* simulate the encoder pulses of a given motor */
void simulateRPM(uint16_t RPM) {
constexpr byte pulseOutPin {5};
static unsigned long lastPulse = 0;
if (lastPulse == 0) {
pinMode(pulseOutPin, OUTPUT);
digitalWrite(pulseOutPin, HIGH);
}
unsigned long noOfPulses = ENCODEROUTPUT_MOTOR * RPM / 60;
unsigned long microsInterval = 1000000UL / noOfPulses;
if (micros() - lastPulse >= microsInterval) {
lastPulse = micros();
digitalWrite(pulseOutPin, LOW);
delayMicroseconds(5);
digitalWrite(pulseOutPin, HIGH);
}
}
Hope that it is of assistance!
ec2021
BTW: Be aware that the function simulateRPM() has only a limited RPM range as it is called inside loop and therefore depends on the loop timing. However it should work as a cheap and simple means for basic testing ... And you can get a more stable RPM measurement by increasing the measurement interval from 100 ms to 250 ms, 500 ms or 1 s.
