tuber/desk/modules/menu/menu_items.cpp

#include "stm32g4xx_hal.h"
#include "FreeRTOS.h"
#include "task.h"
#include "menu_items.h"
#include "menu.h"
#include "config.h"
#include "settings.h"
#include "uart_bridge.h"
#include "oled_common.h"
#include "oled_config.h"
#include <string.h>
#include <stdio.h>

extern "C" {
#include "GFX_SSD1327.h"
#include "GUI_Paint.h"
#include "fonts_old.h"
#include "message.h"
#include "fonts.h"
}

#define DBG if(1)

extern uint8_t pict_gear[][128];
extern bool update_flag;

#ifdef SCREEN_MENU
#define SCREEN_BUF_LEN     30
char screen_str_buf[SCREEN_BUF_LEN];

static void screen_draw_main(uint8_t sel);
static void screen_draw_settings(uint8_t sel);
#endif

#ifdef KEYBOARD_MENU
#define CLI_BUF_LEN     30
char cli_str_buf[CLI_BUF_LEN];

static void cli_draw_main(uint8_t sel);
static void cli_draw_settings(uint8_t sel);
static void cli_print_int_param(char* name, uint32_t val, bool hl);
static void cli_print_str_param(char *name, char *val, bool hl);
#endif

//
void menuChange(void* NewMenu, bool direction) 
{
    if ((void *) NewMenu == NULL)
        return;

    if (selectedMenuItem->Focus) {
        selectedMenuItem->func_change(direction);
        //(*(selectedMenuItem->func_draw))(selectedMenuItem->Select);
    }
    else {
        selectedMenuItem = (menuItem*)NewMenu;
        (*(selectedMenuItem->func_draw))(selectedMenuItem->Select);
    }
}

//
void menuFocus(void) 
{
    // Пункт "Сбросить счетчики"
    if (selectedMenuItem->Select == MCELL_RES) {
        reset_distance();
        return;
    }

    // Пункт "Сохранить настройки"
    if (selectedMenuItem->Select == MCELL_SAVE) {
        settings_save();
        return;
    }
    
    // Главный экран меню. При нажатии кнопки - переход на следующий экран.
    if (selectedMenuItem->Select == MCELL_MAIN) {
        menuChange(NEXT, true);
    }
    
    if (!selectedMenuItem->Focus)
        selectedMenuItem->Focus = true;
    else
        selectedMenuItem->Focus = false;
}

// -------------------------------------------------------------------------- //    
// Отрисовка

// Заставка
void draw_screensaver(void)
{
    Paint_DrawString_EN(25, 52, "TUBOT", &Font24, 0xf, 0x0);
    oled_display();
}

// Главное меню. Отрисовка.
void draw_main(uint8_t sel)
{
    update_flag = true;
               
#ifdef SCREEN_MENU    
    screen_draw_main(sel);
    //screen_draw_settings(sel);
#endif    
    
#ifdef KEYBOARD_MENU    
    cli_draw_main(sel);
#endif    
}

//
void draw_settings(uint8_t sel)
{
    update_flag = true;
    
#ifdef SCREEN_MENU    
    screen_draw_settings(sel);
#endif    
    
#ifdef KEYBOARD_MENU    
    cli_draw_settings(sel);
#endif    
}


//
void empty_func_bool(bool) {}

// -------------------------------------------------------------------------- //    
// Изменение значений параметров

//
void change_factor_1(bool dir)
{
    if (dir) {
        if (settings.factor_1 != FACTOR_1_UP_THR)
            settings.factor_1++;
    }
    else {
        if (settings.factor_1 != FACTOR_1_DOWN_THR)
            settings.factor_1--;
    }
}

//
void change_factor_2(bool dir)
{
    if (dir) {
        if (settings.factor_2 != FACTOR_2_UP_THR)
            settings.factor_2++;
    }
    else {
        if (settings.factor_2 != FACTOR_2_DOWN_THR)
            settings.factor_2--;
    }
}

//
void change_revers(bool dir)
{
    if (settings.revers)
        settings.revers = false;
    else
        settings.revers = true;
}

// Сброс дистанции
void change_reset_distance(bool dir)
{
    reset_distance();
}

// -------------------------------------------------------------------------- //
// Экранное меню OLDED.

#ifdef SCREEN_MENU

