dmcp.h

#ifndef __SYS_DMCP_H__
#define __SYS_DMCP_H__
 
 
 
#include <stdint.h>
 
typedef unsigned int uint;
 
// Remove space before ! in next line to enable Intro page
/* ! \mainpage Introduction
 *
 * \section intro_sec Introduction
 *
 * This is the introduction.
 *
 * \section install_sec Installation
 *
 * \subsection step1 Step 1: Opening the box
 *
 * etc...
 */
 
 
// --------------------------------------
// -------------------------------------
 
 
// -----------------------------------
// ----------------------------------
// -----------------------------------
// ----------------------------------
// -----------------------------------
// ----------------------------------
// --------------------------------------
// -------------------------------------
// --------------------------------------
// -------------------------------------
// ----------------------------------------
// ---------------------------------------
 
// -----------------------------------
// ----------------------------------
 
// -----------------------------------
// ----------------------------------
 
#include "ff_ifc.h"
 
#include "qrcode_ifc.h"
 
 
 
void qrcode_disp(QRCode *qr, int xo, int yo, int z);
 
// HW interface
 
void LCD_clear();
 
void LCD_power_on();
 
void LCD_power_off(int clear);
 
void LCD_write_line(uint8_t * buf);
 
// --------------------------------------
// -------------------------------------
// Configuration
#define LCD_INVERT_XAXIS 
#define LCD_INVERT_DATA  
// -------
 
 
#define BLT_OR    0    
#define BLT_ANDN  1    
#define BLT_XOR   2    
#define BLT_NONE  0    
#define BLT_SET   1    
#ifdef LCD_INVERT_DATA
# define LCD_EMPTY_VALUE 0xFF  
# define LCD_SET_VALUE      0  
#else
# define LCD_EMPTY_VALUE    0  
# define LCD_SET_VALUE   0xFF  
#endif
 
#define LCD_X 400  
#define LCD_Y 240  
#define LCD_LINE_SIZE      50 
#define LCD_LINE_BUF_SIZE  (LCD_LINE_SIZE+4) 
// Drawing Prototypes
 
void lcd_clear_buf();
 
void lcd_refresh();
 
void lcd_refresh_dma();
 
void lcd_refresh_wait();
 
void lcd_forced_refresh();
 
void lcd_refresh_lines(int ln, int cnt);
 
 
void bitblt24(uint32_t x, uint32_t dx, uint32_t y, uint32_t val, int blt_op, int fill);
 
 
 
uint8_t * lcd_line_addr(int y);
 
 
void lcd_fill_rect(uint32_t x, uint32_t y, uint32_t dx, uint32_t dy, int val);
 
 
void lcd_fill_ptrn(int x, int y, int dx, int dy, int ptrn1, int ptrn2);
 
 
void lcd_fillLine(int ln, uint8_t val);
 
 
void lcd_fillLines(int ln, uint8_t val, int cnt);
 
 
void lcd_set_buf_cleared(int val);
 
int lcd_get_buf_cleared();
 
 
uint8_t reverse_byte(uint8_t x);
 
#define SCR_DIR        "/SCREENS"
 
#define OFFIMG_DIR     "/OFFIMG"
 
 
 
// Screenshot
int create_screenshot(int report_error);
 
// Place image into LCD buffer
 
void lcd_draw_img(const char* img, uint32_t xo, uint32_t yo, uint32_t x, uint32_t y);
 
 
void lcd_draw_img_direct(const char* img, uint32_t xo, uint32_t yo, uint32_t x, uint32_t y);
 
 
void lcd_draw_img_part(const char* img, uint32_t xo, uint32_t yo, uint32_t x, uint32_t y, uint32_t dx);
 
 
 
// Off images
void draw_power_off_image(int allow_errors);
 
void reset_off_image_cycle();
 
#define BG_COL_PAPER  0xf4f2dc 
#define BG_COL_LCD    0xdff5cc 
int update_bmp_file_header(FIL* fp, int width, int height, uint32_t bg_color);
 
 
// ----------------------------------
 
 
// ----------------------------------
 
