small_water_meter_4g_src/Users/lcd/lcd_ghg102.c

#include "board.h"
#include "lcd_disp.h"
#include "tdc_tof.h"
#include "param.h"
#include "app_nb.h"
#include "check.h"
#include "alarm.h"

uint8_t g_lcd_display_check_bw_cum_flow = 0; /////
uint8_t lcd_disp_pass_flag = 0;              // wxl20260423 用于显示pass字段
uint8_t cumulative_flow_display_update_flag = 0;  //add by HBR 20260604
uint8_t back_to_main_flag = 0;   // add by HBR 20260618,其他页返回主页标志（1:循环中，0:停止）
uint8_t lcd_check_first_page_flag = 0;   // add by HBR 20260618,进入检表模式后，首次强制显示正向累积页
extern uint8_t instant_flow_zero_flag ;
extern uint8_t G_KEY_CAN_DEEP_SLEEP ;
extern uint8_t DispMem_Dec[10];

//'-': 00000100
//'0': 11101011 '1': 01100000 '2': 11000111 '3': 11100101 '4': 01101100
//'5': 10101101 '6': 10101111 '7': 11100000 '8': 11101111 '9': 11101101
//'=': 00000101
//'C': 10001011 'E': 10001111 'H': 01101110 'I': 01100000 'U': 01101011
//'d': 01100111 'n': 00100110 'o': 00100111 'r': 00000110 't': 00001111

// LED abcdefg dp
// a:bit7,b:bit6,c:bit5 d:bit0, e:bit1,f:bit3,g:bit2, dp:bit4

// a b c dp f g e d
// 7 6 5 4  3 2 1 0
const uint8_t LCD_CharAry[] = {
    0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
    0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
    0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
    0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
    0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
    0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x04u, // 0x04: '-'
    0x00u, 0x00u,
    0xEBu, 0x60u, 0xC7u, 0xE5u, 0x6Cu, 0xADu, 0xAFu, 0xE0u, //'0' - '7'
    0xEFu, 0xEDu,                                           //'8' - '9'
    0x00u, 0x00u, 0x00u,
    0x05u, // '='
    0x00u, 0x00u, 0x00u,
    0xEEu, 0xEFu, 0x8Bu, 0xEBu, 0x8Fu, 0x8Eu, 0xAFu, 0x6Eu, // 'A' - 'H'
    0x60u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0xCEu, // 'I' - 'P'
    0x00u, 0x00u, 0xADu, 0x00u, 0x6Bu, 0x00u, 0x00u, 0x00u, // 'Q' - 'X'
    0x00u, 0x00u,                                           // 'Y' - 'Z'
    0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
    0x00u, 0x00u, 0x00u, 0x67u, 0x00u, 0x00u, 0x00u, 0x00u, // 'a' - 'h'
    0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x26u, 0x27u, 0x00u, // 'i' - 'p'
    0x00u, 0x06u, 0x00u, 0x0Fu, 0x00u, 0x00u, 0x00u, 0x00u, // 'q' - 'x'
    0x00u, 0x00u,                                           // 'x' - 'z'
    0x00u, 0x00u, 0x00u, 0x00u, 0x00u};

en_lcd_page_t LcdPage = disp_cumflow;
uint16_t LcdTimer = 0;

void lcd_set_timer(uint16_t len)
{
    LcdTimer = len;
}

//add by HBR 20260622
void lcd_enter_check_mode(void)         
{
    lcd_check_first_page_flag = 1;
    back_to_main_flag = 1;
    LcdPage = disp_cumflow;
}

void lcd_timer_countdown(void) // waiting for modify
{
    // add code here
}

void lcd_temp_err(void)                            //add by HBR 20260603,err7 display
{
    LCD_ClrAll();                                  //add by HBR 20260608
    LCD_DispStr("Err7", 4, 4);
}

void lcd_show_ot_countdown(uint16_t ot_count)     //add by HBR 20260603,ot display
{  
   LCD_ClrAll();
   LCD_DispStr("ot", 2, 2);
   LCD_DispDec(ot_count,5,3);

}