// Отрисовка главного экрана
static void screen_draw_main(uint8_t sel)
{
    uint32_t raw_forw_turns, raw_back_turns, dir;
    int total;
    double distance;
    move_t move;
        
    get_raw_params(&raw_forw_turns, &raw_back_turns, &dir);
    get_total(&total);
    distance = get_distance();
    move = get_move();
    
    oled_clear(BLACK);
    
    // Скругленная рамка и логотип
#if 0    
    GFX_DrawRoundRectangle(0, 0, 127, 127, 5, 15);  
    Paint_DrawString_EN(50, 120, "Fly Electronics", &Font8, 0xf, 0x0);
#endif    
    
    // Total
    //memset(screen_str_buf, 0, SCREEN_BUF_LEN);
    //oled_float_right_aligment(distance, 7, screen_str_buf);
    Paint_DrawString_EN(1, 30, "Distance (m):", &Font12, 0xf, 0x0);
    
    memset(screen_str_buf, 0, SCREEN_BUF_LEN);
    GFX_SetFont(font_8x5);
    GFX_SetFontSize(4);
    oled_float_symbol_formated(distance, screen_str_buf);
    GFX_DrawString(4, 64, screen_str_buf, 15, 0);

        
#if 0    
    memset(screen_str_buf, 0, SCREEN_BUF_LEN);
    oled_float_right_aligment(distance, 7, screen_str_buf);
    Paint_DrawString_EN(4, 52, screen_str_buf, &Font24, 0xf, 0x0);
#endif    
    
#if 0        
    // Основнаая рамка
    GFX_DrawRectangle(1, 1, 126, 125, 15);
    
    // Дефолтный шрифт
    GFX_SetFont(font_8x5);
    GFX_SetFontSize(4);

    memset(screen_str_buf, 0, SCREEN_BUF_LEN);
    sprintf(screen_str_buf, "F: %u", raw_forw_turns);
    GFX_DrawString(8, 20, (char*)screen_str_buf, 15, 0);

    memset(screen_str_buf, 0, SCREEN_BUF_LEN);
    sprintf(screen_str_buf, "B: %u", raw_back_turns);
    GFX_DrawString(8, 40, (char*)screen_str_buf, 15, 0);
    
    memset(screen_str_buf, 0, SCREEN_BUF_LEN);
    sprintf(screen_str_buf, "T: %d", total);
    GFX_DrawString(8, 60, (char*)screen_str_buf, 15, 0);
    
    memset(screen_str_buf, 0, SCREEN_BUF_LEN);
    if (move == m_forward)
        sprintf(screen_str_buf, "M: forward");
    else if (move == m_back)
        sprintf(screen_str_buf, "M: back");
    else 
        sprintf(screen_str_buf, "M: stop");
    
    GFX_DrawString(8, 80, (char*)screen_str_buf, 15, 0);
#endif        
    oled_display();
}

// Отрисовка экрана настроек
static void screen_draw_settings(uint8_t sel)
{
    bool select;
    static bool blink = false;
    
    oled_clear(BLACK);
    
    select = sel == MCELL_K1 ? true : false;
   
    if (select) {
        if (selectedMenuItem->Focus == false)
            draw_diameter(select, true);
        else {
            if (blink == true) {
                draw_diameter(true, false);
                blink = false;
            }
            else {
                draw_diameter(select, true);
                blink = true;
            }
        }
    }
    else 
        draw_diameter(select, true);

   
    select = sel == MCELL_K2 ? true : false;
    
    if (select) {
        if (selectedMenuItem->Focus == false)
            draw_gearbox(select, true);
        else {
            if (blink == true) {
                //oled_frame(MENU_3_STR_Y, true);
                draw_gearbox(select, false);
                blink = false;
            }
            else {
                draw_gearbox(select, true);
                blink = true;
            }
        }
    }
    else 
        draw_gearbox(select, true);
    
    
    select = sel == MCELL_REV ? true : false;
    
    if (select) {
        if (selectedMenuItem->Focus == false)
            draw_revers(select, true);
        else {
            if (blink == true) {
                //oled_frame(MENU_5_STR_Y, false);
                draw_revers(select, false);
                blink = false;
            }
            else {
                draw_revers(select, true);
                blink = true;
            }
        }
    }
    else 
        draw_revers(select, true);
        
    
    select = sel == MCELL_RES ? true : false;
    memset(screen_str_buf, 0, SCREEN_BUF_LEN);
    Paint_DrawString_EN(4, MENU_6_STR_Y, "Reset", &Font16, 0xf, 0x0);
    if (select)
        oled_frame(MENU_6_STR_Y, false);
    
    oled_display();
}
#endif

