Michal
/
Prusa-Firmware-MMU
mirror of https://github.com/prusa3d/Prusa-Firmware-MMU
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove handling of left+right buttons in error states 

Based on long-term test experience - saves some code + prevents the user from entering hard-to-understand states.
Only Retry remains as the one and only way of recovering from errors.
pull/258/head
D.R.racer 2022-11-09 18:00:28 +01:00 committed by DRracer
parent 2b5a129c7d
commit 75a0ebaf0e
7 changed files with 226 additions and 340 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/logic/load_filament.cpp
View File

@ -121,9 +121,6 @@ bool LoadFilament::StepInner() {
// waiting for user buttons and/or a command from the printer // waiting for user buttons and/or a command from the printer
mui::Event ev = mui::userInput.ConsumeEvent(); mui::Event ev = mui::userInput.ConsumeEvent();
switch (ev) { switch (ev) {
case mui::Event::Left: // try to manually load just a tiny bit - help the filament with the pulley
GoToErrEngagingIdler();
break;
case mui::Event::Middle: // try again the whole sequence case mui::Event::Middle: // try again the whole sequence
// however it depends on the state of FINDA - if it is on, we must perform unload first // however it depends on the state of FINDA - if it is on, we must perform unload first
if (!mf::finda.Pressed()) { if (!mf::finda.Pressed()) {
@ -132,40 +129,11 @@ bool LoadFilament::StepInner() {
GoToRetractingFromFinda(); GoToRetractingFromFinda();
} }
break; break;
case mui::Event::Right: // problem resolved - the user pushed the fillament by hand?
// we should check the state of all the sensors and either report another error or confirm the correct state
// First invalidate homing flags as the user may have moved the Idler or Selector accidentally
InvalidateHoming();
if (!mf::finda.Pressed()) {
// FINDA is still NOT pressed - that smells bad
error = ErrorCode::FINDA_DIDNT_SWITCH_ON;
state = ProgressCode::ERRWaitingForUser; // stand still
} else {
// all sensors are ok - pull the filament back
GoToRetractingFromFinda();
}
break;
default: // no event, continue waiting for user input default: // no event, continue waiting for user input
break; break;
} }
return false; return false;
} }
case ProgressCode::ERREngagingIdler:
if (mi::idler.Engaged()) {
state = ProgressCode::ERRHelpingFilament;
mpu::pulley.PlanMove(config::pulleyHelperMove, config::pulleySlowFeedrate);
}
return false;
case ProgressCode::ERRHelpingFilament:
if (mf::finda.Pressed()) {
// the help was enough to press the FINDA, we are ok, continue normally
GoToRetractingFromFinda();
} else if (mm::motion.QueueEmpty()) {
// helped a bit, but FINDA didn't trigger, return to the main error state
GoToErrDisengagingIdler(ErrorCode::FINDA_DIDNT_SWITCH_ON);
}
return false;
default: // we got into an unhandled state, better report it default: // we got into an unhandled state, better report it
state = ProgressCode::ERRInternal; state = ProgressCode::ERRInternal;
error = ErrorCode::INTERNAL; error = ErrorCode::INTERNAL;

4
src/logic/progress_codes.h
View File

@ -19,10 +19,10 @@ enum class ProgressCode : uint_fast8_t {
FinishingMoves, // P9 FinishingMoves, // P9
ERRDisengagingIdler, // P10 ERRDisengagingIdler, // P10
ERREngagingIdler, // P11 ERREngagingIdler, // P11 - unused: intended for SlowLoad which is removed now
ERRWaitingForUser, // P12 ERRWaitingForUser, // P12
ERRInternal, // P13 ERRInternal, // P13
ERRHelpingFilament, // P14 ERRHelpingFilament, // P14 - unused: intended for SlowLoad which is removed now
ERRTMCFailed, // P15 ERRTMCFailed, // P15
UnloadingFilament, // P16 UnloadingFilament, // P16

45
src/logic/tool_change.cpp
View File

@ -121,9 +121,6 @@ bool ToolChange::StepInner() {
// waiting for user buttons and/or a command from the printer // waiting for user buttons and/or a command from the printer
mui::Event ev = mui::userInput.ConsumeEvent(); mui::Event ev = mui::userInput.ConsumeEvent();
switch (ev) { switch (ev) {
case mui::Event::Left: // try to manually load just a tiny bit - help the filament with the pulley
GoToErrEngagingIdler();
break;
case mui::Event::Middle: // try again the whole sequence case mui::Event::Middle: // try again the whole sequence
// It looks like we don't have to reset the whole state machine but jump straight into the feeding phase. // It looks like we don't have to reset the whole state machine but jump straight into the feeding phase.
// The reasons are multiple: // The reasons are multiple:
@ -165,53 +162,11 @@ bool ToolChange::StepInner() {
} }
} }
break; break;
case mui::Event::Right: // problem resolved - the user pushed the fillament by hand?
// we should check the state of all the sensors and either report another error or confirm the correct state
// First invalidate homing flags as the user may have moved the Idler or Selector accidentally
InvalidateHoming();
if (!mf::finda.Pressed()) {
// FINDA is still NOT pressed - that smells bad
error = ErrorCode::FINDA_DIDNT_SWITCH_ON;
state = ProgressCode::ERRWaitingForUser; // stand still
} else if (!mfs::fsensor.Pressed()) {
// printer's filament sensor is still NOT pressed - that smells bad
mg::globals.SetFilamentLoaded(plannedSlot, mg::FilamentLoadState::InSelector); // only assume the filament is in selector
error = ErrorCode::FSENSOR_DIDNT_SWITCH_ON;
state = ProgressCode::ERRWaitingForUser; // stand still - we may even try loading the filament into the nozzle
} else {
// all sensors are ok, we assume the user pushed the filament into the nozzle
mg::globals.SetFilamentLoaded(plannedSlot, mg::FilamentLoadState::InNozzle);
ToolChangeFinishedCorrectly();
}
break;
default: // no event, continue waiting for user input default: // no event, continue waiting for user input
break; break;
} }
return false; return false;
} }
case ProgressCode::ERREngagingIdler:
if (mi::idler.Engaged()) {
state = ProgressCode::ERRHelpingFilament;
mpu::pulley.PlanMove(config::pulleyHelperMove, config::pulleySlowFeedrate);
}
return false;
case ProgressCode::ERRHelpingFilament:
// @@TODO helping filament needs improvement - the filament should try to move forward as long as the button is pressed
if (mf::finda.Pressed()) {
// the help was enough to press the FINDA, we are ok, continue normally
GoToFeedingToBondtech();
} else if (mfs::fsensor.Pressed()) {
// the help was enough to press the filament sensor, we are ok, continue normally
GoToFeedingToBondtech();
// Beware, when the fsensor triggers, we still need to push the filament into the nozzle/gears
// which requires restarting James from its last stage
james.GoToPushToNozzle();
} else if (mm::motion.QueueEmpty()) {
// helped a bit, but FINDA/Fsensor didn't trigger, return to the main error state
GoToErrDisengagingIdler(ErrorCode::FSENSOR_DIDNT_SWITCH_ON);
}
return false;
default: // we got into an unhandled state, better report it default: // we got into an unhandled state, better report it
state = ProgressCode::ERRInternal; state = ProgressCode::ERRInternal;
error = ErrorCode::INTERNAL; error = ErrorCode::INTERNAL;