void lcd_page_switch(void)
{
    LcdPage++;

    if (LcdPage >= disp_end)
    {
        LcdPage = disp_cumflow;
    }

    if (LcdPage != disp_cumflow)
    {
        if(CheckRxState()!=1)                      //add by HBR 20260603
        {
            lcd_set_timer(30);
        }
    }
}

//modify by HBR 20260622,instant flow display
void lcd_instant_flow(void)                        
{
    
    DispMem_Status |= LCD_STATUS_INSTANT;
    DispMem_Status |= LCD_STATUS_M3;
    DispMem_Status |= LCD_STATUS_SLASH;
    DispMem_Status |= LCD_STATUS_HOUR; 
    
   if(TdcItf.bw_flow_flag)
   {
     DispMem_Status |= LCD_STATUS_BACKWARD;         
   }   
    else
   {
    
     DispMem_Status |= LCD_STATUS_FORWARD;               
   }
    
    if (alarm_status(ERR_BLANK_PIPE))
    {

     LCD_DispFloat(0.0f, 0, 10, 7);
     DispMem_Status &= ~(LCD_STATUS_BACKWARD|LCD_STATUS_FORWARD); 
    }
    else
   {
     LCD_DispFloat(FlowVol * 0.000001f * 3600, 0, 10, 7);
     if(instant_flow_zero_flag)
    {
       instant_flow_zero_flag=0;
       DispMem_Status &= ~(LCD_STATUS_BACKWARD|LCD_STATUS_FORWARD);
    } 
   } 
   
}

//modify by HBR 20260622
void lcd_cumflow(void)
{
 
//    DispMem_Status &= ~(LCD_STATUS_KPA |
//                        LCD_STATUS_DEGREE |
//                        LCD_STATUS_M3 |
//                        LCD_STATUS_YUAN |
//                        LCD_STATUS_SLASH |
//                        LCD_STATUS_HOUR |
//                        LCD_STATUS_CIRCLE |
//                        LCD_STATUS_INSTANT |
//                        LCD_STATUS_BACKWARD);






   // 每 3 秒切换一次：0-2 秒显示累积，3-5 秒显示瞬时，周期 6 秒

    uint8_t cycle_length;
    uint8_t  cumu_display_counts;
    
       if (alarm_status(ERR_BLANK_PIPE)) {
        cycle_length = 2;
        cumu_display_counts = 1;
    } else {
        cycle_length = 8;
        cumu_display_counts = 4;
    }
    
    uint32_t cnt_int = get_rtc_cnt_int();   
        
    // 每 3 秒切换一次：0-2 秒显示累积，3-5 秒显示瞬时，周期 6 秒
    if((cnt_int % cycle_length) <  cumu_display_counts || back_to_main_flag)                                             
    {
        back_to_main_flag=0;                               //add by HBR 20260622
    // ========== 显示正向累积流量 ==========
        DispMem_Status |= LCD_STATUS_FORWARD;     // “正向”符号
        DispMem_Status |= LCD_STATUS_CUM;         // “累积”符号
        DispMem_Status |= LCD_STATUS_M3;          // “m3”单位
        LCD_DispDouble(FwCumFlow * 0.000001, 0, 10, 7);
    }
    else
    {
    // ========== 显示瞬时流量 ==========
        cumulative_flow_display_update_flag = 1;  // 标记累积流量显示已更新       
        lcd_instant_flow();                       // 内部会配置 m3/h 等符号
    }
    
    
}

void lcd_bw_cumflow(void)
{
    DispMem_Status |= LCD_STATUS_CUM;
    DispMem_Status |= LCD_STATUS_BACKWARD;
    DispMem_Status |= LCD_STATUS_M3;
    LCD_DispDouble(BwCumFlow * 0.000001, 0, 10, 7);
}

 //modify by HBR 20260622,check display