//
void draw_diameter(bool frame, bool is_value)
{
    memset(screen_str_buf, 0, SCREEN_BUF_LEN);
    Paint_DrawString_EN(4, MENU_1_STR_Y, "Diameter:", &Font16, 0xf, 0x0);
    memset(screen_str_buf, 0, SCREEN_BUF_LEN);
    if (is_value) {
        oled_int_right_alignment_post(settings.factor_1, 11, (char*)"mm", screen_str_buf);
        Paint_DrawString_EN(4, MENU_2_STR_Y, screen_str_buf, &Font16, 0xf, 0x0);
    }
    if (frame)
        oled_frame(MENU_1_STR_Y, true);
}

//
void draw_gearbox(bool frame, bool is_value)
{
    memset(screen_str_buf, 0, SCREEN_BUF_LEN);
    Paint_DrawString_EN(4, MENU_3_STR_Y, "Gearbox:", &Font16, 0xf, 0x0);
    memset(screen_str_buf, 0, SCREEN_BUF_LEN);
    if (is_value) {
        oled_int_right_alignment(settings.factor_2, 11, screen_str_buf);
        Paint_DrawString_EN(4, MENU_4_STR_Y, screen_str_buf, &Font16, 0xf, 0x0);
    }
    if (frame)
        oled_frame(MENU_3_STR_Y, true);
}

//
void draw_revers(bool frame, bool is_value)
{
    memset(screen_str_buf, 0, SCREEN_BUF_LEN);
    if (is_value) {
        if (settings.revers == true)
            Paint_DrawString_EN(4, MENU_5_STR_Y, "Revers: yes", &Font16, 0xf, 0x0);
        else
            Paint_DrawString_EN(4, MENU_5_STR_Y, "Revers:  no", &Font16, 0xf, 0x0);
    }
    else {
        Paint_DrawString_EN(4, MENU_5_STR_Y, "Revers:", &Font16, 0xf, 0x0);
    }
    if (frame)
        oled_frame(MENU_5_STR_Y, false);
}

// -------------------------------------------------------------------------- //
// Консольное меню. Вспомогательные функции.
#ifdef KEYBOARD_MENU
static void cli_draw_main(uint8_t sel)
{
    uint32_t raw_forw_turns, raw_back_turns, dir;
    double distance = get_distance();
    
    get_raw_params(&raw_forw_turns, &raw_back_turns, &dir);
    
    DBG printf("\033c");
    DBG printf("~~~ MAIN SCREEN ~~~\r\n\n");
   
    DBG printf("Total (m): %.2f\r\n", distance);
#if 0    
    cli_print_int_param((char*)"Turns forward: ", raw_forw_turns, false);
    cli_print_int_param((char*)"Turns back   : ", raw_back_turns, false);
    cli_print_int_param((char*)"Direction    : ", dir, false);
#endif    
    update_flag = true;
}

//
static void cli_draw_settings(uint8_t sel)
{
    bool select;
    
    DBG printf("\033c");
    DBG printf("~~~ SETTINGS SCREEN ~~~\r\n\n");
    
    select = sel == MCELL_K1 ? true : false;
    cli_print_int_param((char*)"Factor 1:   ", settings.factor_1, select);
    
    select = sel == MCELL_K2 ? true : false;
    cli_print_int_param((char*)"Factor 2:   ", settings.factor_2, select);
    
    select = sel == MCELL_REV ? true : false;
    if (settings.revers == true)
        cli_print_str_param((char*)"Revers:     ", (char*)"yes", select);
    else
        cli_print_str_param((char*)"Revers:     ", (char*)"no", select);
    
    select = sel == MCELL_RES ? true : false;
    cli_print_str_param((char*)"Reset counters", (char*)"", select);
   
    //DBG printf("\r\nSelect item: %u\r\n", sel);
}

//
static void cli_print_int_param(char* name, uint32_t val, bool hl)
{
    memset(cli_str_buf, 0, CLI_BUF_LEN);
    
    if (hl)
        sprintf(cli_str_buf, "\033[7m%s%d\033[0m\r\n", name, val);
    else
        sprintf(cli_str_buf, "%s%d\r\n", name,  val);
    
    DBG printf("%s", cli_str_buf);
}

//
static void cli_print_str_param(char *name, char *val, bool hl)
{
    memset(cli_str_buf, 0, CLI_BUF_LEN);
    
    if (hl)
        sprintf(cli_str_buf, "\033[7m%s%s\033[0m\r\n", name, val);
    else
        sprintf(cli_str_buf, "%s%s\r\n", name,  val);
    
    DBG printf("%s", cli_str_buf);
}

#endif