typedef struct {
  const char * name;      
  uint8_t width;          
  uint8_t height;         
  uint8_t baseline;       
  uint8_t first_char;     
  uint8_t char_cnt;       
  uint8_t scale_x;        
  uint8_t scale_y;        
  uint8_t const * data;   
  uint16_t const * offs;  
} line_font_t;
 
 
#define NR2T(x) (-(x)-1)   // x<0
 
#define T2NR(x) (-(x)-1)   // x>=0
 
 
typedef struct {
  line_font_t const * f; 
  int16_t x;             
  int16_t y;             
  int16_t ln_offs;       
  int16_t y_top_grd;     
  int8_t  ya;            
  int8_t  yb;            
  int8_t  xspc;          
  int8_t  xoffs;         
  uint8_t fixed;         
  uint8_t inv;           
  uint8_t bgfill;        
  uint8_t lnfill;        
  uint8_t newln;         
  const uint8_t *post_offs;
} disp_stat_t;
 
 
 
void lcd_writeNl(disp_stat_t * ds);
 
void lcd_prevLn(disp_stat_t * ds);
 
void lcd_writeClr(disp_stat_t * ds);
 
 
void lcd_setLine(disp_stat_t * ds, int ln_nr);
 
 
void lcd_setXY(disp_stat_t * ds, int x, int y);
 
int lcd_lineHeight(disp_stat_t * ds);
 
 
int lcd_baseHeight(disp_stat_t * ds);
 
 
int lcd_fontWidth(disp_stat_t * ds);
 
 
void lcd_writeText(disp_stat_t * ds, const char* text);
 
void lcd_textToBox(disp_stat_t * ds, int x, int width, char *text, int from_right, int align_right);
 
 
 
int lcd_textWidth(disp_stat_t * ds, const char* text);
 
int lcd_charWidth(disp_stat_t * ds, int c);
 
 
 
int lcd_textToWidth(disp_stat_t * ds, const char* text, int expected_width, int * plen);
 
 
 
int lcd_textToWidthR(disp_stat_t * ds, const char* text, int expected_width, int * plen);
 
 
 
void lcd_writeTextWidth(disp_stat_t * ds, const char* text);
 
 
int lcd_textForWidth(disp_stat_t * ds, const char* text, int expected_width, int * plen);
 
 
 
int lcd_nextFontNr(int nr);
 
int lcd_prevFontNr(int nr);
 
void lcd_switchFont(disp_stat_t * ds, int nr);
 
int lcd_toggleFontT(int nr);
 
 
void lcd_print(disp_stat_t * ds, const char* fmt, ...);
 
 
#define lcd_printAt(ds, ln, ...)  do { lcd_setLine(ds, ln); lcd_print(ds, __VA_ARGS__); } while(0)
 
#define lcd_printR(ds, ...)       do { ds->inv=1; lcd_print(ds, __VA_ARGS__); ds->inv=0; } while(0)
 
#define lcd_printRAt(ds, ln, ...) do { lcd_setLine(ds, ln); ds->inv=1; lcd_print(ds, __VA_ARGS__); ds->inv=0; } while(0)
 
#define lcd_puts lcd_writeText
 
#define lcd_putsAt(ds, ln, str)   do { lcd_setLine(ds, ln); lcd_puts(ds,str); } while(0)
 
#define lcd_putsR(ds, str)        do { ds->inv=1; lcd_puts(ds,str); ds->inv=0; } while(0)
 
 
#define lcd_putsRAt(ds, ln, str)  do { lcd_setLine(ds, ln); ds->inv=1; lcd_puts(ds,str); ds->inv=0; } while(0)
 