void lcd_check_cumflow(void)                              
{      
    static uint8_t lcd_instant_swtich_forward_flag=0;
    static uint8_t lcd_instant_swtich_backward_flag=0;
    uint8_t cycle_length;
    uint8_t  cumu_display_counts;   
    uint32_t cnt_int = get_rtc_cnt_int();
    
    //add by HBR 20260622
    if (lcd_check_first_page_flag)
    {
        lcd_check_first_page_flag = 0;
        DispMem_Status |= LCD_STATUS_FORWARD;
        DispMem_Status |= LCD_STATUS_CUM;
        DispMem_Status |= LCD_STATUS_M3;
        LCD_DispDouble(FwCumFlow * 0.000001, 0, 10, 4);
        return;
    }
    
    if (alarm_status(ERR_BLANK_PIPE)) 
    {  
        cycle_length = 2;
        cumu_display_counts = 1;
    } 
    else 
    {
        cycle_length = 8;
        cumu_display_counts = 4;
    }
     
     if (g_lcd_display_check_bw_cum_flow == 0)
    {

        
             if(lcd_instant_swtich_backward_flag)
            {
               cnt_int=0;   
            }  
           

          if ((cnt_int % cycle_length) <  cumu_display_counts || G_KEY_CAN_DEEP_SLEEP==0)  
          { 
              DispMem_Status |= LCD_STATUS_FORWARD;
              DispMem_Status |= LCD_STATUS_CUM;
              DispMem_Status |= LCD_STATUS_M3;
              LCD_DispDouble(FwCumFlow * 0.000001, 0, 10, 4);
              lcd_instant_swtich_backward_flag=0;  
          }
          else 
          {
                      // ========== 显示瞬时流量 ==========
              cumulative_flow_display_update_flag = 1;  // 标记累积流量显示已更新 
              lcd_instant_swtich_forward_flag=1;                       
              lcd_instant_flow();                       // 内部会配置 m3/h 等符号             

          } 
      
    }   
    else
    {  
        
          if(lcd_instant_swtich_forward_flag)
         {
           cnt_int=0;   
         } 
           
            if ((cnt_int % cycle_length) <  cumu_display_counts || G_KEY_CAN_DEEP_SLEEP==0)   
          { 
              DispMem_Status |= LCD_STATUS_CUM;
              DispMem_Status |= LCD_STATUS_BACKWARD;
              DispMem_Status |= LCD_STATUS_M3;
              LCD_DispDouble(BwCumFlow * 0.000001, 0, 10, 4);
              lcd_instant_swtich_forward_flag=0; 
          }   
            else 
          {
                      // ========== 显示瞬时流量 ==========
              cumulative_flow_display_update_flag = 1;  // 标记累积流量显示已更新 
              lcd_instant_swtich_backward_flag=1;             
              lcd_instant_flow();                       // 内部会配置 m3/h 等符号   
       
          } 
      
    }     
}

void lcd_dev_id(uint8_t id_pos, uint8_t len)
{
    uint32_t i;
    uint8_t disp_num_pos = 0;

    Param_t *param;

    GetParam(&param);

    if (id_pos == 0)
    {
        LCD_DispStr("Id=", 0, 3);
        disp_num_pos += 3;
    }

    for (i = 0; i < len; i++)
    {
        LCD_DispDec(BcdToOct(param->dev_id[id_pos + i]), disp_num_pos + i * 2, 2);
        if (BcdToOct(param->dev_id[id_pos + i]) < 10)
        {
            LCD_DispDec(0, disp_num_pos + i * 2, 1);
        }
    }
}

void lcd_dev_id_part1(void)
{
    lcd_dev_id(0, 3);
}

void lcd_dev_id_part2(void)
{
    lcd_dev_id(3, 3);
}

//modify by HBR 20260608
void lcd_temp(void)
{
     if (WaterTemp > 100.0f || WaterTemp < 0.0f)
    {
        lcd_temp_err();                                 //add by HBR 20260603,err7 display
    }
    else
    {
        DispMem_Status |= LCD_STATUS_DEGREE;
        LCD_DispFloat(WaterTemp, 0, 10, 9);
    }    

}

void lcd_bat(void)
{
    LCD_DispStr("U=", 3, 2);
    LCD_DispFloat((float)McuVbat * 1.0f / 1000, 5, 3, 1);
}

void lcd_date(void)
{
    uint8_t year;
    uint8_t month;
    uint8_t day;

    get_rtc_date(&year, &month, &day);
    year = BcdToOct(year);
    month = BcdToOct(month);
    day = BcdToOct(day);

    LCD_DispDec(year, 2, 2);
    LCD_DispStr("-", 4, 1);
    LCD_DispDec(month / 10, 5, 1);
    LCD_DispDec(month % 10, 6, 1);
    LCD_DispStr("-", 7, 1);
    LCD_DispDec(day/ 10, 8, 1);
    LCD_DispDec(day% 10, 9, 1);
}