37
src/logic/unload_filament.cpp
View File

@ -93,9 +93,6 @@ bool UnloadFilament::StepInner() {
// waiting for user buttons and/or a command from the printer // waiting for user buttons and/or a command from the printer
mui::Event ev = mui::userInput.ConsumeEvent(); mui::Event ev = mui::userInput.ConsumeEvent();
switch (ev) { switch (ev) {
case mui::Event::Left: // try to manually unload just a tiny bit - help the filament with the pulley
GoToErrEngagingIdler();
break;
case mui::Event::Middle: // try again the whole sequence case mui::Event::Middle: // try again the whole sequence
// First invalidate homing flags as the user may have moved the Idler or Selector accidentally // First invalidate homing flags as the user may have moved the Idler or Selector accidentally
InvalidateHoming(); InvalidateHoming();
@ -110,45 +107,11 @@ bool UnloadFilament::StepInner() {
GoToRecheckFilamentAgainstFINDA(); GoToRecheckFilamentAgainstFINDA();
} }
break; break;
case mui::Event::Right: // problem resolved - the user pulled the fillament by hand
// we should check the state of all the sensors and either report another error or confirm the correct state
// First invalidate homing flags as the user may have moved the Idler or Selector accidentally
InvalidateHoming();
if (mfs::fsensor.Pressed()) {
// printer's filament sensor is still pressed - that smells bad
error = ErrorCode::FSENSOR_DIDNT_SWITCH_OFF;
state = ProgressCode::ERRWaitingForUser; // stand still
} else if (mf::finda.Pressed()) {
// FINDA is still pressed - that smells bad
error = ErrorCode::FINDA_DIDNT_SWITCH_OFF;
state = ProgressCode::ERRWaitingForUser; // stand still
} else {
// all sensors are ok, but re-check the position of the filament against FINDA
GoToRecheckFilamentAgainstFINDA();
}
break;
default: default:
break; break;
} }
return false; return false;
} }
case ProgressCode::ERREngagingIdler:
if (mi::idler.Engaged()) {
state = ProgressCode::ERRHelpingFilament;
mpu::pulley.PlanMove(-config::pulleyHelperMove, config::pulleySlowFeedrate);
}
return false;
case ProgressCode::ERRHelpingFilament:
if (!mf::finda.Pressed()) {
// the help was enough to depress the FINDA, we are ok, continue normally
state = ProgressCode::DisengagingIdler;
error = ErrorCode::RUNNING;
} else if (mm::motion.QueueEmpty()) {
// helped a bit, but FINDA didn't trigger, return to the main error state
GoToErrDisengagingIdler(ErrorCode::FINDA_DIDNT_SWITCH_OFF);
}
return false;
case ProgressCode::FeedingToFinda: case ProgressCode::FeedingToFinda:
// recovery mode - we assume the filament is somewhere between the idle position and FINDA - thus blocking the selector // recovery mode - we assume the filament is somewhere between the idle position and FINDA - thus blocking the selector
if (feed.Step()) { if (feed.Step()) {

120
tests/unit/logic/load_filament/test_load_filament.cpp
View File

@ -122,50 +122,50 @@ void FailedLoadToFinda(uint8_t slot, logic::LoadFilament &lf) {
REQUIRE(VerifyState(lf, mg::FilamentLoadState::InSelector, mi::Idler::IdleSlotIndex(), slot, false, false, ml::off, ml::blink0, ErrorCode::FINDA_DIDNT_SWITCH_ON, ProgressCode::ERRWaitingForUser)); REQUIRE(VerifyState(lf, mg::FilamentLoadState::InSelector, mi::Idler::IdleSlotIndex(), slot, false, false, ml::off, ml::blink0, ErrorCode::FINDA_DIDNT_SWITCH_ON, ProgressCode::ERRWaitingForUser));
} }
void FailedLoadToFindaResolveHelp(uint8_t slot, logic::LoadFilament &lf) { //void FailedLoadToFindaResolveHelp(uint8_t slot, logic::LoadFilament &lf) {
// Stage 3 - the user has to do something // // Stage 3 - the user has to do something
// there are 3 options: // // there are 3 options:
// - help the filament a bit // // - help the filament a bit
// - try again the whole sequence // // - try again the whole sequence
// - resolve the problem by hand - after pressing the button we shall check, that FINDA is off and we should do what? // // - resolve the problem by hand - after pressing the button we shall check, that FINDA is off and we should do what?
// In this case we check the first option // // In this case we check the first option
PressButtonAndDebounce(lf, mb::Left, false); // PressButtonAndDebounce(lf, mb::Left, false);
REQUIRE(VerifyState(lf, mg::FilamentLoadState::InSelector, mi::Idler::IdleSlotIndex(), slot, false, false, ml::off, ml::blink0, ErrorCode::RUNNING, ProgressCode::ERREngagingIdler)); // REQUIRE(VerifyState(lf, mg::FilamentLoadState::InSelector, mi::Idler::IdleSlotIndex(), slot, false, false, ml::off, ml::blink0, ErrorCode::RUNNING, ProgressCode::ERREngagingIdler));
if (!mi::idler.HomingValid()) { // if (!mi::idler.HomingValid()) {
SimulateIdlerHoming(lf); // SimulateIdlerHoming(lf);
} // }
// Stage 4 - engage the idler // // Stage 4 - engage the idler
REQUIRE(WhileTopState(lf, ProgressCode::ERREngagingIdler, idlerEngageDisengageMaxSteps)); // REQUIRE(WhileTopState(lf, ProgressCode::ERREngagingIdler, idlerEngageDisengageMaxSteps));
REQUIRE(VerifyState(lf, mg::FilamentLoadState::InSelector, slot, slot, false, true, ml::off, ml::blink0, ErrorCode::RUNNING, ProgressCode::ERRHelpingFilament)); // REQUIRE(VerifyState(lf, mg::FilamentLoadState::InSelector, slot, slot, false, true, ml::off, ml::blink0, ErrorCode::RUNNING, ProgressCode::ERRHelpingFilament));
ClearButtons(lf); // ClearButtons(lf);
} //}
void FailedLoadToFindaResolveHelpFindaTriggered(uint8_t slot, logic::LoadFilament &lf) { //void FailedLoadToFindaResolveHelpFindaTriggered(uint8_t slot, logic::LoadFilament &lf) {
// Stage 5 - move the pulley a bit - simulate FINDA depress // // Stage 5 - move the pulley a bit - simulate FINDA depress
REQUIRE(WhileCondition( // REQUIRE(WhileCondition(
lf, // lf,
[&](uint32_t step) -> bool { // [&](uint32_t step) -> bool {
if(step == 100){ // on 100th step make FINDA trigger // if(step == 100){ // on 100th step make FINDA trigger
hal::gpio::WritePin(FINDA_PIN, hal::gpio::Level::high); // hal::gpio::WritePin(FINDA_PIN, hal::gpio::Level::high);
} // }
return lf.TopLevelState() == ProgressCode::ERRHelpingFilament; }, // return lf.TopLevelState() == ProgressCode::ERRHelpingFilament; },
5000)); // 5000));
REQUIRE(VerifyState(lf, mg::FilamentLoadState::InSelector, slot, slot, true, true, ml::blink0, ml::off, ErrorCode::RUNNING, ProgressCode::RetractingFromFinda)); // REQUIRE(VerifyState(lf, mg::FilamentLoadState::InSelector, slot, slot, true, true, ml::blink0, ml::off, ErrorCode::RUNNING, ProgressCode::RetractingFromFinda));
} //}
void FailedLoadToFindaResolveHelpFindaDidntTrigger(uint8_t slot, logic::LoadFilament &lf) { //void FailedLoadToFindaResolveHelpFindaDidntTrigger(uint8_t slot, logic::LoadFilament &lf) {
// Stage 5 - move the pulley a bit - no FINDA change // // Stage 5 - move the pulley a bit - no FINDA change
REQUIRE(WhileTopState(lf, ProgressCode::ERRHelpingFilament, 5000)); // REQUIRE(WhileTopState(lf, ProgressCode::ERRHelpingFilament, 5000));
REQUIRE(VerifyState(lf, mg::FilamentLoadState::InSelector, slot, slot, false, true, ml::off, ml::blink0, ErrorCode::RUNNING, ProgressCode::ERRDisengagingIdler)); // REQUIRE(VerifyState(lf, mg::FilamentLoadState::InSelector, slot, slot, false, true, ml::off, ml::blink0, ErrorCode::RUNNING, ProgressCode::ERRDisengagingIdler));
} //}
void FailedLoadToFindaResolveManual(uint8_t slot, logic::LoadFilament &lf) { void FailedLoadToFindaResolveManual(uint8_t slot, logic::LoadFilament &lf) {
// simulate the user fixed the issue himself // simulate the user fixed the issue himself
@ -240,25 +240,25 @@ void FailedLoadToFindaResolveTryAgain(uint8_t slot, logic::LoadFilament &lf) {
LoadFilamentSuccessfulWithRehomeSelector(slot, lf); LoadFilamentSuccessfulWithRehomeSelector(slot, lf);
} }
TEST_CASE("load_filament::failed_load_to_finda_0-4_resolve_help_second_ok", "[load_filament]") { //TEST_CASE("load_filament::failed_load_to_finda_0-4_resolve_help_second_ok", "[load_filament]") {
for (uint8_t slot = 0; slot < config::toolCount; ++slot) { // for (uint8_t slot = 0; slot < config::toolCount; ++slot) {
logic::LoadFilament lf; // logic::LoadFilament lf;
LoadFilamentCommonSetup(slot, lf, true); // LoadFilamentCommonSetup(slot, lf, true);
FailedLoadToFinda(slot, lf); // FailedLoadToFinda(slot, lf);
FailedLoadToFindaResolveHelp(slot, lf); // FailedLoadToFindaResolveHelp(slot, lf);
FailedLoadToFindaResolveHelpFindaTriggered(slot, lf); // FailedLoadToFindaResolveHelpFindaTriggered(slot, lf);
} // }
} //}
TEST_CASE("load_filament::failed_load_to_finda_0-4_resolve_help_second_fail", "[load_filament]") { //TEST_CASE("load_filament::failed_load_to_finda_0-4_resolve_help_second_fail", "[load_filament]") {
for (uint8_t slot = 0; slot < config::toolCount; ++slot) { // for (uint8_t slot = 0; slot < config::toolCount; ++slot) {
logic::LoadFilament lf; // logic::LoadFilament lf;
LoadFilamentCommonSetup(slot, lf, true); // LoadFilamentCommonSetup(slot, lf, true);
FailedLoadToFinda(slot, lf); // FailedLoadToFinda(slot, lf);
FailedLoadToFindaResolveHelp(slot, lf); // FailedLoadToFindaResolveHelp(slot, lf);
FailedLoadToFindaResolveHelpFindaDidntTrigger(slot, lf); // FailedLoadToFindaResolveHelpFindaDidntTrigger(slot, lf);
} // }
} //}
TEST_CASE("load_filament::invalid_slot", "[load_filament]") { TEST_CASE("load_filament::invalid_slot", "[load_filament]") {
for (uint8_t activeSlot = 0; activeSlot < config::toolCount; ++activeSlot) { for (uint8_t activeSlot = 0; activeSlot < config::toolCount; ++activeSlot) {
@ -283,14 +283,14 @@ TEST_CASE("load_filament::state_machine_reusal", "[load_filament]") {
} }
} }
TEST_CASE("load_filament::failed_load_to_finda_0-4_resolve_manual", "[load_filament]") { //TEST_CASE("load_filament::failed_load_to_finda_0-4_resolve_manual", "[load_filament]") {
for (uint8_t slot = 0; slot < config::toolCount; ++slot) { // for (uint8_t slot = 0; slot < config::toolCount; ++slot) {
logic::LoadFilament lf; // logic::LoadFilament lf;
LoadFilamentCommonSetup(slot, lf, true); // LoadFilamentCommonSetup(slot, lf, true);
FailedLoadToFinda(slot, lf); // FailedLoadToFinda(slot, lf);
FailedLoadToFindaResolveManual(slot, lf); // FailedLoadToFindaResolveManual(slot, lf);
} // }
} //}
TEST_CASE("load_filament::failed_load_to_finda_0-4_resolve_manual_no_FINDA", "[load_filament]") { TEST_CASE("load_filament::failed_load_to_finda_0-4_resolve_manual_no_FINDA", "[load_filament]") {
for (uint8_t slot = 0; slot < config::toolCount; ++slot) { for (uint8_t slot = 0; slot < config::toolCount; ++slot) {

106
tests/unit/logic/tool_change/test_tool_change.cpp
View File

@ -212,32 +212,32 @@ void ToolChangeFailLoadToFinda(logic::ToolChange &tc, uint8_t fromSlot, uint8_t
SimulateErrDisengagingIdler(tc, ErrorCode::FINDA_DIDNT_SWITCH_ON); SimulateErrDisengagingIdler(tc, ErrorCode::FINDA_DIDNT_SWITCH_ON);
} }
void ToolChangeFailLoadToFindaLeftBtn(logic::ToolChange &tc, uint8_t toSlot) { //void ToolChangeFailLoadToFindaLeftBtn(logic::ToolChange &tc, uint8_t toSlot) {
// now waiting for user input // // now waiting for user input
REQUIRE_FALSE(mui::userInput.AnyEvent()); // REQUIRE_FALSE(mui::userInput.AnyEvent());
PressButtonAndDebounce(tc, mb::Left, true); // PressButtonAndDebounce(tc, mb::Left, true);
REQUIRE(WhileTopState(tc, ProgressCode::ERREngagingIdler, 5000UL)); // REQUIRE(WhileTopState(tc, ProgressCode::ERREngagingIdler, 5000UL));
ClearButtons(tc); // ClearButtons(tc);
REQUIRE(VerifyState(tc, mg::FilamentLoadState::InSelector, toSlot, toSlot, false, true, ml::off, ml::blink0, ErrorCode::RUNNING, ProgressCode::ERRHelpingFilament)); // REQUIRE(VerifyState(tc, mg::FilamentLoadState::InSelector, toSlot, toSlot, false, true, ml::off, ml::blink0, ErrorCode::RUNNING, ProgressCode::ERRHelpingFilament));
// try push more, if FINDA triggers, continue loading // // try push more, if FINDA triggers, continue loading
REQUIRE(WhileCondition( // REQUIRE(WhileCondition(
tc, // tc,
[&](uint32_t step) -> bool { // [&](uint32_t step) -> bool {
if(step == 20){ // on 20th step make FINDA trigger // if(step == 20){ // on 20th step make FINDA trigger
hal::gpio::WritePin(FINDA_PIN, hal::gpio::Level::high); // hal::gpio::WritePin(FINDA_PIN, hal::gpio::Level::high);
} // }
return tc.TopLevelState() == ProgressCode::ERRHelpingFilament; }, // return tc.TopLevelState() == ProgressCode::ERRHelpingFilament; },
2000UL)); // 2000UL));
REQUIRE(VerifyState(tc, mg::FilamentLoadState::InSelector, toSlot, toSlot, true, true, ml::blink0, ml::off, ErrorCode::RUNNING, ProgressCode::FeedingToBondtech)); // REQUIRE(VerifyState(tc, mg::FilamentLoadState::InSelector, toSlot, toSlot, true, true, ml::blink0, ml::off, ErrorCode::RUNNING, ProgressCode::FeedingToBondtech));
FeedingToBondtech(tc, toSlot); // FeedingToBondtech(tc, toSlot);
CheckFinishedCorrectly(tc, toSlot); // CheckFinishedCorrectly(tc, toSlot);
} //}
void ToolChangeFailLoadToFindaMiddleBtn(logic::ToolChange &tc, uint8_t toSlot) { void ToolChangeFailLoadToFindaMiddleBtn(logic::ToolChange &tc, uint8_t toSlot) {
// now waiting for user input // now waiting for user input
@ -313,17 +313,17 @@ void ToolChangeFailLoadToFindaRightBtn(logic::ToolChange &tc, uint8_t toSlot) {
ClearButtons(tc); ClearButtons(tc);
} }
TEST_CASE("tool_change::load_fail_FINDA_resolve_btnL", "[tool_change]") { //TEST_CASE("tool_change::load_fail_FINDA_resolve_btnL", "[tool_change]") {
logic::ToolChange tc; // logic::ToolChange tc;
for (uint8_t fromSlot = 0; fromSlot < config::toolCount; ++fromSlot) { // for (uint8_t fromSlot = 0; fromSlot < config::toolCount; ++fromSlot) {
for (uint8_t toSlot = 0; toSlot < config::toolCount; ++toSlot) { // for (uint8_t toSlot = 0; toSlot < config::toolCount; ++toSlot) {
if (fromSlot != toSlot) { // if (fromSlot != toSlot) {
ToolChangeFailLoadToFinda(tc, fromSlot, toSlot); // ToolChangeFailLoadToFinda(tc, fromSlot, toSlot);
ToolChangeFailLoadToFindaLeftBtn(tc, toSlot); // ToolChangeFailLoadToFindaLeftBtn(tc, toSlot);
} // }
} // }
} // }
} //}
TEST_CASE("tool_change::load_fail_FINDA_resolve_btnM", "[tool_change]") { TEST_CASE("tool_change::load_fail_FINDA_resolve_btnM", "[tool_change]") {
logic::ToolChange tc; logic::ToolChange tc;
@ -337,29 +337,29 @@ TEST_CASE("tool_change::load_fail_FINDA_resolve_btnM", "[tool_change]") {
} }
} }
TEST_CASE("tool_change::load_fail_FINDA_resolve_btnR_FINDA_FSensor", "[tool_change]") { //TEST_CASE("tool_change::load_fail_FINDA_resolve_btnR_FINDA_FSensor", "[tool_change]") {
logic::ToolChange tc; // logic::ToolChange tc;
for (uint8_t fromSlot = 0; fromSlot < config::toolCount; ++fromSlot) { // for (uint8_t fromSlot = 0; fromSlot < config::toolCount; ++fromSlot) {
for (uint8_t toSlot = 0; toSlot < config::toolCount; ++toSlot) { // for (uint8_t toSlot = 0; toSlot < config::toolCount; ++toSlot) {
if (fromSlot != toSlot) { // if (fromSlot != toSlot) {
ToolChangeFailLoadToFinda(tc, fromSlot, toSlot); // ToolChangeFailLoadToFinda(tc, fromSlot, toSlot);
ToolChangeFailLoadToFindaRightBtnFINDA_FSensor(tc, toSlot); // ToolChangeFailLoadToFindaRightBtnFINDA_FSensor(tc, toSlot);
} // }
} // }
} // }
} //}
TEST_CASE("tool_change::load_fail_FINDA_resolve_btnR_FINDA", "[tool_change]") { //TEST_CASE("tool_change::load_fail_FINDA_resolve_btnR_FINDA", "[tool_change]") {
logic::ToolChange tc; // logic::ToolChange tc;
for (uint8_t fromSlot = 0; fromSlot < config::toolCount; ++fromSlot) { // for (uint8_t fromSlot = 0; fromSlot < config::toolCount; ++fromSlot) {
for (uint8_t toSlot = 0; toSlot < config::toolCount; ++toSlot) { // for (uint8_t toSlot = 0; toSlot < config::toolCount; ++toSlot) {
if (fromSlot != toSlot) { // if (fromSlot != toSlot) {
ToolChangeFailLoadToFinda(tc, fromSlot, toSlot); // ToolChangeFailLoadToFinda(tc, fromSlot, toSlot);
ToolChangeFailLoadToFindaRightBtnFINDA(tc, toSlot); // ToolChangeFailLoadToFindaRightBtnFINDA(tc, toSlot);
} // }
} // }
} // }
} //}
void ToolChangeFailFSensor(logic::ToolChange &tc, uint8_t fromSlot, uint8_t toSlot) { void ToolChangeFailFSensor(logic::ToolChange &tc, uint8_t fromSlot, uint8_t toSlot) {
using namespace std::placeholders; using namespace std::placeholders;

222
tests/unit/logic/unload_filament/test_unload_filament.cpp
View File

@ -164,92 +164,92 @@ void FindaDidntTriggerCommonSetup(uint8_t slot, logic::UnloadFilament &uf) {
REQUIRE(VerifyState(uf, mg::FilamentLoadState::InSelector, mi::Idler::IdleSlotIndex(), slot, true, false, ml::off, ml::blink0, ErrorCode::FINDA_DIDNT_SWITCH_OFF, ProgressCode::ERRWaitingForUser)); REQUIRE(VerifyState(uf, mg::FilamentLoadState::InSelector, mi::Idler::IdleSlotIndex(), slot, true, false, ml::off, ml::blink0, ErrorCode::FINDA_DIDNT_SWITCH_OFF, ProgressCode::ERRWaitingForUser));
} }
void FindaDidntTriggerResolveHelp(uint8_t slot, logic::UnloadFilament &uf) { //void FindaDidntTriggerResolveHelp(uint8_t slot, logic::UnloadFilament &uf) {
// Stage 3 - the user has to do something // // Stage 3 - the user has to do something
// there are 3 options: // // there are 3 options:
// - help the filament a bit // // - help the filament a bit
// - try again the whole sequence // // - try again the whole sequence
// - resolve the problem by hand - after pressing the button we shall check, that FINDA is off and we should do what? // // - resolve the problem by hand - after pressing the button we shall check, that FINDA is off and we should do what?
// In this case we check the first option // // In this case we check the first option
REQUIRE_FALSE(mui::userInput.AnyEvent()); // REQUIRE_FALSE(mui::userInput.AnyEvent());
// Perform press on button 0 + debounce // // Perform press on button 0 + debounce
PressButtonAndDebounce(uf, mb::Left, false); // PressButtonAndDebounce(uf, mb::Left, false);
REQUIRE_FALSE(mui::userInput.AnyEvent()); // button processed and nothing remains // REQUIRE_FALSE(mui::userInput.AnyEvent()); // button processed and nothing remains
// we still think we have filament loaded at this stage // // we still think we have filament loaded at this stage
// idler should have been disengaged // // idler should have been disengaged
// no change in selector's position // // no change in selector's position
// FINDA still on // // FINDA still on
// red LED should blink, green LED should be off // // red LED should blink, green LED should be off
REQUIRE(VerifyState(uf, mg::FilamentLoadState::InSelector, mi::Idler::IdleSlotIndex(), slot, true, false, ml::off, ml::blink0, ErrorCode::RUNNING, ProgressCode::ERREngagingIdler)); // REQUIRE(VerifyState(uf, mg::FilamentLoadState::InSelector, mi::Idler::IdleSlotIndex(), slot, true, false, ml::off, ml::blink0, ErrorCode::RUNNING, ProgressCode::ERREngagingIdler));
if (!mi::idler.HomingValid()) { // if (!mi::idler.HomingValid()) {
SimulateIdlerHoming(uf); // SimulateIdlerHoming(uf);
} // }
// Stage 4 - engage the idler // // Stage 4 - engage the idler
REQUIRE(WhileTopState(uf, ProgressCode::ERREngagingIdler, idlerEngageDisengageMaxSteps)); // REQUIRE(WhileTopState(uf, ProgressCode::ERREngagingIdler, idlerEngageDisengageMaxSteps));
// we still think we have filament loaded at this stage // // we still think we have filament loaded at this stage
// idler should be engaged // // idler should be engaged
// no change in selector's position // // no change in selector's position
// FINDA still on // // FINDA still on
// red LED should blink, green LED should be off // // red LED should blink, green LED should be off
REQUIRE(VerifyState(uf, mg::FilamentLoadState::InSelector, slot, slot, true, true, ml::off, ml::blink0, ErrorCode::RUNNING, ProgressCode::ERRHelpingFilament)); // REQUIRE(VerifyState(uf, mg::FilamentLoadState::InSelector, slot, slot, true, true, ml::off, ml::blink0, ErrorCode::RUNNING, ProgressCode::ERRHelpingFilament));
} //}
void FindaDidntTriggerResolveHelpFindaTriggered(uint8_t slot, logic::UnloadFilament &uf) { //void FindaDidntTriggerResolveHelpFindaTriggered(uint8_t slot, logic::UnloadFilament &uf) {
// Stage 5 - move the pulley a bit - simulate FINDA depress // // Stage 5 - move the pulley a bit - simulate FINDA depress
REQUIRE(WhileCondition( // REQUIRE(WhileCondition(
uf, // uf,
[&](uint32_t step) -> bool { // [&](uint32_t step) -> bool {
if(step == 100){ // on 100th step make FINDA trigger // if(step == 100){ // on 100th step make FINDA trigger
hal::gpio::WritePin(FINDA_PIN, hal::gpio::Level::low); // hal::gpio::WritePin(FINDA_PIN, hal::gpio::Level::low);
} // }
return uf.TopLevelState() == ProgressCode::ERRHelpingFilament; }, // return uf.TopLevelState() == ProgressCode::ERRHelpingFilament; },
5000)); // 5000));
// we still think we have filament loaded at this stage // // we still think we have filament loaded at this stage
// idler should be engaged // // idler should be engaged
// no change in selector's position // // no change in selector's position
// FINDA depressed // // FINDA depressed
// red LED should blink, green LED should be off // // red LED should blink, green LED should be off
REQUIRE(VerifyState(uf, mg::FilamentLoadState::InSelector, slot, slot, false, true, ml::off, ml::blink0, ErrorCode::RUNNING, ProgressCode::DisengagingIdler)); // REQUIRE(VerifyState(uf, mg::FilamentLoadState::InSelector, slot, slot, false, true, ml::off, ml::blink0, ErrorCode::RUNNING, ProgressCode::DisengagingIdler));
} //}
void FindaDidntTriggerResolveHelpFindaDidntTrigger(uint8_t slot, logic::UnloadFilament &uf) { //void FindaDidntTriggerResolveHelpFindaDidntTrigger(uint8_t slot, logic::UnloadFilament &uf) {
// Stage 5 - move the pulley a bit - no FINDA change // // Stage 5 - move the pulley a bit - no FINDA change
REQUIRE(WhileTopState(uf, ProgressCode::ERRHelpingFilament, 5000)); // REQUIRE(WhileTopState(uf, ProgressCode::ERRHelpingFilament, 5000));
// we still think we have filament loaded at this stage // // we still think we have filament loaded at this stage
// idler should be engaged // // idler should be engaged
// no change in selector's position // // no change in selector's position
// FINDA still pressed // // FINDA still pressed
// red LED should blink, green LED should be off // // red LED should blink, green LED should be off
REQUIRE(VerifyState(uf, mg::FilamentLoadState::InSelector, slot, slot, true, true, ml::off, ml::blink0, ErrorCode::RUNNING, ProgressCode::ERRDisengagingIdler)); // REQUIRE(VerifyState(uf, mg::FilamentLoadState::InSelector, slot, slot, true, true, ml::off, ml::blink0, ErrorCode::RUNNING, ProgressCode::ERRDisengagingIdler));
} //}
TEST_CASE("unload_filament::finda_didnt_trigger_resolve_help_second_ok", "[unload_filament]") { //TEST_CASE("unload_filament::finda_didnt_trigger_resolve_help_second_ok", "[unload_filament]") {
for (uint8_t slot = 0; slot < config::toolCount; ++slot) { // for (uint8_t slot = 0; slot < config::toolCount; ++slot) {
logic::UnloadFilament uf; // logic::UnloadFilament uf;
FindaDidntTriggerCommonSetup(slot, uf); // FindaDidntTriggerCommonSetup(slot, uf);
FindaDidntTriggerResolveHelp(slot, uf); // FindaDidntTriggerResolveHelp(slot, uf);
FindaDidntTriggerResolveHelpFindaTriggered(slot, uf); // FindaDidntTriggerResolveHelpFindaTriggered(slot, uf);
} // }
} //}
TEST_CASE("unload_filament::finda_didnt_trigger_resolve_help_second_fail", "[unload_filament]") { //TEST_CASE("unload_filament::finda_didnt_trigger_resolve_help_second_fail", "[unload_filament]") {
// the same with different end scenario // // the same with different end scenario
for (uint8_t slot = 0; slot < config::toolCount; ++slot) { // for (uint8_t slot = 0; slot < config::toolCount; ++slot) {
logic::UnloadFilament uf; // logic::UnloadFilament uf;
FindaDidntTriggerCommonSetup(slot, uf); // FindaDidntTriggerCommonSetup(slot, uf);
FindaDidntTriggerResolveHelp(slot, uf); // FindaDidntTriggerResolveHelp(slot, uf);
FindaDidntTriggerResolveHelpFindaDidntTrigger(slot, uf); // FindaDidntTriggerResolveHelpFindaDidntTrigger(slot, uf);
} // }
} //}
void FindaDidntTriggerResolveTryAgain(uint8_t slot, logic::UnloadFilament &uf) { void FindaDidntTriggerResolveTryAgain(uint8_t slot, logic::UnloadFilament &uf) {
// Stage 3 - the user has to do something // Stage 3 - the user has to do something
@ -348,13 +348,13 @@ void FailedUnloadResolveManualFSensorOn(uint8_t slot, logic::UnloadFilament &uf)
REQUIRE(VerifyState(uf, mg::FilamentLoadState::InSelector, mi::Idler::IdleSlotIndex(), slot, false, false, ml::off, ml::blink0, ErrorCode::FSENSOR_DIDNT_SWITCH_OFF, ProgressCode::ERRWaitingForUser)); REQUIRE(VerifyState(uf, mg::FilamentLoadState::InSelector, mi::Idler::IdleSlotIndex(), slot, false, false, ml::off, ml::blink0, ErrorCode::FSENSOR_DIDNT_SWITCH_OFF, ProgressCode::ERRWaitingForUser));
} }
TEST_CASE("unload_filament::failed_unload_to_finda_0-4_resolve_manual", "[unload_filament]") { //TEST_CASE("unload_filament::failed_unload_to_finda_0-4_resolve_manual", "[unload_filament]") {
for (uint8_t slot = 0; slot < config::toolCount; ++slot) { // for (uint8_t slot = 0; slot < config::toolCount; ++slot) {
logic::UnloadFilament uf; // logic::UnloadFilament uf;
FindaDidntTriggerCommonSetup(slot, uf); // FindaDidntTriggerCommonSetup(slot, uf);
FailedUnloadResolveManual(slot, uf); // FailedUnloadResolveManual(slot, uf);
} // }
} //}
TEST_CASE("unload_filament::failed_unload_to_finda_0-4_resolve_manual_FINDA_on", "[unload_filament]") { TEST_CASE("unload_filament::failed_unload_to_finda_0-4_resolve_manual_FINDA_on", "[unload_filament]") {
for (uint8_t slot = 0; slot < config::toolCount; ++slot) { for (uint8_t slot = 0; slot < config::toolCount; ++slot) {
@ -364,43 +364,43 @@ TEST_CASE("unload_filament::failed_unload_to_finda_0-4_resolve_manual_FINDA_on",
} }
} }
TEST_CASE("unload_filament::failed_unload_to_finda_0-4_resolve_manual_FSensor_on", "[unload_filament]") { //TEST_CASE("unload_filament::failed_unload_to_finda_0-4_resolve_manual_FSensor_on", "[unload_filament]") {
for (uint8_t slot = 0; slot < config::toolCount; ++slot) { // for (uint8_t slot = 0; slot < config::toolCount; ++slot) {
logic::UnloadFilament uf; // logic::UnloadFilament uf;
FindaDidntTriggerCommonSetup(slot, uf); // FindaDidntTriggerCommonSetup(slot, uf);
FailedUnloadResolveManualFSensorOn(slot, uf); // FailedUnloadResolveManualFSensorOn(slot, uf);
} // }
} //}
TEST_CASE("unload_filament::unload_homing_retry", "[unload_filament][homing]") { //TEST_CASE("unload_filament::unload_homing_retry", "[unload_filament][homing]") {
uint8_t slot = 0; // uint8_t slot = 0;
logic::UnloadFilament uf; // logic::UnloadFilament uf;
FindaDidntTriggerCommonSetup(slot, uf); // FindaDidntTriggerCommonSetup(slot, uf);
// simulate the user fixed the issue himself (not really important, we are after a failed homing of the selector) // // simulate the user fixed the issue himself (not really important, we are after a failed homing of the selector)
hal::gpio::WritePin(FINDA_PIN, hal::gpio::Level::low); // hal::gpio::WritePin(FINDA_PIN, hal::gpio::Level::low);
PressButtonAndDebounce(uf, mb::Right, false); // PressButtonAndDebounce(uf, mb::Right, false);
SimulateIdlerHoming(uf); // make Idler happy // SimulateIdlerHoming(uf); // make Idler happy
REQUIRE(WhileCondition(uf, std::bind(SimulateFeedToFINDA, _1, 100), 5000)); // REQUIRE(WhileCondition(uf, std::bind(SimulateFeedToFINDA, _1, 100), 5000));
REQUIRE(WhileCondition(uf, std::bind(SimulateRetractFromFINDA, _1, 100), 5000)); // REQUIRE(WhileCondition(uf, std::bind(SimulateRetractFromFINDA, _1, 100), 5000));
REQUIRE(WhileCondition( // REQUIRE(WhileCondition(
uf, [&](uint32_t) { return uf.State() == ProgressCode::RetractingFromFinda; }, 50000)); // uf, [&](uint32_t) { return uf.State() == ProgressCode::RetractingFromFinda; }, 50000));
REQUIRE(WhileTopState(uf, ProgressCode::DisengagingIdler, idlerEngageDisengageMaxSteps)); // REQUIRE(WhileTopState(uf, ProgressCode::DisengagingIdler, idlerEngageDisengageMaxSteps));
// now fail homing of the Selector // // now fail homing of the Selector
REQUIRE(SimulateFailedHomeSelectorRepeated(uf)); // REQUIRE(SimulateFailedHomeSelectorRepeated(uf));
// REQUIRE(VerifyState(uf, mg::FilamentLoadState::AtPulley, mi::Idler::IdleSlotIndex(), slot, false, false, ml::blink0, ml::off, ErrorCode::RUNNING, ProgressCode::OK)); // // REQUIRE(VerifyState(uf, mg::FilamentLoadState::AtPulley, mi::Idler::IdleSlotIndex(), slot, false, false, ml::blink0, ml::off, ErrorCode::RUNNING, ProgressCode::OK));
REQUIRE(uf.State() == ProgressCode::Homing); // REQUIRE(uf.State() == ProgressCode::Homing);
REQUIRE(uf.Error() == ErrorCode::RUNNING); // REQUIRE(uf.Error() == ErrorCode::RUNNING);
// one retry // // one retry
REQUIRE(SimulateFailedHomeSelectorRepeated(uf)); // REQUIRE(SimulateFailedHomeSelectorRepeated(uf));
// success // // success
SimulateSelectorHoming(uf); // SimulateSelectorHoming(uf);
REQUIRE(VerifyState(uf, mg::FilamentLoadState::AtPulley, mi::Idler::IdleSlotIndex(), slot, false, false, ml::off, ml::off, ErrorCode::OK, ProgressCode::OK)); // REQUIRE(VerifyState(uf, mg::FilamentLoadState::AtPulley, mi::Idler::IdleSlotIndex(), slot, false, false, ml::off, ml::off, ErrorCode::OK, ProgressCode::OK));
} //}