josh
/
Prusa-Firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Prusa-Firmware/Firmware/mmu2_reporting.cpp

440 lines
15 KiB
C++
Raw Blame History

#include <avr/pgmspace.h>
#include "mmu2.h"
#include "mmu2_log.h"
#include "mmu2_reporting.h"
#include "mmu2_error_converter.h"
#include "mmu2/error_codes.h"
#include "mmu2/buttons.h"
#include "menu.h"
#include "ultralcd.h"
#include "Filament_sensor.h"
#include "language.h"
#include "temperature.h"
#include "sound.h"
namespace MMU2 {
const char * ProgressCodeToText(uint16_t pc); // we may join progress convertor and reporter together
void BeginReport(CommandInProgress /*cip*/, uint16_t ec) {
custom_message_type = CustomMsg::MMUProgress;
lcd_setstatuspgm( _T(ProgressCodeToText(ec)) );
}
void EndReport(CommandInProgress /*cip*/, uint16_t /*ec*/) {
// clear the status msg line - let the printed filename get visible again
if (!printJobOngoing()) {
lcd_setstatuspgm(MSG_WELCOME);
}
custom_message_type = CustomMsg::Status;
}
/**
* @brief Renders any characters that will be updated live on the MMU error screen.
*Currently, this is FINDA and Filament Sensor status and Extruder temperature.
*/
extern void ReportErrorHookDynamicRender(void){
// beware - this optimization abuses the fact, that FindaDetectsFilament returns 0 or 1 and '0' is followed by '1' in the ASCII table
lcd_putc_at(3, 2, mmu2.FindaDetectsFilament() + '0');
lcd_putc_at(8, 2, fsensor.getFilamentPresent() + '0');
// print active/changing filament slot
lcd_set_cursor(10, 2);
lcdui_print_extruder();
// Print active extruder temperature
lcd_set_cursor(16, 2);
lcd_printf_P(PSTR("%3d"), (int)(degHotend(0) + 0.5));
}
/**
* @brief Renders any characters that are static on the MMU error screen i.e. they don't change.
* @param[in] ei Error code index
*/
static void ReportErrorHookStaticRender(uint8_t ei) {
//! Show an error screen
//! When an MMU error occurs, the LCD content will look like this:
//! |01234567890123456789|
//! |MMU FW update needed| <- title/header of the error: max 20 characters
//! |prusa.io/04504 | <- URL max 20 characters
//! |FI:1 FS:1 5>3 t201°| <- status line, t is thermometer symbol
//! |>Retry >Done >W| <- buttons
bool two_choices = false;
// Read and determine what operations should be shown on the menu
const uint8_t button_operation = PrusaErrorButtons(ei);
const uint8_t button_op_right = BUTTON_OP_RIGHT(button_operation);
const uint8_t button_op_middle = BUTTON_OP_MIDDLE(button_operation);
// Check if the menu should have three or two choices
if (button_op_right == (uint8_t)ButtonOperations::NoOperation){
// Two operations not specified, the error menu should only show two choices
two_choices = true;
}
lcd_set_custom_characters_nextpage();
lcd_update_enable(false);
lcd_clear();
// Print title and header
lcd_printf_P(PSTR("%.20S\nprusa.io/04%hu"), _T(PrusaErrorTitle(ei)), PrusaErrorCode(ei) );
ReportErrorHookSensorLineRender();
// Render the choices
lcd_show_choices_prompt_P(two_choices ? LCD_LEFT_BUTTON_CHOICE : LCD_MIDDLE_BUTTON_CHOICE, _T(PrusaErrorButtonTitle(button_op_middle)), two_choices ? PrusaErrorButtonMore() : _T(PrusaErrorButtonTitle(button_op_right)), two_choices ? 18 : 9, two_choices ? nullptr : PrusaErrorButtonMore());
}
void ReportErrorHookSensorLineRender(){
// Render static characters in third line
lcd_puts_at_P(0, 2, PSTR("FI: FS: > " LCD_STR_THERMOMETER " " LCD_STR_DEGREE));
}
/**
* @brief Monitors the LCD button selection without blocking MMU communication
* @param[in] ei Error code index
* @return 0 if there is no knob click --
* 1 if user clicked 'More' and firmware should render
* the error screen when ReportErrorHook is called next --
* 2 if the user selects an operation and we would like
* to exit the error screen. The MMU will raise the menu
* again if the error is not solved.
*/
static uint8_t ReportErrorHookMonitor(uint8_t ei) {
uint8_t ret = 0;
bool two_choices = false;
static uint8_t reset_button_selection;
// Read and determine what operations should be shown on the menu
const uint8_t button_operation = PrusaErrorButtons(ei);
const uint8_t button_op_right = BUTTON_OP_RIGHT(button_operation);
const uint8_t button_op_middle = BUTTON_OP_MIDDLE(button_operation);
// Check if the menu should have three or two choices
if (button_op_right == (uint8_t)ButtonOperations::NoOperation){
// Two operations not specified, the error menu should only show two choices
two_choices = true;
}
static int8_t current_selection = two_choices ? LCD_LEFT_BUTTON_CHOICE : LCD_MIDDLE_BUTTON_CHOICE;
static int8_t choice_selected = -1;
if (reset_button_selection) {
// If a new error screen is shown, we must reset the button selection
// Default selection is different depending on how many buttons are present
current_selection = two_choices ? LCD_LEFT_BUTTON_CHOICE : LCD_MIDDLE_BUTTON_CHOICE;
choice_selected = -1;
reset_button_selection = 0;
}
// Check if knob was rotated
if (lcd_encoder) {
if (two_choices == false) { // third_choice is not nullptr, safe to dereference
if (lcd_encoder < 0 && current_selection != LCD_LEFT_BUTTON_CHOICE) {
// Rotating knob counter clockwise
current_selection--;
} else if (lcd_encoder > 0 && current_selection != LCD_RIGHT_BUTTON_CHOICE) {
// Rotating knob clockwise
current_selection++;
}
} else {
if (lcd_encoder < 0 && current_selection != LCD_LEFT_BUTTON_CHOICE) {
// Rotating knob counter clockwise
current_selection = LCD_LEFT_BUTTON_CHOICE;
} else if (lcd_encoder > 0 && current_selection != LCD_MIDDLE_BUTTON_CHOICE) {
// Rotating knob clockwise
current_selection = LCD_MIDDLE_BUTTON_CHOICE;
}
}
// Update '>' render only
//! @brief Button menu
//!
//! @code{.unparsed}
//! |01234567890123456789|
//! | |
//! | |
//! | |
//! |>(left) |
//! ----------------------
//! Three choices
//! |>(left)>(mid)>(righ)|
//! ----------------------
//! Two choices
//! ----------------------
//! |>(left) >(mid) |
//! ----------------------
//! @endcode
//
lcd_putc_at(0, 3, current_selection == LCD_LEFT_BUTTON_CHOICE ? '>': ' ');
if (two_choices == false)
{
lcd_putc_at(9, 3, current_selection == LCD_MIDDLE_BUTTON_CHOICE ? '>': ' ');
lcd_putc_at(18, 3, current_selection == LCD_RIGHT_BUTTON_CHOICE ? '>': ' ');
} else {
// More button for two button screen
lcd_putc_at(18, 3, current_selection == LCD_MIDDLE_BUTTON_CHOICE ? '>': ' ');
}
// Consume rotation event
lcd_encoder = 0;
}
// Check if knob was clicked and consume the event
if (lcd_clicked()) {
choice_selected = current_selection;
} else {
// continue monitoring
return ret;
}
if ((two_choices && choice_selected == LCD_MIDDLE_BUTTON_CHOICE) // Two choices and middle button selected
|| (!two_choices && choice_selected == LCD_RIGHT_BUTTON_CHOICE)) // Three choices and right most button selected
{
// 'More' show error description
lcd_show_fullscreen_message_and_wait_P(_T(PrusaErrorDesc(ei)));
ret = 1;
} else if(choice_selected == LCD_MIDDLE_BUTTON_CHOICE) {
SetButtonResponse((ButtonOperations)button_op_right);
ret = 2;
} else {
SetButtonResponse((ButtonOperations)button_op_middle);
ret = 2;
}
// Next MMU error screen should reset the choice selection
reset_button_selection = 1;
return ret;
}
enum class ReportErrorHookStates : uint8_t {
RENDER_ERROR_SCREEN = 0,
MONITOR_SELECTION = 1,
DISMISS_ERROR_SCREEN = 2,
};
enum ReportErrorHookStates ReportErrorHookState = ReportErrorHookStates::RENDER_ERROR_SCREEN;
// Helper variable to monitor knob in MMU error screen in blocking functions e.g. manage_response
static bool is_mmu_error_monitor_active;
// Helper variable to stop rendering the error screen when the firmware is rendering complementary
// UI to resolve the error screen, for example tuning Idler Stallguard Threshold
// Set to false to allow the error screen to render again.
static bool putErrorScreenToSleep;
bool isErrorScreenRunning() {
return is_mmu_error_monitor_active;
}
bool TuneMenuEntered() {
return putErrorScreenToSleep;
}
void ReportErrorHook(CommandInProgress /*cip*/, uint16_t ec, uint8_t /*es*/) {
if (putErrorScreenToSleep) return;
if (mmu2.MMUCurrentErrorCode() == ErrorCode::OK && mmu2.MMULastErrorSource() == MMU2::ErrorSourceMMU) {
// If the error code suddenly changes to OK, that means
// a button was pushed on the MMU and the LCD should
// dismiss the error screen until MMU raises a new error
ReportErrorHookState = ReportErrorHookStates::DISMISS_ERROR_SCREEN;
}
const uint8_t ei = PrusaErrorCodeIndex((ErrorCode)ec);
switch ((uint8_t)ReportErrorHookState) {
case (uint8_t)ReportErrorHookStates::RENDER_ERROR_SCREEN:
ReportErrorHookStaticRender(ei);
ReportErrorHookState = ReportErrorHookStates::MONITOR_SELECTION;
[[fallthrough]];
case (uint8_t)ReportErrorHookStates::MONITOR_SELECTION:
is_mmu_error_monitor_active = true;
ReportErrorHookDynamicRender(); // Render dynamic characters
sound_wait_for_user();
switch (ReportErrorHookMonitor(ei)) {
case 0:
// No choice selected, return to loop()
break;
case 1:
// More button selected, change state
ReportErrorHookState = ReportErrorHookStates::RENDER_ERROR_SCREEN;
break;
case 2:
// Exit error screen and enable lcd updates
lcd_set_custom_characters();
lcd_update_enable(true);
lcd_return_to_status();
sound_wait_for_user_reset();
// Reset the state in case a new error is reported
is_mmu_error_monitor_active = false;
ReportErrorHookState = ReportErrorHookStates::RENDER_ERROR_SCREEN;
break;
default:
break;
}
return; // Always return to loop() to let MMU trigger a call to ReportErrorHook again
break;
case (uint8_t)ReportErrorHookStates::DISMISS_ERROR_SCREEN:
lcd_set_custom_characters();
lcd_update_enable(true);
lcd_return_to_status();
sound_wait_for_user_reset();
// Reset the state in case a new error is reported
is_mmu_error_monitor_active = false;
ReportErrorHookState = ReportErrorHookStates::RENDER_ERROR_SCREEN;
break;
default:
break;
}
}
void ReportProgressHook(CommandInProgress cip, uint16_t ec) {
if (cip != CommandInProgress::NoCommand) {
custom_message_type = CustomMsg::MMUProgress;
lcd_setstatuspgm( _T(ProgressCodeToText(ec)) );
}
}
void TryLoadUnloadProgressbarInit() {
lcd_clearstatus();
}
void TryLoadUnloadProgressbarDeinit() {
// Delay the next status message just so
// the user can see the results clearly
lcd_reset_status_message_timeout();
}
void TryLoadUnloadProgressbarEcho() {
char buf[LCD_WIDTH];
lcd_getstatus(buf);
for (uint8_t i = 0; i < sizeof(buf); i++) {
// 0xFF is -1 when converting from unsigned to signed char
// If the number is negative, that means filament is present
buf[i] = (buf[i] < 0) ? '1' : '0';
}
MMU2_ECHO_MSGLN(buf);
}
void TryLoadUnloadProgressbar(uint8_t col, bool sensorState) {
lcd_insert_char_into_status(col, sensorState ? '-' : LCD_STR_SOLID_BLOCK[0]);
if (!lcd_update_enabled) lcdui_print_status_line();
}
void IncrementLoadFails(){
eeprom_increment_byte((uint8_t *)EEPROM_MMU_LOAD_FAIL);
eeprom_increment_word((uint16_t *)EEPROM_MMU_LOAD_FAIL_TOT);
}
void IncrementMMUFails(){
eeprom_increment_byte((uint8_t *)EEPROM_MMU_FAIL);
eeprom_increment_word((uint16_t *)EEPROM_MMU_FAIL_TOT);
}
void MakeSound(SoundType s){
Sound_MakeSound( (eSOUND_TYPE)s);
}
static void FullScreenMsg(const char *pgmS, uint8_t slot){
lcd_update_enable(false);
lcd_clear();
lcd_puts_at_P(0, 1, pgmS);
lcd_print(' ');
lcd_print(slot + 1);
}
void FullScreenMsgCut(uint8_t slot){
FullScreenMsg(_T(MSG_CUT_FILAMENT), slot);
}
void FullScreenMsgEject(uint8_t slot){
FullScreenMsg(_T(MSG_EJECT_FROM_MMU), slot);
}
void FullScreenMsgTest(uint8_t slot){
FullScreenMsg(_T(MSG_TESTING_FILAMENT), slot);
}
void FullScreenMsgLoad(uint8_t slot){
FullScreenMsg(_T(MSG_LOADING_FILAMENT), slot);
}
void FullScreenMsgRestoringTemperature(){
lcd_display_message_fullscreen_P(_i("MMU Retry: Restoring temperature...")); ////MSG_MMU_RESTORE_TEMP c=20 r=4
}
void ScreenUpdateEnable(){
lcd_update_enable(true);
}
void ScreenClear(){
lcd_clear();
}
struct TuneItem {
uint8_t address;
uint8_t minValue;
uint8_t maxValue;
} __attribute__((packed));
static const TuneItem TuneItems[] PROGMEM = {
{ (uint8_t)Register::Selector_sg_thrs_R, 1, 4},
{ (uint8_t)Register::Idler_sg_thrs_R, 4, 7},
};
static_assert(sizeof(TuneItems)/sizeof(TuneItem) == 2);
struct _menu_tune_data_t
{
menu_data_edit_t reserved; //13 bytes reserved for number editing functions
int8_t status; // 1 byte
uint8_t currentValue; // 1 byte
TuneItem item; // 3 bytes
};
static_assert(sizeof(_menu_tune_data_t) == 18);
static_assert(sizeof(menu_data)>= sizeof(_menu_tune_data_t),"_menu_tune_data_t doesn't fit into menu_data");
void tuneIdlerStallguardThresholdMenu() {
static constexpr _menu_tune_data_t * const _md = (_menu_tune_data_t*)&(menu_data[0]);
// Do not timeout the screen, otherwise there will be FW crash (menu recursion)
lcd_timeoutToStatus.stop();
if (_md->status == 0)
{
_md->status = 1; // Menu entered for the first time
// Fetch the TuneItem from PROGMEM
const uint8_t offset = (mmu2.MMUCurrentErrorCode() == ErrorCode::HOMING_IDLER_FAILED) ? 1 : 0;
memcpy_P(&(_md->item), &TuneItems[offset], sizeof(TuneItem));
// Fetch the value which is currently in MMU EEPROM
mmu2.ReadRegister(_md->item.address);
_md->currentValue = mmu2.GetLastReadRegisterValue();
}
MENU_BEGIN();
ON_MENU_LEAVE(
mmu2.WriteRegister(_md->item.address, (uint16_t)_md->currentValue);
putErrorScreenToSleep = false;
lcd_return_to_status();
return;
);
MENU_ITEM_BACK_P(_T(MSG_DONE));
MENU_ITEM_EDIT_int3_P(
_i("Sensitivity"), ////MSG_MMU_SENSITIVITY c=18
&_md->currentValue,
_md->item.minValue,
_md->item.maxValue
);
MENU_END();
}
void tuneIdlerStallguardThreshold() {
putErrorScreenToSleep = true;
menu_submenu(tuneIdlerStallguardThresholdMenu);
}
} // namespace MMU2
Reference in New Issue View Git Blame Copy Permalink