void lcd_time(void)
{
    uint8_t hour;
    uint8_t min;
    uint8_t sec;

    get_rtc_time(&hour, &min, &sec);
    hour = BcdToOct(hour);
    min = BcdToOct(min);
    sec = BcdToOct(sec);
    
    LCD_DispDecAllPos(hour, 3, 2);
    LCD_DispPoint(LCD_POINT5);
    LCD_DispDecAllPos(min, 5, 2);
    LCD_DispPoint(LCD_POINT7);
    LCD_DispDecAllPos(sec, 7, 2);
}

void lcd_imei(uint8_t imei_pos, uint8_t len)
{
    int i;
    uint8_t num_disp_pos = 0;
    Nb_Run_t *nb_run;

    GetNbRun(&nb_run);
    if (imei_pos == 0)
    {
        LCD_DispStr("EId=", 0, 4);
        num_disp_pos += 4;
    }

    for (i = 0; i < len; i++)
    {
        LCD_DispDec((nb_run->imei[imei_pos + i] - '0'), num_disp_pos + i, 1);
    }
}

void lcd_imei_part1(void)
{
    lcd_imei(0, 6);
}

void lcd_imei_part2(void)
{
    lcd_imei(6, 10);
}

void lcd_ccid(uint8_t ccid_pos, uint8_t len)
{
    int i;
    uint8_t num_disp_pos = 0;
    Nb_Run_t *nb_run;

    GetNbRun(&nb_run);
    if (ccid_pos == 0)
    {
        LCD_DispStr("CId=", 0, 4);
        num_disp_pos += 4;
    }

    for (i = 0; i < len; i++)
    {
        LCD_DispDec((nb_run->ccid[ccid_pos + i] - '0'), num_disp_pos + i, 1);
    }
}

void lcd_ccid_part1(void)
{
    lcd_ccid(0, 6);
}

void lcd_ccid_part2(void)
{
    lcd_ccid(6, 10);
}

void lcd_ccid_part3(void)
{
    lcd_ccid(16, 4);
}

void lcd_pipe_dn(void)
{
    Param_t *param;

    GetParam(&param);

    LCD_DispStr("dn", 4, 2);

    if (param->diameter >= 100)
    {
        LCD_DispDec(param->diameter, 6, 3);
    }
    else
    {
        LCD_DispDec(param->diameter, 6, 2);
    }
}

void lcd_ver(void)
{
    back_to_main_flag=1;                                       //add by HBR 20260622
    cumulative_flow_display_update_flag=1;                     //add by HBR 20260604
    
    Param_t *param;

    GetParam(&param);

    LCD_DispStr("no", 3, 2);

    LCD_DispPoint(LCD_POINT5);
    LCD_DispDec(VER_TYPE, 5, 1);
    LCD_DispPoint(LCD_POINT6);
    LCD_DispDec(VER_OPERATOR, 6, 1);
    LCD_DispPoint(LCD_POINT7);
    LCD_DispDec(VER_MODULE, 7, 1);
    LCD_DispPoint(LCD_POINT8);
    LCD_DispDec(VER_FIRMWARE, 8, 1);
}

void lcd_run_time(void)
{
    uint32_t run_time = get_rtc_cnt_int();

    LCD_DispDecAllPos(run_time, 0, 10);
}

void lcd_low_power(void)
{
    boolean_t flag = McuVbat < LOW_PWR_THRESHOLD;

    if (flag)
    {
        DispMem_Status |= LCD_STATUS_LOWPWR;
    }
    else
    {
        DispMem_Status &= ~LCD_STATUS_LOWPWR;
    }
}
#define RSRP_LEVEL1 -140
#define RSRP_LEVEL2 -115
#define RSRP_LEVEL3 -105
#define RSRP_LEVEL4 -95
#define RSRP_LEVEL5 -85

