dani/CommandStation-EX
1
0
Fork 0
mirror of https://github.com/DCC-EX/CommandStation-EX.git synced 2024-11-26 17:46:14 +01:00
Code Releases Activity

Merge branch 'devel-overcurrent' into devel

Browse Source
This commit is contained in:
Harald Barth 2023-06-20 21:17:28 +02:00
commit 2f65d4347e
3 changed files with 131 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
GITHUB_SHA.h
View File

@ -1 +1 @@
#define GITHUB_SHA "devel-202306182208Z" #define GITHUB_SHA "devel-202306190642Z"

151
MotorDriver.cpp
View File

@ -159,11 +159,7 @@ MotorDriver::MotorDriver(int16_t power_pin, byte signal_pin, byte signal_pin2, i
// senseFactorInternal, raw2mA(1000),mA2raw(1000)); // senseFactorInternal, raw2mA(1000),mA2raw(1000));
} }
// prepare values for current detection
sampleDelay = 0;
lastSampleTaken = millis();
progTripValue = mA2raw(TRIP_CURRENT_PROG); progTripValue = mA2raw(TRIP_CURRENT_PROG);
} }
bool MotorDriver::isPWMCapable() { bool MotorDriver::isPWMCapable() {
@ -172,6 +168,7 @@ bool MotorDriver::isPWMCapable() {
void MotorDriver::setPower(POWERMODE mode) { void MotorDriver::setPower(POWERMODE mode) {
if (powerMode == mode) return;
bool on=mode==POWERMODE::ON; bool on=mode==POWERMODE::ON;
if (on) { if (on) {
// when switching a track On, we need to check the crrentOffset with the pin OFF // when switching a track On, we need to check the crrentOffset with the pin OFF
@ -372,63 +369,123 @@ void MotorDriver::getFastPin(const FSH* type,int pin, bool input, FASTPIN & res
} }
void MotorDriver::checkPowerOverload(bool useProgLimit, byte trackno) { void MotorDriver::checkPowerOverload(bool useProgLimit, byte trackno) {
if (millis() - lastSampleTaken < sampleDelay) return;
lastSampleTaken = millis();
int tripValue= useProgLimit?progTripValue:getRawCurrentTripValue(); int tripValue= useProgLimit?progTripValue:getRawCurrentTripValue();
// Trackname for diag messages later
switch (powerMode) { switch (powerMode) {
case POWERMODE::OFF: case POWERMODE::OFF:
sampleDelay = POWER_SAMPLE_OFF_WAIT; if (overloadNow) {
// reset overload condition as we have just turned off power
// DIAG(F("OVERLOAD POFF OFF"));
overloadNow=false;
lastPowerChange = micros();
}
if (microsSinceLastPowerChange() > POWER_SAMPLE_ALL_GOOD) {
power_sample_overload_wait = POWER_SAMPLE_OVERLOAD_WAIT;
}
break; break;
case POWERMODE::ON: case POWERMODE::ON:
// Check current // Check current
lastCurrent=getCurrentRaw(); lastCurrent=getCurrentRaw();
if (lastCurrent < 0) { if (lastCurrent < 0) {
// We have a fault pin condition to take care of // We have a fault pin condition to take care of
lastCurrent = -lastCurrent; if (!overloadNow) {
setPower(POWERMODE::OVERLOAD); // Turn off, decide later how fast to turn on again // turn on overload condition as fault pin has gone active
if (commonFaultPin) { // DIAG(F("OVERLOAD FPIN ON"));
if (lastCurrent < tripValue) { overloadNow=true;
setPower(POWERMODE::ON); // maybe other track lastPowerChange = micros();
} }
// Write this after the fact as we want to turn on as fast as possible lastCurrent = -lastCurrent;
// because we don't know which output actually triggered the fault pin if (commonFaultPin) {
DIAG(F("COMMON FAULT PIN ACTIVE: POWERTOGGLE TRACK %c"), trackno + 'A'); if (lastCurrent < tripValue) {
} else { // probably other track, do a fast toggle.
DIAG(F("TRACK %c FAULT PIN ACTIVE - OVERLOAD"), trackno + 'A'); setPower(POWERMODE::OVERLOAD); // Turn off, decide later how fast to turn on again
if (lastCurrent < tripValue) { setPower(POWERMODE::ON); // maybe other track
lastCurrent = tripValue; // exaggerate // Write this after the fact as we want to turn on as fast as possible
} // because we don't know which output actually triggered the fault pin
DIAG(F("COMMON FAULT PIN ACTIVE: POWERTOGGLE TRACK %c"), trackno + 'A');
} }
} else {
if (lastCurrent < tripValue) {
if (power_sample_overload_wait <= (POWER_SAMPLE_OVERLOAD_WAIT * 10) && // almost virgin
microsSinceLastPowerChange() < POWER_SAMPLE_IGNORE_FAULT_LOW) {
// Ignore 50ms fault pin if no current
DIAG(F("TRACK %c FAULT PIN 50ms ignore"), trackno + 'A');
break;
}
lastCurrent = tripValue; // exaggerate so condition below (*) is true
} else {
if (power_sample_overload_wait <= POWER_SAMPLE_OVERLOAD_WAIT && // virgin
microsSinceLastPowerChange() < POWER_SAMPLE_IGNORE_FAULT_HIGH) {
// Ignore 5ms fault pin if we see current
DIAG(F("TRACK %c FAULT PIN 5ms ignore"), trackno + 'A');
break;
}
}
DIAG(F("TRACK %c FAULT PIN ACTIVE"), trackno + 'A');
}
} }
if (lastCurrent < tripValue) { // // //
sampleDelay = POWER_SAMPLE_ON_WAIT; // above we looked at fault pin, below we look at current
if(power_good_counter<100) // // //
power_good_counter++; if (lastCurrent < tripValue) { // see above (*)
else if (overloadNow) {
if (power_sample_overload_wait>POWER_SAMPLE_OVERLOAD_WAIT) power_sample_overload_wait=POWER_SAMPLE_OVERLOAD_WAIT; // current is below trip value, turn off overload condition
// DIAG(F("OVERLOAD PON OFF"));
overloadNow=false;
lastPowerChange = micros();
}
if (microsSinceLastPowerChange() > POWER_SAMPLE_ALL_GOOD) {
power_sample_overload_wait = POWER_SAMPLE_OVERLOAD_WAIT;
}
} else { } else {
setPower(POWERMODE::OVERLOAD); // too much current
unsigned int mA=raw2mA(lastCurrent); if (!overloadNow) {
unsigned int maxmA=raw2mA(tripValue); // current is over trip value, turn on overload condition
power_good_counter=0; // DIAG(F("OVERLOAD PON ON"));
sampleDelay = power_sample_overload_wait; overloadNow=true;
DIAG(F("TRACK %c POWER OVERLOAD %dmA (limit %dmA) shutdown for %dms"), trackno + 'A', mA, maxmA, sampleDelay); lastPowerChange = micros();
if (power_sample_overload_wait >= 10000) }
power_sample_overload_wait = 10000; unsigned long uSecs = microsSinceLastPowerChange();
else if (power_sample_overload_wait > POWER_SAMPLE_OVERLOAD_WAIT || // not virgin
power_sample_overload_wait *= 2; uSecs > POWER_SAMPLE_OFF_DELAY) {
// Overload has existed longer than delay (typ. 10ms)
setPower(POWERMODE::OVERLOAD);
if (overloadNow) {
// the setPower just turned off, so overload is now gone
// DIAG(F("OVERLOAD PON OFF"));
overloadNow=false;
lastPowerChange = micros();
}
unsigned int mA=raw2mA(lastCurrent);
unsigned int maxmA=raw2mA(tripValue);
DIAG(F("TRACK %c POWER OVERLOAD %dmA (limit %dmA) shutdown after %lus for %lus"),
trackno + 'A', mA, maxmA, uSecs, power_sample_overload_wait);
}
} }
break; break;
case POWERMODE::OVERLOAD: case POWERMODE::OVERLOAD:
// Try setting it back on after the OVERLOAD_WAIT if (overloadNow) {
// state overload mode means power is off, turn off overload condition flag as well
// DIAG(F("OVERLOAD POVER OFF"));
overloadNow=false;
lastPowerChange = micros();
}
// Try setting it back on after the OVERLOAD_WAIT
if (microsSinceLastPowerChange() > power_sample_overload_wait) {
// adjust next wait time
power_sample_overload_wait *= 2;
if (power_sample_overload_wait > POWER_SAMPLE_RETRY_MAX)
power_sample_overload_wait = POWER_SAMPLE_RETRY_MAX;
// power on test
setPower(POWERMODE::ON); setPower(POWERMODE::ON);
sampleDelay = POWER_SAMPLE_ON_WAIT; // here we change power but not the overloadNow as that was
// Debug code.... // already changed to false when we entered POWERMODE::OVERLOAD
DIAG(F("TRACK %c POWER RESTORE (check %dms)"), trackno + 'A', sampleDelay); // so we need to set the lastPowerChange anyway.
break; lastPowerChange = micros();
default: DIAG(F("TRACK %c POWER RESTORE (was off %lus)"), trackno + 'A', power_sample_overload_wait);
sampleDelay = 999; // cant get here..meaningless statement to avoid compiler warning. }
break;
default:
break;
} }
} }

31
MotorDriver.h
View File

@ -186,6 +186,16 @@ class MotorDriver {
inline void setTrackLetter(char c) { inline void setTrackLetter(char c) {
trackLetter = c; trackLetter = c;
}; };
// this returns how much time has passed since the last power change. If it
// was really long ago (approx > 52min) advance counter approx 35 min so that
// we are at 18 minutes again. Times for 32 bit unsigned long.
inline unsigned long microsSinceLastPowerChange() {
unsigned long now = micros();
unsigned long diff = now - lastPowerChange;
if (diff > (1UL << (7 *sizeof(unsigned long)))) // 2^(4*7)us = 268.4 seconds
lastPowerChange = now - 30000000UL; // 30 seconds ago
return diff;
};
#ifdef ANALOG_READ_INTERRUPT #ifdef ANALOG_READ_INTERRUPT
bool sampleCurrentFromHW(); bool sampleCurrentFromHW();
void startCurrentFromHW(); void startCurrentFromHW();
@ -217,8 +227,8 @@ class MotorDriver {
int rawCurrentTripValue; int rawCurrentTripValue;
// current sampling // current sampling
POWERMODE powerMode; POWERMODE powerMode;
unsigned long lastSampleTaken; bool overloadNow = false;
unsigned int sampleDelay; unsigned long lastPowerChange; // timestamp in microseconds
int progTripValue; int progTripValue;
int lastCurrent; int lastCurrent;
#ifdef ANALOG_READ_INTERRUPT #ifdef ANALOG_READ_INTERRUPT
@ -228,10 +238,19 @@ class MotorDriver {
int maxmA; int maxmA;
int tripmA; int tripmA;
// Wait times for power management. Unit: milliseconds // Times for overload management. Unit: microseconds.
static const int POWER_SAMPLE_ON_WAIT = 100; // Base for wait time until power is turned on again
static const int POWER_SAMPLE_OFF_WAIT = 1000; static const unsigned long POWER_SAMPLE_OVERLOAD_WAIT = 100UL;
static const int POWER_SAMPLE_OVERLOAD_WAIT = 20; // Time after we consider all faults old and forgotten
static const unsigned long POWER_SAMPLE_ALL_GOOD = 5000000UL;
// How long to ignore fault pin if current is under limit
static const unsigned long POWER_SAMPLE_IGNORE_FAULT_LOW = 50000UL;
// How long to ignore fault pin if current is higher than limit
static const unsigned long POWER_SAMPLE_IGNORE_FAULT_HIGH = 5000UL;
// How long to wait between overcurrent and turning off
static const unsigned long POWER_SAMPLE_OFF_DELAY = 10000UL;
// Upper limit for retry period
static const unsigned long POWER_SAMPLE_RETRY_MAX = 10000000UL;
// Trip current for programming track, 250mA. Change only if you really // Trip current for programming track, 250mA. Change only if you really
// need to be non-NMRA-compliant because of decoders that are not either. // need to be non-NMRA-compliant because of decoders that are not either.