src/modules/utils/panel/Panel.h

   1 /*
   2       This file is part of Smoothie (http://smoothieware.org/). The motion control part is heavily based on Grbl (https://github.com/simen/grbl).
   3       Smoothie 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.
   4       Smoothie 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.
   5       You should have received a copy of the GNU General Public License along with Smoothie. If not, see <http://www.gnu.org/licenses/>.
   6 */
   7
   8 #ifndef PANEL_H
   9 #define PANEL_H
  10
  11 #include "Button.h"
  12 #include "Pin.h"
  13 #include "mbed.h"
  14 #include <string>
  15 using std::string;
  16
  17 #define MENU_MODE                  0
  18 #define CONTROL_MODE               1
  19
  20 #define THEPANEL Panel::instance
  21
  22 class LcdBase;
  23 class PanelScreen;
  24 class ModifyValuesScreen;
  25 class SDCard;
  26 class SDFAT;
  27
  28 class Panel : public Module {
  29     public:
  30         Panel();
  31         virtual ~Panel();
  32         static Panel* instance;
  33
  34         void on_module_loaded();
  35         uint32_t button_tick(uint32_t dummy);
  36         uint32_t encoder_tick(uint32_t dummy);
  37         void on_idle(void* argument);
  38         void on_halt(void* argument);
  39         void on_main_loop(void* argument);
  40         void on_gcode_received(void* argument);
  41         void on_second_tick(void* argument);
  42         void enter_screen(PanelScreen* screen);
  43         void reset_counter();
  44
  45         // Encoder and buttons
  46         uint32_t on_up(uint32_t dummy);
  47         uint32_t on_down(uint32_t dummy);
  48         uint32_t on_back(uint32_t dummy);
  49         uint32_t on_select(uint32_t dummy);
  50         uint32_t on_pause(uint32_t dummy);
  51         uint32_t refresh_tick(uint32_t dummy);
  52         uint32_t encoder_check(uint32_t dummy);
  53         bool counter_change();
  54         bool click();
  55         int get_encoder_resolution() const { return encoder_click_resolution; }
  56
  57         // Menu
  58         void enter_menu_mode(bool force= false);
  59         void setup_menu(uint16_t rows, uint16_t lines);
  60         void setup_menu(uint16_t rows);
  61         void menu_update();
  62         bool menu_change();
  63         uint16_t max_screen_lines() { return screen_lines; }
  64         uint16_t get_menu_current_line() { return menu_current_line; }
  65
  66         // Control
  67         bool enter_control_mode(float passed_normal_increment, float passed_pressed_increment);
  68         void set_control_value(float value);
  69         float get_control_value();
  70         bool control_value_change();
  71         void control_value_update();
  72         float get_jogging_speed(char axis) { return jogging_speed_mm_min[axis-'X']; }
  73         float get_default_hotend_temp() { return default_hotend_temperature; }
  74         float get_default_bed_temp() { return default_bed_temperature; }
  75
  76         // file playing from sd
  77         bool is_playing() const;
  78         void set_playing_file(string f);
  79         const char* get_playing_file() { return playing_file; }
  80
  81         string getMessage() { return message; }
  82         bool hasMessage() { return message.size() > 0; }
  83         bool is_halted() const { return halted; }
  84
  85         uint16_t get_screen_lines() const { return screen_lines; }
  86
  87         // public as it is directly accessed by screens... not good
  88         // TODO pass lcd into ctor of each sub screen
  89         LcdBase* lcd;
  90         PanelScreen* custom_screen;
  91
  92         // as panelscreen accesses private fields in Panel
  93         friend class PanelScreen;
  94
  95     private:
  96
  97         // external SD card
  98         bool mount_external_sd(bool on);
  99         Pin sdcd_pin;
 100         PinName extsd_spi_cs;
 101         SDCard *sd;
 102         SDFAT *extmounter;
 103
 104         // Menu
 105         int menu_selected_line;
 106         int menu_start_line;
 107         int menu_rows;
 108         int panel_lines;
 109
 110         // Control
 111         float normal_increment;
 112         int control_normal_counter;
 113         float control_base_value;
 114
 115         Button up_button;
 116         Button down_button;
 117         Button back_button;
 118         Button click_button;
 119         Button pause_button;
 120
 121         int* counter;
 122
 123         int idle_time;
 124
 125         PanelScreen* top_screen;
 126         PanelScreen* current_screen;
 127
 128         float jogging_speed_mm_min[3];
 129         float default_hotend_temperature;
 130         float default_bed_temperature;
 131
 132         string message;
 133
 134         uint16_t screen_lines;
 135         uint16_t menu_current_line;
 136         char playing_file[20];
 137         uint8_t extsd_spi_channel;
 138
 139         volatile struct {
 140             bool start_up:1;
 141             bool menu_changed:1;
 142             bool control_value_changed:1;
 143             bool external_sd_enable:1;
 144             bool halted:1;
 145             volatile bool counter_changed:1;
 146             volatile bool click_changed:1;
 147             volatile bool refresh_flag:1;
 148             volatile bool do_buttons:1;
 149             volatile bool do_encoder:1;
 150             char mode:2;
 151             char menu_offset:3;
 152             int encoder_click_resolution:3;
 153         };
 154 };
 155
 156 #endif