const int16_t rsrp_level[5] = {RSRP_LEVEL1, RSRP_LEVEL2, RSRP_LEVEL3, RSRP_LEVEL4, RSRP_LEVEL5};
void lcd_nb_sign(void)
{
    Nb_Run_t *nb_run;

    GetNbRun(&nb_run);
    if (nb_run->rsrp == 0)
    {
        return;
    }

    if (nb_run->rsrp >= RSRP_LEVEL1)
    {
        DispMem_Status |= LCD_STATUS_BAR1;
    }

    if (nb_run->rsrp >= RSRP_LEVEL2)
    {
        DispMem_Status |= LCD_STATUS_BAR2;
    }

    if (nb_run->rsrp >= RSRP_LEVEL3)
    {
        DispMem_Status |= LCD_STATUS_BAR3;
    }

    if (nb_run->rsrp >= RSRP_LEVEL4)
    {
        DispMem_Status |= LCD_STATUS_BAR4;
    }

    if (nb_run->rsrp >= RSRP_LEVEL5)
    {
        DispMem_Status |= LCD_STATUS_BAR5;
    }
}

void lcd_check_pulse(void)
{
    uint32_t pulse = GetCheckPulse();

    LCD_DispDecAllPos(pulse, 4, 6);
}

void lcd_check_rx_err(void)
{
    LCD_ClrAll();                                //add by HBR 20260604
    LCD_DispStr("Err-H", 2, 5);
}

lcd_page_func LcdPageFunc[] = {
    lcd_cumflow,
    lcd_bw_cumflow,
//    lcd_instant_flow,                           //add by HBR 20260603
    lcd_dev_id_part1,
    lcd_dev_id_part2,
    lcd_temp,
    lcd_bat,
    lcd_date,
    lcd_time,
    lcd_imei_part1,
    lcd_imei_part2,
    lcd_ccid_part1,
    lcd_ccid_part2,
    lcd_ccid_part3,
    lcd_pipe_dn,
    lcd_ver};

void lcd_show_page(void)
{
    
    if (LcdPage < disp_end)
    {
        LcdPageFunc[LcdPage]();
    }
}

void lcd_blank_disp(void)
{
     if (TdcItf.blank_flag)
    {
        DispMem_Status |= LCD_STATUS_CIRCLE;
    }

}

void LcdHandler(void)
{
    if(LcdPage != disp_cumflow && LcdPage != disp_bw_cumflow && GetCheckState() != CHECKING)  //add by HBR 20260604
    {
      LCD_ClrDec();
    }
    
    LCD_ClrStatus();
    CheckRxState();                                 //add by HBR 20260603,check display           
    
    if (LcdTimer > 0 && --LcdTimer == 0)
    {
        cumulative_flow_display_update_flag=1;      //add by HBR 20260604
        
        if (LcdPage != disp_cumflow)
        {
            LcdPage = disp_cumflow;
        }
    }

    if (GetCheckState() == CHECKING)
    {
        if (CheckRxState())
        {
            lcd_check_rx_err();
        }
        else
        {
            lcd_check_cumflow();                    //add by HBR 20260603,check display
        }
    }
    else
    {
        if (LcdTimer > 0 && CheckRxState())
        {
            lcd_check_rx_err();
        }
        else
        {
            lcd_show_page();
        }
    }
    if (tof_state & TOF_ST_TEST) 
    {
         lcd_show_ot_countdown(ot_count_down);   // add,HBR,20260602,ot display
    }

    lcd_low_power();
    lcd_nb_sign();
    lcd_blank_disp();
    
    LCD_Update();
}

//////show "pass" word noting key press for 5 minute,now nb upload beginning//////////////////////////////
void lcd_show_key_trigger_report_pass(void)
{
    // wait for add code here
    cumulative_flow_display_update_flag=1;                  //add by HBR 20260604
    LCD_ClrAll();
    LCD_DispStr("PASS", 4, 4);
    lcd_low_power();
    lcd_nb_sign();
    LCD_Update();
}

//////////show "ot Err" code for indicate ot para check err///////////////////
void lcd_show_ot_error(void)
{
    // waite for add code here
    cumulative_flow_display_update_flag=1;                  //add by HBR 20260604
    LCD_ClrAll();
    LCD_DispStr("ot-Err", 3, 6);
    lcd_low_power();
    lcd_nb_sign();
    LCD_Update();
}