// ----------------------------------
 
 
#define DISP_CALC                0  
#define DISP_SYS_MENU            2  
#define DISP_BOOTLOADER          4  
#define DISP_UNIMPLEMENTED       5  
#define DISP_USB_WRITE           6  
#define DISP_MSC_CONNECT_USB     7  
#define DISP_ABOUT               8  
#define DISP_FAT_FORMAT          9  
#define DISP_FAULT              11  
#define DISP_QSPI_BAD_CRC       12  
#define DISP_QSPI_CHECK         13  
#define DISP_MARK_REGION        15  
#define DISP_DISK_TEST          16  
#define DISP_DSKTST_CONNECT_USB 17  
#define DISP_QSPI_CONNECT_USB   18  
#define DISP_OFF_IMAGE_ERR      19  
#define DISP_HELP               21  
#define DISP_BOOTLDR_CON_USB    22  
#define DISP_PROD_DIAG          23  
#define DISP_POWER_CHECK        24  
#define DISP_FLASH_CONNECT_USB  26  
// ----
 
 
int lcd_for_calc(int what);
 
#define LCD_MENU_LINES        32  
#define MENU_KEY_LABEL_LEN    12  
#define MENU_KEY_COUNT         6  
void lcd_draw_menu_bg();
 
void lcd_draw_menu_key(int nr, const char *key, int highlight);
 
void lcd_draw_menu_keys(const char *keys[]);
 
// ----------------------------------
 
 
// === Date/Time
 
 
 
#define PRINT_DT_TM_SZ 20
 
 
typedef struct {
  uint16_t year;  
  uint8_t  month; 
  uint8_t  day;   
} dt_t;
 
typedef struct {
  uint8_t hour; 
  uint8_t min;  
  uint8_t sec;  
  uint8_t csec; 
  uint8_t dow;
} tm_t;
 
const char* get_wday_shortcut(int day); // 0 = Monday
const char* get_month_shortcut(int month); // 1 = Jan
 
int julian_day(dt_t *d);
 
void julian_to_date(int julian_day, dt_t *d);
 
void print_dmy_date(char * s, int const sz, dt_t *dt, const char * prefix, int shortmon, char sep_arg);
 
void print_clk24_time(char * t, int const sz, tm_t *tm, int disp_sec, int disp_dow);
 
// ----------------------------------
 
// System data block (SDB)
 
 
 
 
 
typedef int get_flag_fn_t();         
typedef void set_flag_fn_t(int val); 
get_flag_fn_t * get_flag_dmy;
 
set_flag_fn_t * set_flag_dmy;
 
 
get_flag_fn_t * is_flag_clk24;
 
set_flag_fn_t * set_flag_clk24;
 
 
get_flag_fn_t * is_beep_mute;
 
set_flag_fn_t * set_beep_mute;
 
void_fn_t * after_fat_format;
 
 
 
typedef void void_fn_t(); 
 
uint32_t calc_state;
 
FIL * ppgm_fp;
 
 
 
const char * key_to_alpha_table;
 
 
 
 
run_menu_item_fn_t * run_menu_item_app;
 
menu_line_str_fn_t * menu_line_str_app;
 
disp_stat_t * t20;
 
disp_stat_t * t24;
 
disp_stat_t * fReg;
 
// ----------------------------------
 
#define PLATFORM_VERSION "3.20"
 
// System interface version
#define PLATFORM_IFC_CNR   3
#define PLATFORM_IFC_VER  15
 
// STATIC_ASSERT ...
#define ASSERT_CONCAT_(a, b) a##b
#define ASSERT_CONCAT(a, b) ASSERT_CONCAT_(a, b)
#define STATIC_ASSERT(e,m) ;enum { ASSERT_CONCAT(assert_line_, __LINE__) = 1/(int)(!!(e)) }
//#define STATIC_ASSERT(expr, msg) typedef char ASSERT_CONCAT(static_assert_check_, __LINE__) [(expr) ? (+1) : (-1)]
 
#define _STRINGIFY(x) #x
#define STR(x) _STRINGIFY(x)
 
#define BIT(n) (1<<(n))
 
 
 
 
int qspi_user_write(uint8_t *data, int size, int offset, int erase);
 
uint8_t * qspi_user_addr();
 
int qspi_user_size();
 
 
void rtc_read(tm_t * tm, dt_t *dt);
 
void rtc_write(tm_t * tm, dt_t *dt);
 
 
void rtc_update_time_sec(int delta_sec);
 
 
uint8_t rtc_read_century();
 
