guimain.c File Reference

#include <stdio.h>
#include "stm32f4xx_hal.h"
#include "gui.h"
#include "config.h"
#include "marlin_client.h"
#include "window_logo.h"
#include "window_file_list.h"
#include "window_header.h"
#include "window_temp_graph.h"
#include "window_dlg_statemachine.h"
#include "window_dlg_wait.h"
#include "window_dlg_preheat.h"
#include "window_dlg_change.h"
#include "screen_print_preview.h"
#include "screen_lan_settings.h"
#include "screen_menu_fw_update.h"
#include "gpio.h"
#include "st7789v.h"
#include "jogwheel.h"
#include "hwio_a3ides.h"
#include "diag.h"
#include "sys.h"
#include "dbg.h"
#include "marlin_host.h"

Functions
void	update_firmware_screen (void)
void	gui_run (void)

Variables
screen_t *	pscreen_splash
screen_t *	pscreen_watchdog
screen_t *	pscreen_test
screen_t *	pscreen_test_gui
screen_t *	pscreen_test_term
screen_t *	pscreen_test_msgbox
screen_t *	pscreen_test_graph
screen_t *	pscreen_test_temperature
screen_t *	pscreen_home
screen_t *	pscreen_filebrowser
screen_t *	pscreen_printing
screen_t *	pscreen_menu_preheat
screen_t *	pscreen_menu_filament
screen_t *	pscreen_preheating
screen_t *	pscreen_menu_calibration
screen_t *	pscreen_menu_settings
screen_t *	pscreen_menu_temperature
screen_t *	pscreen_menu_move
screen_t *	pscreen_menu_info
screen_t *	pscreen_menu_tune
screen_t *	pscreen_menu_service
screen_t *	pscreen_sysinfo
screen_t *	pscreen_version_info
screen_t *	pscreen_test_disp_mem
screen_t *	pscreen_messages
screen_t *	pscreen_mesh_bed_lv
screen_t *	pscreen_wizard
int	HAL_IWDG_Reset
SPI_HandleTypeDef	hspi2
IWDG_HandleTypeDef	hiwdg
int	guimain_spi_test = 0
const st7789v_config_t	st7789v_cfg
const jogwheel_config_t	jogwheel_cfg
marlin_vars_t *	gui_marlin_vars = 0
int8_t	menu_timeout_enabled = 1

Function Documentation

update_firmware_screen()

void update_firmware_screen