void rtc_write_century(uint8_t cent);
 
uint8_t rtc_read_min();
 
uint8_t rtc_read_sec();
 
void rtc_wakeup_delay();
 
 
void rtc_check_unset();
 
 
 
#define RTCREGS_SS_PER_SEC  256
 
 
uint32_t get_rtc_ticks();
 
 
 
typedef struct {
  uint32_t dt; 
  uint32_t tm; 
  uint16_t ss; 
} rtc_time_regs_t;
 
 
typedef struct {
  rtc_time_regs_t regs; 
  uint64_t dsec; 
  uint32_t jday; 
  uint32_t sec;  
  uint32_t msec; 
} rtc_ticks_stat_t;
 
 
rtc_ticks_stat_t* rtc_update_ticks();
 
 
 
 
 
 
 
 
 
 
void rtc_set_alarm(tm_t * tm, dt_t *dt);
 
 
void rtc_cancel_alarm();
 
 
 
// ==== VBAT
 
uint32_t read_power_voltage();
 
int get_lowbat_state();
 
int get_vbat();
 
// ==== USB functions
int usb_powered();
 
// ==== Buzzer
 
// Freq in mHz
 
void start_buzzer_freq(uint32_t freq);
 
void stop_buzzer();
 
void set_buzzer(int pin1val, int pin2val);
 
 
void beep_volume_up();
 
void beep_volume_down();
 
int get_beep_volume();
 
// ==== REGIONS
 
uint32_t mark_region(uint32_t id);
 
void no_region();
 
// ==== RESET values
 
#define NO_SPLASH_MAGIC         0xEACE7362 
#define ALLOC_FAIL_MAGIC        0x363EACE7 
#define CLEAN_RESET_MAGIC       0x3EACE736 
#define RUN_DMCP_MAGIC          0x3CE7EA37 
void set_reset_magic(uint32_t value);
 
 
 
// === RESET STATE FILE
 
#define RESET_STATE_FILE_SIZE        0x38 
int is_reset_state_file();
 
char * get_reset_state_file();
 
void set_reset_state_file(const char * str);
 
 
void sys_reset();
 
 
// Aux buf
#define AUX_BUF_SIZE (5*512) 
char * aux_buf_ptr();
 
void * write_buf_ptr();
 
int write_buf_size();
 
 
void sys_clear_write_buf_used();
 
int sys_write_buf_used();
 
// Program info structure
#define PROG_INFO_MAGIC 0xd377C0DE
 
void program_main();
 
typedef struct {
    uint32_t pgm_magic;
    uint32_t pgm_size;
    void * pgm_entry;
    uint32_t ifc_cnr;
    uint32_t ifc_ver;
    uint32_t qspi_size;
    uint32_t qspi_crc;
    char pgm_name[16];
    char pgm_ver[16];
}  prog_info_t;
 
// Keyboard
int read_key(int *k1, int *k2);
void suspended_bg_key_read();
void resume_bg_key_read();
 
 
// Timer
uint32_t get_tim1_timer();
 
 
// Base frequency 8MHz
#define TIMER_BASE_FREQ  (8000000)
void start_timer2(uint32_t div32);
void start_timer3(uint16_t div16);
void stop_timer2();
void stop_timer3();
 
 
 
 
 
 
 
 
// ----------------------------------
 
// Printer 
#define PRINT_GRA_LN  1 
#define PRINT_TXT_LN  0 
#define MAX_82240_WIDTH 166        
#define DFLT_82240_LINE_DUR 1800   
void print_byte(uint8_t b);
 
 
void print_buffer(uint8_t * buf, int cnt);
 
 
 
int print_is_ready();
 
 
 
// Printer delay in ms
uint printer_get_delay();
 
void printer_set_delay(uint val);
 
void printer_advance_buf(int what);
 
int printer_busy_for(int what);
 
// ----------------------------------
 
// --------------------------------
//  Menu pages
// --------------------------------
 
 
typedef struct {
  const char  * name;       
  const uint8_t * items;    
  const char* const * msg;
 
  void_fn_t * post_disp;
} smenu_t;
 
 
// --------------------------------------
// -------------------------------------
extern const smenu_t     MID_SYS_WARN; 
extern const smenu_t       MID_SYSTEM; 
extern const smenu_t   MID_FAT_FORMAT; 
extern const smenu_t MID_DSKTST_ENTER; 
extern const smenu_t    MID_PROD_DIAG; 
extern const smenu_t   MID_PROD_DIAG2; 
extern const smenu_t         MID_DMCP; 
extern const smenu_t   MID_BASE_SETUP; 
// --------------------------------------
// -------------------------------------
#define MI_SYSTEM          192 
#define MI_BOOTLOADER      193 
#define MI_QSPI_LOADER     194 
#define MI_DIAG            195 
#define MI_MSC             196 
#define MI_ABOUT           197 
#define MI_BASE_SETUP      198 
#define MI_BEEP_MUTE       199 
#define MI_SYSTEM_ENTER    200 
#define MI_RELOAD_RESET    201 
#define MI_SET_TIME        202 
#define MI_SET_DATE        203 
#define MI_FF_ENTER        204 
#define MI_FAT_FORMAT      205 
#define MI_DISK_TEST       206 
#define MI_DSKTST_ENTER    207 
#define MI_DISK_INFO       208 
#define MI_LOAD_QSPI       209 
#define MI_SLOW_AUTOREP    210 
#define MI_EXIT            211 
#define MI_KBD_TEST        212 
#define MI_LCD_TEST        213 
#define MI_IR_TEST         214 
#define MI_BEEP_TEST       215 
#define MI_DMCP_MENU       216 
#define MI_SELF_TEST       217 
#define MI_RAMFLASH        218 
#define MI_PGM_INFO        219 
#define MI_PGM_RUN         220 
#define MI_PGM_LOAD        221 
#define MI_RUN_DMCP        222 
#define MI_OFF_MODE        223 
// --------------------------------
 
 
typedef int run_menu_item_fn_t(uint8_t line_id);
 
typedef const char * menu_line_str_fn_t(uint8_t line_id, char * s, const int slen);
 
 
// --------------------------------------
// -------------------------------------
// --------------------------------
#define MENU_MAX_LEVEL     8  
#define MENU_FONT        t24  
#define MENU_LCD_LINES     8  
#define MENU_RESET         0  
#define MENU_ADD           1  
#define MRET_UNIMPL       -1  
#define MRET_EXIT         -2  
#define MRET_LEAVELIMIT  512
// --------------------------------
// === Base menu functions ===
int handle_menu(const smenu_t * menu_id, int action, int cur_line);
 
 
int run_menu_item_sys(uint8_t line_id);
 
 
int run_menu_item(uint8_t line_id);
 
const char * menu_line_str(uint8_t line_id, char * ln, const int ln_len);
 
 
// --------------------------------------
// -------------------------------------
// === Menu formatting support
const char * rb_str(int val);
 
 
const char * sel_str(int val);
 
char * opt_str(char * s, char const *txt, int val);
 
char * date_str(char * s, const char * txt);
 
char * time_str(char * s, const char * txt);
 
void run_set_time();
 
void run_set_date();
 
// === Base dialogs
void disp_disk_info(const char * hdr);
 
int power_check_screen();
 
// === File selection ===
 
#define MAX_PGM_FN_LEN  24
typedef int (*file_sel_fn_t)(const char * fpath, const char * fname, void * data);
 
int file_selection_screen(const char * title, const char * base_dir, const char * ext, file_sel_fn_t sel_fn,
                          int disp_new, int overwrite_check, void * data);
 
 
// ---------------------------------------------------
//  Item selection screen
// ---------------------------------------------------
 
#define ISEL_FILL_ITEMS    -100
 
#define ISEL_KEY_PRESSED   -101
 
#define ISEL_EXIT          -102
 
#define ISEL_POST_DRAW       -2
 
#define ISEL_PRE_DRAW        -1
 
 
typedef uint16_t list_item_t;
 
struct item_sel_state;
 
typedef void isel_disp_line_fn_t(int lnr, list_item_t *fis, int cur_fnr, struct item_sel_state *st);
 