(

void

)

                                  {
    font_t *font = resource_font(IDR_FNT_SPECIAL);
    font_t *font1 = resource_font(IDR_FNT_NORMAL);
    display->fill_rect(rect_ui16(0, 0, 240, 320), COLOR_BLACK);
    render_icon_align(rect_ui16(70, 20, 100, 100), IDR_PNG_icon_pepa, COLOR_BLACK, RENDER_FLG(ALIGN_CENTER, 0));
    display->draw_text(rect_ui16(10, 115, 240, 60), "Hi, this is your\nOriginal Prusa MINI.", font, COLOR_BLACK, COLOR_WHITE);
    display->draw_text(rect_ui16(10, 160, 240, 80), "Please insert the USB\ndrive that came with\nyour MINI and reset\nthe printer to flash\nthe firmware", font, COLOR_BLACK, COLOR_WHITE);
    render_text_align(rect_ui16(5, 250, 230, 40), "RESET PRINTER", font1, COLOR_ORANGE, COLOR_WHITE, padding_ui8(2, 6, 2, 2), ALIGN_CENTER);
    while (1) {
        if (jogwheel_button_down > 50)
            sys_reset();
        osDelay(1);
#ifndef _DEBUG
        HAL_IWDG_Refresh(&hiwdg); //watchdog reset
#endif //_DEBUG
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

gui_run()

void gui_run

(

void

)

                   {
    if (diag_fastboot)
        return;
 
    st7789v_config = st7789v_cfg;
    jogwheel_config = jogwheel_cfg;
    gui_init();
 
    // select jogwheel type by meassured 'reset delay'
    // original displays with 15 position encoder returns values 1-2 (short delay - no capacitor)
    // new displays with MK3 encoder returns values around 16000 (long delay - 100nF capacitor)
    if (st7789v_reset_delay > 1000) // threshold value is 1000
        jogwheel_config.flg = JOGWHEEL_FLG_INV_DIR;
    //_dbg("delay=%u", st7789v_reset_delay);
 
    gui_defaults.font = resource_font(IDR_FNT_NORMAL);
    gui_defaults.font_big = resource_font(IDR_FNT_BIG);
    window_msgbox_id_icon[0] = 0; //IDR_PNG_icon_pepa;
    window_msgbox_id_icon[1] = IDR_PNG_header_icon_error;
    window_msgbox_id_icon[2] = IDR_PNG_header_icon_question;
    window_msgbox_id_icon[3] = IDR_PNG_header_icon_warning;
    window_msgbox_id_icon[4] = IDR_PNG_header_icon_info;
 
    if (!sys_fw_is_valid())
        update_firmware_screen();
 
    gui_marlin_vars = marlin_client_init();
 
    hwio_beeper_tone2(440.0, 100, 0.0125); //start beep
 
    screen_register(pscreen_splash);
    screen_register(pscreen_watchdog);
 
    WINDOW_CLS_LOGO = window_register_class((window_class_t *)&window_class_logo);
#ifdef LCDSIM
    WINDOW_CLS_LCDSIM = window_register_class((window_class_t *)&window_class_lcdsim);
    screen_register(pscreen_marlin);
#else //LCDSIM
    WINDOW_CLS_FILE_LIST = window_register_class((window_class_t *)&window_class_file_list);
    WINDOW_CLS_HEADER = window_register_class((window_class_t *)&window_class_header);
    WINDOW_CLS_TEMP_GRAPH = window_register_class((window_class_t *)&window_class_temp_graph);
    WINDOW_CLS_DLG_LOADUNLOAD = window_register_class((window_class_t *)&window_class_dlg_statemachine);
    WINDOW_CLS_DLG_WAIT = window_register_class((window_class_t *)&window_class_dlg_wait);
    #ifdef _DEBUG
    WINDOW_CLS_DLG_POPUP = window_register_class((window_class_t *)&window_class_dlg_popup);
    #endif //_DEBUG
    WINDOW_CLS_DLG_PREHEAT = window_register_class((window_class_t *)&window_class_dlg_preheat);
    screen_register(pscreen_test);
    screen_register(pscreen_test_gui);
    screen_register(pscreen_test_term);
    screen_register(pscreen_test_msgbox);
    screen_register(pscreen_test_graph);
    screen_register(pscreen_test_temperature);
    screen_register(pscreen_home);
    screen_register(pscreen_filebrowser);
    screen_register(pscreen_printing);
    screen_register(pscreen_menu_preheat);
    screen_register(pscreen_menu_filament);
    screen_register(pscreen_menu_calibration);
    screen_register(pscreen_menu_settings);
    screen_register(pscreen_menu_temperature);
    screen_register(pscreen_menu_move);
    screen_register(pscreen_menu_info);
    screen_register(pscreen_menu_tune);
    screen_register(pscreen_menu_service);
    screen_register(pscreen_sysinfo);
    screen_register(pscreen_version_info);
    screen_register(pscreen_test_disp_mem);
    screen_register(pscreen_messages);
    #ifdef PIDCALIBRATION
    screen_register(pscreen_PID);
    #endif //PIDCALIBRATION
    screen_register(pscreen_mesh_bed_lv);
    screen_register(pscreen_wizard);
    screen_register(pscreen_print_preview);
    screen_register(pscreen_lan_settings);
    screen_register(pscreen_menu_fw_update);
#endif // LCDSIM
 
#ifndef _DEBUG
    if (HAL_IWDG_Reset) {
        screen_stack_push(pscreen_splash->id);
        screen_open(pscreen_watchdog->id);
    } else
#endif // _DEBUG
        screen_open(pscreen_splash->id);
 
    //set loop callback (will be called every time inside gui_loop)
    gui_loop_cb = marlin_client_loop;
    int8_t gui_timeout_id;
    while (1) {
        float vol = 0.01F;
        //simple jogwheel acoustic feedback
        if ((jogwheel_changed & 1) && jogwheel_button_down) //button changed and pressed
            hwio_beeper_tone2(200.0, 50, (double)(vol * 0.125F)); //beep
        else if (jogwheel_changed & 2) // encoder changed
            hwio_beeper_tone2(50.0, 25, (double)(vol * 0.125F)); //short click
        // show warning dialog on safety timer expiration
        if (marlin_event_clr(MARLIN_EVT_SafetyTimerExpired)) {
            gui_msgbox("Heating disabled due to 30 minutes of inactivity.", MSGBOX_BTN_OK | MSGBOX_ICO_WARNING);
        }
        gui_loop();
#ifndef LCDSIM
        if (marlin_message_received()) {
            screen_t *curr = screen_get_curr();
            if (curr == pscreen_printing) {
                screen_dispatch_event(NULL, WINDOW_EVENT_MESSAGE, 0);
            }
        }
        if (menu_timeout_enabled) {
            gui_timeout_id = gui_get_menu_timeout_id();
            if (gui_timer_expired(gui_timeout_id) == 1) {
                screen_t *curr = screen_get_curr();
                if (
                    curr != pscreen_menu_tune && curr != pscreen_wizard && curr != pscreen_print_preview) { //timeout screen black list
    #ifdef PIDCALIBRATION
                    if (curr != pscreen_PID) {
    #endif //PIDCALIBRATION
                        while (curr != pscreen_printing && curr != pscreen_home && curr != pscreen_menu_tune) {
                            screen_close();
                            curr = screen_get_curr();
                        }
    #ifdef PIDCALIBRATION
                    }
    #endif //PIDCALIBRATION
                }
                gui_timer_delete(gui_timeout_id);
            }
        }
        if (marlin_event_clr(MARLIN_EVT_CommandBegin)) {
            if (marlin_command() == MARLIN_CMD_M600) {
                _dbg("M600 start");
                gui_dlg_change();
                _dbg("M600 end");
            }
        }
#endif //LCDSIM
    }
}

Variable Documentation

pscreen_splash

screen_t* pscreen_splash

pscreen_watchdog

screen_t* pscreen_watchdog

pscreen_test

screen_t* pscreen_test

pscreen_test_gui

screen_t* pscreen_test_gui

pscreen_test_term

screen_t* pscreen_test_term

pscreen_test_msgbox

screen_t* pscreen_test_msgbox

pscreen_test_graph

screen_t* pscreen_test_graph

pscreen_test_temperature

screen_t* pscreen_test_temperature

pscreen_home

screen_t* pscreen_home

pscreen_filebrowser

screen_t* pscreen_filebrowser

pscreen_printing

screen_t* pscreen_printing

pscreen_menu_preheat

screen_t* pscreen_menu_preheat

pscreen_menu_filament

screen_t* pscreen_menu_filament

pscreen_preheating

screen_t* pscreen_preheating

pscreen_menu_calibration

screen_t* pscreen_menu_calibration

pscreen_menu_settings

screen_t* pscreen_menu_settings

pscreen_menu_temperature

screen_t* pscreen_menu_temperature

pscreen_menu_move

screen_t* pscreen_menu_move

pscreen_menu_info

screen_t* pscreen_menu_info

pscreen_menu_tune

screen_t* pscreen_menu_tune

pscreen_menu_service

screen_t* pscreen_menu_service

pscreen_sysinfo

screen_t* pscreen_sysinfo

pscreen_version_info

screen_t* pscreen_version_info

pscreen_test_disp_mem

screen_t* pscreen_test_disp_mem

pscreen_messages

screen_t* pscreen_messages

pscreen_mesh_bed_lv

screen_t* pscreen_mesh_bed_lv

pscreen_wizard

screen_t* pscreen_wizard

HAL_IWDG_Reset

int HAL_IWDG_Reset

hspi2

SPI_HandleTypeDef hspi2

hiwdg

IWDG_HandleTypeDef hiwdg

Marlin 3D Printer Firmware Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]

Based on Sprinter and grbl. Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

guimain_spi_test

int guimain_spi_test = 0

st7789v_cfg

const st7789v_config_t st7789v_cfg

Initial value:

= {
    &hspi2, 
    ST7789V_PIN_CS, 
    ST7789V_PIN_RS, 
    ST7789V_PIN_RST, 
    ST7789V_FLG_DMA, 
    ST7789V_DEF_COLMOD, 
    ST7789V_DEF_MADCTL, 
}

jogwheel_cfg

const jogwheel_config_t jogwheel_cfg

Initial value:

= {
    JOGWHEEL_PIN_EN1, 
    JOGWHEEL_PIN_EN2, 
    JOGWHEEL_PIN_ENC, 
    JOGWHEEL_DEF_FLG, 
}

gui_marlin_vars

marlin_vars_t* gui_marlin_vars = 0

menu_timeout_enabled

int8_t menu_timeout_enabled = 1