typedef void fis_name_fn_t(struct item_sel_state *st, list_item_t fis, char * nmbuf, int len);
 
 
typedef struct item_sel_state {
  int8_t fnr;         
  int8_t top_nr;      
  int8_t lncnt;       
  int8_t roll_lines;  
  int8_t key;         
  list_item_t * fis;           
  fis_name_fn_t * fis_name_fn; 
  int max_items;               
  int fcnt;                    
  // -- Set by user --
  const char * title;  
  char * title2;       
  isel_disp_line_fn_t * disp_line_fn; 
  char * lnbuf;        
  int lnsize;          
  void * data;         
  void * items;        
}  item_sel_state_t;
 
 
void item_sel_init(item_sel_state_t *st);
 
 
void item_sel_reinit(item_sel_state_t *st);
 
 
int item_sel_engine(item_sel_state_t *st, int upd);
 
 
void item_sel_header(item_sel_state_t *st, int update);
 
 
// ---------------------------------------------------
 
void msg_box(disp_stat_t * ds, const char * txt, int inv);
 
// ----------------------------------
 
 
#define MAX_LCD_LINE_LEN 40
 
 
// -----------------------
//  Bit masks operations
// -----------------------
#define VAL(x,val)      ((x) & (val))
#define CLR(x,val)       val &= ~(x)
#define SET(x,val)       val |=  (x)
#define MSK(x,val)     (~(x) & (val))
#define SETMSK(x,m,val)  val = (MSK(m,val)|(x))
//#define SETBY(c,x,val)   (c) ? SET(x,val) : CLR(x,val)
#define SETBY(c,x,val)   if (c) { SET(x,val); } else { CLR(x,val); }
 
 
 
 
 
 
#define     ST(x)       VAL(x,calc_state)
#define VAL_ST(x)       VAL(x,calc_state)
#define CLR_ST(x)       CLR(x,calc_state)
#define SET_ST(x)       SET(x,calc_state)
#define SETMSK_ST(x,m)  SETMSK(x,m,calc_state) 
#define SETBY_ST(c,x)   SETBY(c,x,calc_state)
 
 
 
#define STAT_CLEAN_RESET       BIT(0)
#define STAT_RUNNING           BIT(1)
#define STAT_SUSPENDED         BIT(2)
#define STAT_KEYUP_WAIT        BIT(3)
#define STAT_OFF               BIT(4)
#define STAT_SOFT_OFF          BIT(5)
#define STAT_MENU              BIT(6)
#define STAT_BEEP_MUTE         BIT(7)
#define STAT_SLOW_AUTOREP      BIT(8)
#define STAT_PGM_END           BIT(9)
#define STAT_CLK_WKUP_ENABLE   BIT(10)
#define STAT_CLK_WKUP_SECONDS  BIT(11) // 0 - wakeup runner each minute, 1 - each second
#define STAT_CLK_WKUP_FLAG     BIT(12)
#define STAT_DMY               BIT(13)
#define STAT_CLK24             BIT(14)
#define STAT_POWER_CHANGE      BIT(15)
 
#define STAT_HW_BEEP           BIT(28)
#define STAT_HW_USB            BIT(29)
#define STAT_HW_IR             BIT(30)
 
#define STAT_HW                (STAT_HW_BEEP | STAT_HW_USB | STAT_HW_IR)
 
 
 
 
 
 
// --------------------------------------
 
// -------------------------------------
#define MAX_KEY_NR       37 
#define MAX_FNKEY_NR     43 
// -------------
//  Key codes
// -------------
 
#define KEY_SIGMA  1 
#define KEY_INV    2 
#define KEY_SQRT   3 
#define KEY_LOG    4 
#define KEY_LN     5 
#define KEY_XEQ    6 
#define KEY_STO    7 
#define KEY_RCL    8 
#define KEY_RDN    9 
#define KEY_SIN   10 
#define KEY_COS   11 
#define KEY_TAN   12 
#define KEY_ENTER 13 
#define KEY_SWAP  14 
#define KEY_CHS   15 
#define KEY_E     16 
#define KEY_BSP   17 
#define KEY_UP    18 
#define KEY_7     19 
#define KEY_8     20 
#define KEY_9     21 
#define KEY_DIV   22 
#define KEY_DOWN  23 
#define KEY_4     24 
#define KEY_5     25 
#define KEY_6     26 
#define KEY_MUL   27 
#define KEY_SHIFT 28 
#define KEY_1     29 
#define KEY_2     30 
#define KEY_3     31 
#define KEY_SUB   32 
#define KEY_EXIT  33 
#define KEY_0     34 
#define KEY_DOT   35 
#define KEY_RUN   36 
#define KEY_ADD   37 
#define KEY_F1    38 
#define KEY_F2    39 
#define KEY_F3    40 
#define KEY_F4    41 
#define KEY_F5    42 
#define KEY_F6    43 
#define KEY_SCREENSHOT 44 
#define KEY_SH_UP      45 
#define KEY_SH_DOWN    46 
#define KEY_DOUBLE_RELEASE 99 
#define KEY_PAGEUP     KEY_DIV 
#define KEY_PAGEDOWN   KEY_MUL 
// ---------------------------
//  Key buffer functions
// ---------------------------
 
int key_empty();
 
int key_push(int k1);
 
int key_tail();
 
int key_pop();
 
 
int key_pop_last();
void key_pop_all();
 
 
// Key functions
int key_to_nr(int key);
 
// Key
int sys_last_key();
 
void wait_for_key_press();
 
void wait_for_key_release(int tout);
 
 
 
int runner_get_key(int *repeat);
 
int runner_get_key_delay(int *repeat, uint timeout, uint rep0, uint rep1, uint rep1tout);
 
 
// ---------------------------
//  Runner get key
// ---------------------------
 
int runner_key_tout_value(const int first);
 
 
 
// Autorepeat
int toggle_slow_autorepeat();
 
int is_slow_autorepeat();
 
void runner_key_tout_init(const int slow);
 
 
 
// Auto off
 
 
#define AUTO_OFF_SECONDS   600  
#define AUTO_OFF_MENU      300  
void reset_auto_off();
 
int is_auto_off();
 
int is_menu_auto_off();
 
int sys_auto_off_cnt();
 
// Check and create dir
// returns 0 on success
int check_create_dir(const char * dir);
 
int file_exists(const char * fn);
 
int file_size(const char * fn);
 
 
void make_date_filename(char * fn, const char * dir, const char * ext);
 
 
int sys_disk_ok();
 
int sys_disk_write_enable(int val);
 
int sys_is_disk_write_enable();
 
 
void sys_disk_check_valid();
 
void set_fat_label(const char * label);
 
void sys_timer_disable(int timer_ix);
 
void sys_timer_start(int timer_ix, uint32_t ms_value);
 
int sys_timer_active(int timer_ix);
 
int sys_timer_timeout(int timer_ix);
 
 
 
void sys_delay(uint32_t ms_delay);
 
// Current systick count
 
uint32_t sys_tick_count();
 
uint32_t sys_current_ms();
 
// Critical sections
 
void sys_critical_start();
 
void sys_critical_end();
 
// Sleep
 
void sys_sleep();
 
// Free memory
 
int sys_free_mem();
 
// ==== HW ID
 
uint8_t get_hw_id();
 
// ---------------------------
// Flashing
// ---------------------------
 
 
void sys_flashing_init();
void sys_flashing_finish();
 
int sys_flash_erase_block(void* start_addr, uint32_t size);
 
int sys_flash_write_block(void* dst_addr, uint8_t * src_buf, uint32_t size);
 
// ---------------------------
 
 
// ----------------------------------
 
 
// Help
#define HELP_INDEX "/HELP/index.htm" 
void run_help();
 
 
void run_help_file(const char * help_file);
 
 
typedef void user_style_fn_t(char *class_attr, disp_stat_t *ds);
 
 
void run_help_file_style(const char * help_file, user_style_fn_t *user_style_fn);
 
 
// ----------------------------------
 
 
 
#endif