#include "board.h"
#include "string.h"
#include "tdc_tof.h"
#include "stdlib.h"
#include "ymodem.h"
#include "smp_shell.h"
#include "app_nb.h"
#include "bill.h"
#include "param.h"
#include "eeprom.h"
#include "alarm.h"

extern uint8_t NbIntStep;

void Cmd_Ver(uint8_t argc, char **argv)
{
    //extern uint32_t SOFT_VER;
    extern uint32_t BUILD_DATE;
    extern uint16_t BUILD_TIME;

    printf("soft_ver: %c%d.%d.%d.%d\n", SOFT_VER[0], SOFT_VER[1], SOFT_VER[2], SOFT_VER[3],SOFT_VER[4]);
    printf("build_time: %d/%d/%d %d:%d\n", BUILD_DATE>>16, (uint8_t)(BUILD_DATE>>8), (uint8_t)BUILD_DATE,
        (uint8_t)(BUILD_TIME>>8), (uint8_t)BUILD_TIME);
}

void Cmd_Plot(uint8_t argc, char **argv)
{
    if (argc==2){
        if (strcmp(argv[1], "on")==0){
            SerPlot_Mode &= ~SERPLOT_DMATX_OFF;
        } else if (strcmp(argv[1], "off")==0){
            SerPlot_Mode |= SERPLOT_DMATX_OFF;
        }
    }
}

void Cmd_Reset(uint8_t argc, char **argv)
{
    uint32_t prm1;

    if (argc>=2){
        str2int(argv[1], &prm1);

        if (prm1>30){
            prm1 = 30;
        }
        us_delay(prm1*1000);
    }

    printf("soft reset will be done.\n\n");
    while(FinSh_Txbuf_Busy()){
        // wait until Txbuf done
    }

    rt_hw_interrupt_disable();
    us_delay(10000);
    NVIC_SystemReset();
}

void Cmd_Date(uint8_t argc, char **argv)
{
    uint16_t flag;
    uint32_t tmp;

    uint8_t y_bcd;
    uint8_t m_bcd;
    uint8_t d_bcd;

    flag = 0;

    if (argc == 1) {
        get_rtc_date(&y_bcd, &m_bcd, &d_bcd);
        printf("20%02x-%02x-%02x\n", y_bcd, m_bcd, d_bcd);
    } else if (argc == 2) {
        if (strcmp(argv[1], "help")==0) {
            flag |= 0x8000u;
        } else {
            flag |= 0x1u;
        }
    } else if (argc == 4) {
        str2int(argv[1], &tmp);
        y_bcd = OctToBcd((uint8_t)(tmp % 2000));
        str2int(argv[2], &tmp);
        m_bcd = OctToBcd((uint8_t)tmp);
        str2int(argv[3], &tmp);
        d_bcd = OctToBcd((uint8_t)tmp);

        set_rtc_date(y_bcd, m_bcd, d_bcd);
    } else {
        flag |= 0x1u;
    }

    if (flag) {
        if (flag&0x1u) {
            printf("    unknown cmd. only the following cmds supported.\n");
        }

        printf("    date [<year> <month> <day>]\n");
        printf("            :get/set date.\n");
    }
}

void Cmd_Time(uint8_t argc, char **argv)
{
    uint16_t flag;
    uint32_t tmp;

    uint8_t s_bcd;
    uint8_t m_bcd;
    uint8_t h_bcd;

    flag = 0;

    if (argc == 1) {
        get_rtc_time(&h_bcd, &m_bcd, &s_bcd);
        printf("%02xh:%02xm:%02xs\n", h_bcd, m_bcd, s_bcd);
    } else if (argc == 2) {
        if (strcmp(argv[1], "help")==0) {
            flag |= 0x8000u;
        } else {
            flag |= 0x1u;
        }
    } else if (argc == 4) {
        str2int(argv[1], &tmp);
        h_bcd = OctToBcd((uint8_t)tmp);
        str2int(argv[2], &tmp);
        m_bcd = OctToBcd((uint8_t)tmp);
        str2int(argv[3], &tmp);
        s_bcd = OctToBcd((uint8_t)tmp);

        set_rtc_time(h_bcd, m_bcd, s_bcd);
    } else {
        flag |= 0x1u;
    }

    if (flag) {
        if (flag&0x1u) {
            printf("    unknown cmd. only the following cmds supported.\n");
        }

        printf("    time [<hour> <minute> <second>]\n");
        printf("            :get/set time.\n");
    }
}

extern Param_t Param;

#define FLASH_ADDR_SAVEPARAM    (0x00008000u - 512)
#define SAVEPARAM_HEAD_SIZE     (32)
#define MCUFLASH_SAVED_LEN      (72)//yw 112->72
/*
void SaveParam(void) {
    uint32_t param_len = 0;
    uint32_t param_crc;
    uint8_t *data;
    McuFlash_WP_t WP;
    uint8_t i;
    Nb_Run_t *nb_run;

    GetNbRun(&nb_run);

    McuFlash_Unlock();

    // erase Flahs
    McuFlash_EraseSegment(FLASH_ADDR_SAVEPARAM, 512);

    data = (uint8_t *)(FLASH_ADDR_SAVEPARAM + SAVEPARAM_HEAD_SIZE);
    McuFlash_OpenWP(FLASH_ADDR_SAVEPARAM + SAVEPARAM_HEAD_SIZE, &WP);

    // write param
    for (i = 0; i < MUX_CH_NUM; i++) {
        McuFlash_Buf2WP((uint8_t *)&TdcItf.path_skew[i], 4, &WP);
        param_len += 1;
    }
    McuFlash_Buf2WP((uint8_t *)&TdcItf.pipe_coe, 4, &WP);
    param_len += 1;
    McuFlash_Buf2WP((uint8_t *)nb_run->imei, 16, &WP);
    param_len += 4;
    McuFlash_Buf2WP((uint8_t *)nb_run->ccid, 32, &WP);
    param_len += 8;
    McuFlash_Buf2WP(TdcItf.mux_ch_no, sizeof(TdcItf.mux_ch_no), &WP);
    param_len += 1;
    McuFlash_Buf2WP((uint8_t *)&Param, sizeof(Param), &WP);
    param_len += (sizeof(Param) / 4);

    McuFlash_CloseWP(&WP);

    // calculate CRC
    param_crc = 0xFFFFFFFFu;
    param_crc = com_crc32L_next(param_crc, data, 4*param_len, 0xEDB88320);

    McuFlash_OpenWP(FLASH_ADDR_SAVEPARAM, &WP);

    // write header
    McuFlash_Buf2WP((uint8_t *)&param_len, 4, &WP);
    McuFlash_Buf2WP((uint8_t *)&param_crc, 4, &WP);

    McuFlash_CloseWP(&WP);

    McuFlash_Lock();
}*/

void Cmd_SaveParam(uint8_t argc, char **argv)
{
    SaveParam();
}
/*
int32_t LoadParam(void) {
    uint32_t param_len;
    uint32_t param_crc;
    uint32_t check_crc;
    uint32_t *data;
    uint8_t i;
    Nb_Run_t *nb_run;

    GetNbRun(&nb_run);

    data = (uint32_t *)(FLASH_ADDR_SAVEPARAM);
    param_len = *data++;
    param_crc = *data;

    if (param_len>120 || param_len != MCUFLASH_SAVED_LEN){
        return(1);
    }

    // calculate CRC
    data = (uint32_t *)(FLASH_ADDR_SAVEPARAM + SAVEPARAM_HEAD_SIZE);
    check_crc = 0xFFFFFFFFu;
    check_crc = com_crc32L_next(check_crc, (uint8_t *)data, 4*param_len, 0xEDB88320);

    if (check_crc!=param_crc){
        return(2);
    }

    for (i = 0; i < MUX_CH_NUM; i++) {
        memcpy(&TdcItf.path_skew[i], data++, 4);
    }
    memcpy(&TdcItf.pipe_coe, data++, 4);
    memcpy(nb_run->imei, data, 16);
    nb_run->imei[16] = 0;
    data += 4;
    memcpy(nb_run->ccid, data, 32);
    nb_run->ccid[31] = 0;
    data += 8;
    memcpy(TdcItf.mux_ch_no, data++, 4);
    memcpy(&Param, data, sizeof(Param));
    data += (sizeof(Param) / 4);

    return(0);
}*/

#ifndef BOOTLOADER_ENABLE
const uint32_t crc32tab[] =
{
    0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL,
    0x076dc419L, 0x706af48fL, 0xe963a535L, 0x9e6495a3L,
    0x0edb8832L, 0x79dcb8a4L, 0xe0d5e91eL, 0x97d2d988L,
    0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, 0x90bf1d91L,
    0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
    0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L,
    0x136c9856L, 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL,
    0x14015c4fL, 0x63066cd9L, 0xfa0f3d63L, 0x8d080df5L,
    0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, 0xa2677172L,
    0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
    0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L,
    0x32d86ce3L, 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L,
    0x26d930acL, 0x51de003aL, 0xc8d75180L, 0xbfd06116L,
    0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, 0xb8bda50fL,
    0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
    0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL,
    0x76dc4190L, 0x01db7106L, 0x98d220bcL, 0xefd5102aL,
    0x71b18589L, 0x06b6b51fL, 0x9fbfe4a5L, 0xe8b8d433L,
    0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, 0xe10e9818L,
    0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
    0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL,
    0x6c0695edL, 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L,
    0x65b0d9c6L, 0x12b7e950L, 0x8bbeb8eaL, 0xfcb9887cL,
    0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, 0xfbd44c65L,
    0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
    0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL,
    0x4369e96aL, 0x346ed9fcL, 0xad678846L, 0xda60b8d0L,
    0x44042d73L, 0x33031de5L, 0xaa0a4c5fL, 0xdd0d7cc9L,
    0x5005713cL, 0x270241aaL, 0xbe0b1010L, 0xc90c2086L,
    0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
    0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L,
    0x59b33d17L, 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL,
    0xedb88320L, 0x9abfb3b6L, 0x03b6e20cL, 0x74b1d29aL,
    0xead54739L, 0x9dd277afL, 0x04db2615L, 0x73dc1683L,
    0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
    0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L,
    0xf00f9344L, 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL,
    0xf762575dL, 0x806567cbL, 0x196c3671L, 0x6e6b06e7L,
    0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, 0x67dd4accL,
    0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
    0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L,
    0xd1bb67f1L, 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL,
    0xd80d2bdaL, 0xaf0a1b4cL, 0x36034af6L, 0x41047a60L,
    0xdf60efc3L, 0xa867df55L, 0x316e8eefL, 0x4669be79L,
    0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
    0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL,
    0xc5ba3bbeL, 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L,
    0xc2d7ffa7L, 0xb5d0cf31L, 0x2cd99e8bL, 0x5bdeae1dL,
    0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, 0x026d930aL,
    0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
    0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L,
    0x92d28e9bL, 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L,
    0x86d3d2d4L, 0xf1d4e242L, 0x68ddb3f8L, 0x1fda836eL,
    0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, 0x18b74777L,
    0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
    0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L,
    0xa00ae278L, 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L,
    0xa7672661L, 0xd06016f7L, 0x4969474dL, 0x3e6e77dbL,
    0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, 0x37d83bf0L,
    0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
    0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L,
    0xbad03605L, 0xcdd70693L, 0x54de5729L, 0x23d967bfL,
    0xb3667a2eL, 0xc4614ab8L, 0x5d681b02L, 0x2a6f2b94L,
    0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, 0x2d02ef8dL
};

uint32_t upgrade_pkg_crc32(const uint8_t *buf, uint32_t size)
{
    uint32_t i, crc;
    uint32_t crc_l;

    crc = 0xFFFFFFFF;

    for (i = 0; i < size; i++)
    {
        crc = crc32tab[(crc ^ buf[i]) & 0xff] ^ (crc >> 8);
    }
    crc ^= 0xFFFFFFFF;

    ToggleEndian((uint8_t *)(&crc), (uint8_t *)(&crc_l), 4, 1);

    return(crc_l);
}
#endif

void Cmd_Upgrade(uint8_t argc, char **argv)
{
    uint16_t res;
    uint16_t flag;
    uint32_t crc_chk;
    int16_t i;
    McuFlash_WP_t WP;

    flag = 0;
    if (argc>=2){
        if (strcmp(argv[1], "help")==0) {
            flag |= 0x8000u;
        } else if (strcmp(argv[1], "dup")==0 || strcmp(argv[1], "bin")==0) {
            printf("Ymodem RX in MCU side is ready.\n");
            printf("please start Ymodem TX in PC side within 45 seconds.\n");
            printf("throughput is 0 in first dozens of seconds because of erasing.\n");
            printf("normally the downloading will take dozens of seconds.\n");

            Finsh_Uart_Mode |= YMODEM_UPGRADE_ON;

            ymodem_cntxt.Buf = malloc(YMODEM_BUF_DEPTH);
            if (strcmp(argv[1], "bin")==0) {
                ymodem_cntxt.MaxSize   = 96*1024-32;
                ymodem_cntxt.FlashAddr = 0x00020020u;
            } else {
                ymodem_cntxt.MaxSize   = 32*1024;
                ymodem_cntxt.FlashAddr = 0x00038000u;
            }
            res = ymodem_rx_file(&ymodem_cntxt);

            Finsh_Uart_Mode &= ~YMODEM_UPGRADE_ON;

            if (res==0 && strcmp(argv[1], "bin")==0) {
                crc_chk = upgrade_pkg_crc32((uint8_t *)0x00020020u, ymodem_cntxt.Fsize);

                memcpy(ymodem_cntxt.Buf  , &(ymodem_cntxt.Fsize), 4);
                memcpy(ymodem_cntxt.Buf+4, &crc_chk             , 4);
                for(i=8; i<32; i++){
                    ymodem_cntxt.Buf[i] = 0x00u;
                }

                McuFlash_Unlock();

                McuFlash_OpenWP(0x00020000u, &WP);
                McuFlash_Buf2WP(ymodem_cntxt.Buf, 32, &WP);
                McuFlash_CloseWP(&WP);

                McuFlash_Lock();
            }

            us_delay(100000);   // 100 ms
            if (res==0){
                printf("%d bytes received.\n", ymodem_cntxt.Fsize);
            } else if (res==1){
                printf("ymodem failed!!!\n");
            } else if (res==2){
                printf("file size is over, drop it!!!\n");
            }
            free(ymodem_cntxt.Buf);
        } else {
            flag |= 0x1u;
        }
    } else {
        flag |= 0x1u;
    }

    if (flag) {
        if (flag&0x1u){
            printf("    unknown cmd. only the following cmds supported.\n");
        }
        printf("    upgrade dup\n");
        printf("        :start Y-modem transfer DUP from PC to MCU flash.\n");
        printf("    upgrade bin\n");
        printf("        :start Y-modem transfer BIN from PC to MCU flash.\n");
        printf("\n");
    }
}

void Cmd_Adc(uint8_t argc, char **argv)
{
    adc_get();

    printf("Temperature of MCU is %3.1fC\n", McuTemp);
    printf("Voltage of VCC is %dmV\n", McuVcc);
    printf("Voltage of VBAT is %dmV\n", McuVbat);
    printf("Voltage of VTxBAT is %dmV\n", McuVTxbat);

    printf("Water pressure is %.3fMPa\n", WaterPressure);
}

extern uint32_t test_var_flag;
void Cmd_Pipe(uint8_t argc, char **argv)
{
    uint16_t flag;
    float TmpFloat;

    flag = 0;
    if (argc==2){
        if (strcmp(argv[1], "help")==0) {
            flag |= 0x8000u;
        } else if (strcmp(argv[1], "temp")==0) {
            printf("Pipe temperature = %3.1fC\n", WaterTemp);
        } else if (strcmp(argv[1], "getcoe")==0) {
            printf("current PipeCoe = %.6f\n", TdcItf.pipe_coe);
        } else if (strcmp(argv[1], "udskew") == 0) {
            uint8_t ch_num = GetChNum();
            for (uint8_t i = 0; i < ch_num; i++) {
                uint8_t ch = TdcItf.mux_ch_no[i];
                printf("Ch%d TdcPathSkew = %.3fns.\n", ch, TdcItf.path_skew[ch]);
            }
        } else if (strcmp(argv[1], "var") == 0) {
            test_var_flag = 1;
            printf("Variance test to begin, please wait three minutes.\n");
        } else {
            flag |= 0x1u;
        }
    } else if (argc==3) {
        str2float(argv[2], &TmpFloat);

        if (strcmp(argv[1], "setcoe")==0) {
            TdcItf.pipe_coe = TmpFloat;
        } else if (strcmp(argv[1], "gaincoe")==0) {
            TdcItf.pipe_coe *= TmpFloat;
        } else {
            flag |= 0x1u;
        }
    } else {
        flag |= 0x1u;
    }

    if (flag){
        if (flag&0x1u){
            printf("    unknown cmd. only the following cmds supported.\n");
        }
        printf("    pipe temp\n");
        printf("            :show temperature of Pipe.\n");
        printf("    pipe getcoe\n");
        printf("            :show current coefficient of Pipe.\n");
        printf("    pipe setcoe [VAL]\n");
        printf("            :set PipeCoe = [VAL].\n");
        printf("    pipe gaincoe [G]\n");
        printf("            :set PipeCoe = PipeCoe*[G].\n");
        printf("    pipe udskew\n");
        printf("            :show diff tof skew.\n");
        printf("    pipe var\n");
        printf("            :show dtof variance.\n");
    }
}

void TestUdskew(uint8_t print_flag) {
    uint8_t ch_num;
    uint16_t i, j;
    float TmpFloat[MUX_CH_NUM];
    uint32_t Tu32;
    uint8_t  ch;
    uint32_t cnt_int;

    set_tof_state(0);
    us_delay(20000);    // 20ms
    set_tof_state(TOF_ST_TEST);

    ch_num = GetChNum();

    for(i = 0; i < ch_num; i++) {
        ch = TdcItf.mux_ch_no[i];
        set_mux_ch(ch);
        us_delay(1); // max transition time type value is 75ns and max value is 250ns, 1us > 250ns

        TmpFloat[i] = 0;
        for (j = 0; j < 512; j++) {
            cnt_int = get_rtc_cnt_int();
            cnt_int++;
            set_rtc_cnt_int(cnt_int);
            set_tdc_int_step(0x00);
            Tu32 = (cnt_int&0x00000001u) ? TDC_CFG_FIRE_DOWN : TDC_CFG_FIRE_UP;
            tdc_start_tof(TDC_CFG_DO_CKENA | TDC_CFG_DO_CKDIS | TDC_CFG_DO_WREG | Tu32);
            while(get_tdc_int_step()!=0xFFu){
                // wait until TDC interrupt ISR done
            }

            TmpFloat[i] += get_diff_tof();

            if (print_flag) {
                if ((j&0x3Fu)==0x00u){
                    printf(".");
                }
            }

            us_delay(10000);    // must insert delay, otherwise TdcPathSkew a little small
        }

        TdcItf.path_skew[ch] += TmpFloat[i]*(1.0f/512);
    }

    extern float DiffToFAvg128;
    DiffToFAvg128 = 0;

    if (print_flag) {
        for (i = 0; i < ch_num; i++) {
            ch = TdcItf.mux_ch_no[i];
            printf("\nCh%d new PathSkew between up and down is %.3fns.\n", ch, TdcItf.path_skew[ch]);
        }
    }

    DiffToFAvg = 0;

    set_tof_state(0);
    us_delay(20000);    // 20ms
    set_tof_state(TOF_ST_METER);
}

void Cmd_Test(uint8_t argc, char **argv)
{
    uint16_t flag;
    uint16_t i, j;
    uint8_t OldOfst;
    float TmpFloat;
    float PreToF;
    float Delta;
    uint8_t NewOfst;

    flag = 0;
    if (argc>=2){
        if (strcmp(argv[1], "help")==0) {
            flag |= 0x8000u;
        } else if (strcmp(argv[1], "fwofst")==0) {
            set_tof_state (0);
            us_delay(20000);    // 20ms
            set_tof_state(TOF_ST_TEST);

            OldOfst = get_tdc_fw_ofst();

            printf("CmpOfst | First_PW | Hit_PW | Ratio | RspDly\n");
            set_tdc_fw_ofst(5);  // 10mV
            i = 0;
            j = 0;
            PreToF = 0;
            while(1){
                // up Tof
                set_tdc_int_step(0x80);
                tdc_start_tof(TDC_CFG_DO_CKENA | TDC_CFG_DO_WREG | TDC_CFG_FIRE_UP);
                while(get_tdc_int_step()==0x80){
                    // wait until TDC interrupt ISR done
                }
                tdc_read_tof(TDC_CFG_FIRE_UP);

                // down Tof
                set_tdc_int_step(0x80);
                tdc_start_tof(TDC_CFG_FIRE_DOWN);
                while(get_tdc_int_step()==0x80){
                    // wait until TDC interrupt ISR done
                }
                tdc_read_tof(TDC_CFG_FIRE_DOWN | TDC_CFG_DO_CKDIS);

                // check data
                TmpFloat = (250.0f/65536/2)*(TdcDToF[0] + TdcUToF[0]);
                Delta  = TmpFloat - PreToF;
                if (-50<Delta && Delta<50){
                    j++;
                } else if (950<Delta && Delta<1050){
                    i++;
                    j=0;
                    PreToF = TmpFloat;
                    printf("-------------------------\n");
                } else {
                    if (llabs((long long)TdcUToF[0] - TdcDToF[0])<(10*65536/250)){
                        PreToF = TmpFloat;
                    }
                    j=0;
                    printf("-------------------------\n");
                }

                NewOfst = get_tdc_fw_ofst();

                printf("U %3dmV     0x%04x   0x%04x    %3d%%   %6.3fns\n", NewOfst<<1,
                        TdcUPwFw, TdcUPwHw, TdcUPwFw*100/TdcUPwHw, (250.0f/65536)*TdcUToF[0]);
                printf("D %3dmV     0x%04x   0x%04x    %3d%%   %6.3fns %2d.%-2d\n", NewOfst<<1,
                        TdcDPwFw, TdcDPwHw, TdcDPwFw*100/TdcDPwHw, (250.0f/65536)*TdcDToF[0], i, j);

                NewOfst++;
                set_tdc_fw_ofst(NewOfst);

                if (NewOfst>40){  // over 80mv
                    break;
                }
            }

            set_tdc_fw_ofst(OldOfst);

            printf("Current Offst is %3dmV\n", OldOfst*2);

            set_tof_state(0);
            us_delay(20000);    // 20ms
            set_tof_state(TOF_ST_METER);
        } else if (strcmp(argv[1], "udskew")==0) {
            TestUdskew(1);
        } else {
            flag |= 0x1u;
        }
    } else {
        flag |= 0x1u;
    }

    if (flag){
        if (flag&0x1u){
            printf("    unknown cmd. only the following cmds supported.\n");
        }
        printf("    test fwofst <ch>\n");
        printf("            :scan first wave with series of offset voltages.\n");
        printf("    test udskew\n");
        printf("            :test up and down path delay skew.\n");
    }
}

float RefFlow=2000;
void Cmd_Calib(uint8_t argc, char **argv)
{
    uint16_t flag;
    float TmpFloat;

    flag = 0;
    if (argc>=2){
        if (strcmp(argv[1], "help")==0) {
            flag |= 0x8000u;
        } else if (strcmp(argv[1], "enter")==0) {
            set_tof_state(TOF_ST_CALIB);
        } else if (strcmp(argv[1], "exit")==0) {
            set_tof_state(TOF_ST_METER);
        } else if (strcmp(argv[1], "setref")==0 && argc>=3) {
            str2float(argv[2], &TmpFloat);
            if (TmpFloat>=100){
                RefFlow = TmpFloat;
                printf("set new reference flow to %.1fml\n", RefFlow);
                if (argc>=4 && strcmp(argv[3], "reprint")==0 && CalibTime>CALIB_TIME_LTH){
                    printf("reprint last one data with new reference.\n");
                    uint32_t flag = get_tof_flag();
                    flag |= TOF_FLAG_CALIB_FALL | TOF_FLAG_CALIB_DONE;
                    set_tof_flag(flag);
                }
            } else {
                printf("FAIL, <setref> must not less than 100ml\n");
            }
        } else {
            flag |= 0x1u;
        }
    } else {
        flag |= 0x1u;
    }

    if (flag){
        if (flag&0x1u){
            printf("    unknown cmd. only the following cmds supported.\n");
        }
        printf("    calib enter\n");
        printf("            :enter calibration mode.\n");
        printf("    calib exit\n");
        printf("            :exit calibration mode.\n");
        printf("    calib setref <ml> [reprint]\n");
        printf("            :set reference flow.\n");
    }
}

void Cmd_Clr(uint8_t argc, char **argv) {
    printf("clear cumulative flow:%dml %dml %dml -> 0ml\n",
        (uint32_t)CumFlow, (uint32_t)FwCumFlow, (uint32_t)BwCumFlow);
    CumFlow = 0;
    FwCumFlow = 0;
    BwCumFlow = 0;
}

void Cmd_Mux(uint8_t argc, char **argv)
{
    uint16_t flag;
    uint32_t value;
    uint32_t tmp;
    uint8_t  i;

    flag = 0;

    if (argc == 2) {
        if (strcmp(argv[1], "help") == 0) {
            flag |= 0x8000u;
        } else if (strcmp(argv[1], "no") == 0) {
            printf("max no = %d %d %d %d\n", TdcItf.mux_ch_no[0], TdcItf.mux_ch_no[1],
                TdcItf.mux_ch_no[2], TdcItf.mux_ch_no[3]);
        } else {
            flag |= 0x1u;
        }
    } else if (argc == 3) {
        str2int(argv[2], &value);
        if (strcmp(argv[1], "addr") == 0) {
            set_mux_ch(value);
            TdcItf.ch_bit_map = (0x00000001 << value);
        } else if (strcmp(argv[1], "switch") == 0) {
            if (strcmp(argv[2], "on") == 0) {
                TdcItf.mux_switch= 1;

                TdcItf.ch_bit_map = 0;
                for (i = 0; i < GetChNum(); i++) {
                    TdcItf.ch_bit_map |= (0x00000001 << TdcItf.mux_ch_no[i]);
                }
            } else if (strcmp(argv[2], "off") == 0) {
                TdcItf.mux_switch = 0;

                TdcItf.ch_bit_map = (0x00000001 << get_mux_ch());
            } else {
                flag |= 0x1u;
            }
        } else {
            flag |= 0x1u;
        }
    } else if (argc == 6) {
        if (strcmp(argv[1], "no") == 0) {
            str2int(argv[2], &tmp);
            TdcItf.mux_ch_no[0] = (uint8_t)tmp;
            str2int(argv[3], &tmp);
            TdcItf.mux_ch_no[1] = (uint8_t)tmp;
            str2int(argv[4], &tmp);
            TdcItf.mux_ch_no[2] = (uint8_t)tmp;
            str2int(argv[5], &tmp);
            TdcItf.mux_ch_no[3] = (uint8_t)tmp;

            TdcItf.ch_bit_map = 0;
            for (i = 0; i < GetChNum(); i++) {
                TdcItf.ch_bit_map |= (0x00000001 << TdcItf.mux_ch_no[i]);
            }
        }
    } else {
        flag |= 0x1u;
    }

    if (flag) {
        if (flag&0x1u) {
            printf("    unknown cmd. only the following cmds supported.\n");
        }
        printf("    mux addr [value]\n");
        printf("            :set mux addr value.\n");
        printf("    mux switch <on/off>\n");
        printf("            :auto switch mux ch on or off.\n");
        printf("    mux no [<ch0_no> <ch1_no> <ch2_no> <ch3_no>]\n");
        printf("            :get/set mux ch no.\n");
    }
}

void nb_help(uint8_t argc, char **argv);

Shell_Cmd_t nb_cmds[] = {
    {"help",      "nb command help",                               nb_help},
    {"on",        "nb module power on",                            NbPowerOnCmd},
    {"off",       "nb module power off",                           NbPowerOffCmd},
    {"at",        "test interface",                                NbAtCmd},
    {"ati",       "request product identification information",    NbAtiCmd},
    {"ate",       "set cmd echo mode, format: nb ate <0/1>",       NbAteCmd},
    {"cgatt",     "query PS attach/detach",                        NbCgattCmd},
    {"cfun",      "query/set ue function, format: nb cfun [0/1]",  NbCfunCmd},
    {"ncsearfcn", "clean freq which ue saved",                     NbNcsearfcnCmd},
    {"cgsn",      "query imei",                                    NbCgsnCmd},
    {"cimi",      "query imsi",                                    NbCimiCmd},
    {"csq",       "get signal strength indication",                NbCsqCmd},
    {"cgpaddr",   "show pdp addr",                                 NbCgpaddrCmd},
    {"cereg",     "query EPS network reg state",                   NbCeregCmd},
    {"nccid",     "query iccid",                                   NbNccidCmd},
    {"nuestats",  "query rsrp/rsrq/rssi/snr",                      NbNuestatsCmd},
    {"cmee",      "report UE error",                               NbCmeeCmd},
    {"nnmi",      "set new message indication",                    NbNnmiCmd},
    {"ncdp",      "query and set server",                          NbNcdpCmd},
    {"nmgs",      "send message",                                  NbNmgsCmd},
    {"closeautocon", "close auto connect",                         NbCloseAutoCon},
    {"nrb",       "soft reboot",                                   NbNrb},
    {"cedrxs",    "extended discontinuous reception",              NbCedrxs},
    {"cpsms",     "set power save model",                          NbCpsms},
    {"showrun",   "show nb run info",                              NbShowrunCmd},
    {"upload",    "nb upload from shell cmd",                      NbUploadCmd},
    {NULL,        NULL,                                            NULL}
};

void nb_help(uint8_t argc, char **argv) {
    uint16_t i;

    for (i = 0; nb_cmds[i].name != NULL; i++) {
        printf("    nb %s\n", nb_cmds[i].name);
        printf("            :%s.\n", nb_cmds[i].help);
    }
}

void Cmd_Nb(uint8_t argc, char **argv)
{
    uint16_t flag;
    uint16_t i;

    flag = 0;
    if (argc >= 2) {
        for (i = 0; nb_cmds[i].name != NULL; i++) {
            if (strcmp(argv[1], nb_cmds[i].name) == 0) {
                NbIntStep = 0x80;
                NbClrRxBuf();
                nb_cmds[i].func(argc, argv);
                return;
            }
        }

        flag |= 0x1u;
    }else {
        flag |= 0x1u;
    }

    if (flag) {
        if (flag&0x1u) {
            printf("    unknown cmd. only the following cmds supported.\n");
        }
        nb_help(argc, argv);
    }
}

void Cmd_Ir(uint8_t argc, char **argv) {
    uint16_t flag = 0;

    if (argc == 2) {
        if (strcmp(argv[1], "help") == 0) {
            flag |= 0x8000u;
        } else {
            flag |= 0x1u;
        }
    } else if (argc == 3) {
        if (strcmp(argv[1], "mode") == 0) {
            if (strcmp(argv[2], "check") == 0) {
                Finsh_Uart_Mode |= CHECK_ITF_ON;
            } else if (strcmp(argv[2], "shell") == 0) {
                Finsh_Uart_Mode &= ~CHECK_ITF_ON;
            } else {
                flag |= 0x1u;
            }
        } else {
            flag |= 0x1u;
        }
    } else {
        flag |= 0x1u;
    }

    if (flag) {
        if (flag&0x1u) {
            printf("    unknown cmd. only the following cmds supported.\n");
        }
        printf("    ir mode <check/shell>\n");
        printf("            :switch ir work mode, check mode or shell mode.\n");
    }
}

//add by yw 20260126
uint16_t ParamAddr(uint8_t argc, char **argv) {
    Param_t *param;
    GetParam(&param);

    if (argc == 2) {
        printf("param addr = ");
        for(int i = 0; i < DEV_ID_LEN; i ++){
            printf("%2X",param->dev_id[i]);
        }
        printf("\n");

        return 0;
    } else if (argc == 3) {
        StrToHexBuf((char *)&param->dev_id[0], argv[2], 6);
        return 0;
    }

    return 0x1u;
}

uint16_t ParamVer(uint8_t argc, char **argv) {
    Param_t *param;
    uint32_t tmp;

    GetParam(&param);

    if (argc == 2) {
        printf("param ver type     = %d\n", param->ver_type);
        printf("param ver operator = %d\n", param->ver_operator);
        printf("param ver module   = %d\n", param->ver_module);
        printf("param ver firmware = %d\n", param->ver_firmware);

        return 0;
    } else if (argc == 6) {
        str2int(argv[2], &tmp);
        param->ver_type = (uint8_t)tmp;
        str2int(argv[3], &tmp);
        param->ver_operator = (uint8_t)tmp;
        str2int(argv[4], &tmp);
        param->ver_module = (uint8_t)tmp;
        str2int(argv[5], &tmp);
        param->ver_firmware = (uint8_t)tmp;

        return 0;
    }

    return 0x1u;
}

uint16_t ParamPipe(uint8_t argc, char **argv) {
    Param_t *param;
    uint32_t tmp;

    GetParam(&param);

    if (argc == 2) {
        printf("param pipe diameter        = %d\n", param->diameter);
        printf("param pipe channel num     = %d\n", param->chan_num);
        printf("param pipe pressure sensor = %d\n", param->pressure_sensor);

        return 0;
    } else if (argc == 5) {
        str2int(argv[2], &tmp);
        param->diameter = (uint16_t)tmp;
        str2int(argv[3], &tmp);
        param->chan_num = (uint8_t)tmp;
        TdcItf.ch_num = (uint8_t)tmp;
        str2int(argv[4], &tmp);
        param->pressure_sensor = (uint8_t)tmp;

        return 0;
    }

    return 0x1u;
}

uint16_t ParamSettle(uint8_t argc, char **argv) {
    Param_t *param;
    uint32_t tmp;

    GetParam(&param);

    if (argc == 2) {
        printf("param settle day = %d\n", param->settlement_day);

        return 0;
    } else if (argc == 3) {
        str2int(argv[2], &tmp);
        param->settlement_day = (uint8_t)tmp;

        return 0;
    }

    return 0x1u;
}

uint16_t ParamReport(uint8_t argc, char **argv) {
    Param_t *param;
    uint32_t tmp;

    GetParam(&param);

    if (argc == 2) {
        printf("param report hour     = %d\n", param->report_base_hour);
        printf("param report minute   = %d\n", param->report_base_min);
        printf("param report second   = %d\n", param->report_base_sec);
        printf("param report interval = %d\n", param->report_interval);

        return 0;
    } else if (argc == 6) {
        str2int(argv[2], &tmp);
        param->report_base_hour = (uint8_t)tmp;
        str2int(argv[3], &tmp);
        param->report_base_min = (uint8_t)tmp;
        str2int(argv[4], &tmp);
        param->report_base_sec = (uint8_t)tmp;
        str2int(argv[5], &tmp);
        param->report_interval = (uint16_t)tmp;

        return 0;
    }

    return 0x1u;
}

uint16_t ParamAlarmThres(uint8_t argc, char **argv) {
    Param_t *param;
    uint32_t tmp;
    float float_tmp;

    GetParam(&param);

    if (argc == 2) {
        printf("param high temperature alarm threshold = %d\n", param->high_temp_alarm_thres);
        printf("param low temperature alarm threshold  = %d\n", param->low_temp_alarm_thres);
        printf("param large flow alarm threshold       = %d\n", param->large_flow_alarm_thres);
        printf("param leak flow alarm threshold        = %d\n", param->leak_flow_alarm_thres);
        printf("param high pressure alarm threshold    = %d\n", param->high_press_alarm_thres);
        printf("param low pressure alarm threshold     = %d\n", param->low_press_alarm_thres);

        return 0;
    } else if (argc == 8) {
        str2float(argv[2], &float_tmp);
        param->high_temp_alarm_thres = (int16_t)float_tmp;
        str2float(argv[3], &float_tmp);
        param->low_temp_alarm_thres = (int16_t)float_tmp;
        str2int(argv[4], &tmp);
        param->large_flow_alarm_thres = (uint32_t)tmp;
        str2int(argv[5], &tmp);
        param->leak_flow_alarm_thres = (uint32_t)tmp;
        str2int(argv[6], &tmp);
        param->high_press_alarm_thres = (uint16_t)tmp;
        str2int(argv[7], &tmp);
        param->low_press_alarm_thres = (uint16_t)tmp;

        return 0;
    }

    return 0x1u;
}

uint16_t ParamCheck(uint8_t argc, char **argv) {
    Param_t *param;
    uint32_t tmp;
    uint32_t i;

    GetParam(&param);

    if (argc == 3) {
        if (strcmp(argv[2], "q") == 0) {
						//modified by yuewei 20260317 change q_value to q
            //printf("check q value = %d\n", param->q_value);
						printf("check q value = %d\n", param->q);
            return 0;
        }
    } else if (argc == 4) {
        if (strcmp(argv[2], "spdlvl") == 0) {
            str2int(argv[3], &tmp);
            for (i = 0; i < CHECK_POINT_NUM; i++) {
                printf("check spdlvl[%d][%d] = %d\n", tmp, i, param->check_spdLvl_c[tmp].spd_lvl[i]);
            }

            return 0;
        } else if (strcmp(argv[2], "basec") == 0) {
            str2int(argv[3], &tmp);
            for (i = 0; i < CHECK_POINT_NUM; i++) {
                printf("check base c value[%d][%d] = %d\n", tmp, i, param->check_spdLvl_c[tmp].base_c[i]);
            }

            return 0;
        } else if (strcmp(argv[2], "curc") == 0) {
            str2int(argv[3], &tmp);
            for (i = 0; i < CHECK_POINT_NUM; i++) {
                printf("check current c value[%d][%d] = %d\n", tmp, i, param->check_spdLvl_c[tmp].cur_c[i]);
            }

            return 0;
        }
    }

    return 0x1u;
}

uint16_t Param_Server(uint8_t argc, char **argv) {
    Param_t *param;

    GetParam(&param);
    if (argc == 2) {
        printf("main server ip   = %d.%d.%d.%d\n", param->main_server_ip[0],
                param->main_server_ip[1], param->main_server_ip[2], param->main_server_ip[3]);
        printf("main server port = %d\n", param->main_server_port);
        printf("sub server ip    = %d.%d.%d.%d\n", param->sub_server_ip[0],
                param->sub_server_ip[1], param->sub_server_ip[2], param->sub_server_ip[3]);
        printf("sub server port  = %d\n", param->sub_server_port);

        return 0;
    }

    return 0x1u;
}

uint16_t Param_Dma(uint8_t argc, char **argv) {
    Param_t *param;

    GetParam(&param);

    if (argc == 2) {
        printf("dma report start h = %d m = %d s = %d\n", param->dma_report_start[0],
                param->dma_report_start[1], param->dma_report_start[2]);
        printf("dma report end   h = %d m = %d s = %d\n", param->dma_report_end[0],
                param->dma_report_end[1], param->dma_report_end[2]);
        printf("dma report interval = %d\n", param->dma_interval);

        double base_read = (double)((param->total_positive_water[3] << 24) |
                                   (param->total_positive_water[2] << 16) |
                                   (param->total_positive_water[1] << 8) |
                                   param->total_positive_water[0]);
        base_read /= 100;
        printf("total positive water = %.6fm^3\n", base_read);

        return 0;
    }

    return 0x1u;
}

void Cmd_Param(uint8_t argc, char **argv)
{
    uint16_t flag;

    flag = 0;

    if (strcmp(argv[1], "help") == 0) {
        flag |= 0x8000u;
    } else if (strcmp(argv[1], "addr") == 0) {//add by yw 20260126
        flag = ParamAddr(argc, argv);
    } else if (strcmp(argv[1], "ver") == 0) {
        flag = ParamVer(argc, argv);
    } else if (strcmp(argv[1], "pipe") == 0) {
        flag = ParamPipe(argc, argv);
    } else if (strcmp(argv[1], "settle") == 0) {
        flag = ParamSettle(argc, argv);
    } else if (strcmp(argv[1], "report") == 0) {
        flag = ParamReport(argc, argv);
    } else if (strcmp(argv[1], "alarmthres") == 0) {
        flag = ParamAlarmThres(argc, argv);
    } else if (strcmp(argv[1], "check") == 0) {
        flag = ParamCheck(argc, argv);
    } else if (strcmp(argv[1], "server") == 0) {
        flag = Param_Server(argc, argv);
    } else if (strcmp(argv[1], "dma") == 0) {
        flag = Param_Dma(argc, argv);
    } else if (strcmp(argv[1], "erase") == 0) {
        McuFlash_Unlock();
        McuFlash_EraseSegment(FLASH_ADDR_SAVEPARAM, 512);
        McuFlash_Lock();
    } else if (strcmp(argv[1], "reset") == 0) {
        ParamInit();
    } else {
        flag |= 0x1u;
    }

    if (flag) {
        if (flag&0x1u) {
            printf("    unknown cmd. only the following cmds supported.\n");
        }
        printf("    param addr [<addr>]\n");//add by yw 20260126
        printf("            :get/set addr param.\n");//add by yw 20260126
        printf("    param ver [<type> <opt> <module> <firmware>]\n");
        printf("            :get/set ver param.\n");
        printf("    param pipe [<diameter> <channel num> <pressure sensor>]\n");
        printf("            :get/set pipe param.\n");
        printf("    param settle [<day>]\n");
        printf("            :get/set settle day param.\n");
        printf("    param report [<hour> <minute> <second> <interval>]\n");
        printf("            :get/set report param.\n");
        printf("    param alarmthres [<high temp> <low temp> <large flow> <leak flow> <high press> <low press>]\n");
        printf("            :get/set alarm threshold param.\n");
        printf("    param check <spdlvl> <index>/<basec> <index>/<curc> <index>/q\n");
        printf("            :print check param, index: 0-2.\n");
        printf("    param server\n");
        printf("            :get nb server ip/port.\n");
        printf("    param dma\n");
        printf("            :get dma param.\n");
        printf("    param erase\n");
        printf("            :erase mcu flash param.\n");
        printf("    param reset\n");
        printf("            :reset param.\n");
    }
}
//add by yw 20260127 start
void print_month_bill(uint8_t year, uint8_t month) {
    bill_t month_bill;

    if (read_month_bill((year % 2000), month, &month_bill)) {
        return;
    }

    printf("month bill flag = %d, year = %d, month = %d, day = %d, forward used = %d, backward used = %d\n",
        month_bill.flag, month_bill.date[0], month_bill.date[1], month_bill.date[2],
        month_bill.fw_used, month_bill.bw_used);
}

void print_day_bill(uint8_t month, uint8_t day) {
    bill_t day_bill;

    if (read_day_bill(month, day, &day_bill)) {
        return;
    }

    printf("day bill flag = %d, year = %d, month = %d, day = %d, forward used = %d, backward used = %d\n",
        day_bill.flag, day_bill.date[0], day_bill.date[1], day_bill.date[2],
        day_bill.fw_used, day_bill.bw_used);
}

void print_hour_bill(uint8_t day, uint8_t hour) {
    hour_bill_t bill;
    uint32_t fw_used;
    uint32_t bw_used;
    uint32_t fr;
    if (read_hour_bill(day, hour, &bill)) {
        return;
    }

    printf("hour bill flag = %d, year = %d, month = %d, day = %d hour = %d\n",
        bill.flag, bill.date[0], bill.date[1], bill.date[2], bill.date[3]);

    fw_used = bill.fw_used[0] | (bill.fw_used[1] << 8) | (bill.fw_used[2] << 16);
    bw_used = bill.bw_used[0] | (bill.bw_used[1] << 8) | (bill.bw_used[2] << 16);
    fr      = bill.flow_rate[0] | (bill.flow_rate[1] << 8) | (bill.flow_rate[2] << 16);

    printf("forward used = %d, backward used = %d, flow rate = %d\n", fw_used, bw_used, fr);
}

void print_5m_bill(uint8_t day, uint8_t hour) {
    hour_bill_t bill;
    uint32_t fw_used;
    uint32_t bw_used;
    uint32_t fr;
    uint32_t i;

    for (i = 0; i < 12; i++) {
        read_five_min_bill(day, hour, i * 5, &bill);
        printf("five minute bill flag = %d, year = %d, month = %d, day = %d hour = %d\n",
            bill.flag, bill.date[0], bill.date[1], bill.date[2], bill.date[3]);

        fw_used = bill.fw_used[0] | (bill.fw_used[1] << 8) | (bill.fw_used[2] << 16);
        bw_used = bill.bw_used[0] | (bill.bw_used[1] << 8) | (bill.bw_used[2] << 16);
        fr      = bill.flow_rate[0] | (bill.flow_rate[1] << 8) | (bill.flow_rate[2] << 16);

        printf("minute = %d forward used = %d, backward used = %d, flow rate = %d\n",
            i * 5, fw_used, bw_used, fr);
    }
}

uint16_t Bill_Print(uint8_t argc, char **argv) {
    uint32_t day;
    uint32_t month;
    uint32_t year;
    uint32_t hour;

    if (strcmp(argv[1], "hour") == 0) {
        str2int(argv[2], &day);
        str2int(argv[3], &hour);
        if (day >= 1 && day <= 31 && hour < 24) {
            print_hour_bill(day, hour);
            return 0;
        }
    } else if (strcmp(argv[1], "day") == 0) {
        str2int(argv[2], &month);
        str2int(argv[3], &day);
        if (month >= 1 && month <= 12 && day >= 1 && day <= 31) {
            print_day_bill(month, day);
            return 0;
        }
    } else if (strcmp(argv[1], "month") == 0) {
        str2int(argv[2], &year);
        str2int(argv[3], &month);
        if (month >= 1 && month <= 12) {
            print_month_bill(year, month);
            return 0;
        }
    } else if (strcmp(argv[1], "5m") == 0) {
        str2int(argv[2], &day);
        str2int(argv[3], &hour);
        if (day > 0 && day <= 31 && hour < 24) {
            print_5m_bill(day, hour);
            return 0;
        }
    }

    return 0x1u;
}

void Cmd_Bill(uint8_t argc, char **argv) {
    uint16_t flag = 0;

    if (argc == 2) {
        if (strcmp(argv[1], "help") == 0) {
            flag |= 0x8000u;
        } else {
            flag |= 0x1u;
        }
    } else if (argc == 4) {
        flag = Bill_Print(argc, argv);
    } else {
        flag |= 0x1u;
    }

    if (flag) {
        if (flag&0x1u) {
            printf("    unknown cmd. only the following cmds supported.\n");
        }
        printf("    bill month <year> <month>\n");
        printf("            :print month bill.\n");
        printf("    bill day <month> <day>\n");
        printf("            :print day bill.\n");
        printf("    bill hour <day> <hour>\n");
        printf("            :print hour bill.\n");
        printf("    bill 5m <day> <hour>\n");
        printf("            :print 5 minute bill.\n");
    }
}

void print_alarm(alarm_t *alarm) {
    uint32_t arg;

    arg = (alarm->arg[3] << 24) | (alarm->arg[2] << 16) | (alarm->arg[1] << 8) | alarm->arg[0];
    printf("y=%d, m=%d, d=%d, h=%d, m=%d, s=%d, err=%d, type = %d, arg = %d\n",
             alarm->time[1], alarm->time[2], alarm->time[3], alarm->time[4],
             alarm->time[5], alarm->time[6], alarm->err_no, alarm->type, arg);
}
void Cmd_Alarm(uint8_t argc, char **argv) {
    uint8_t i;
    int8_t  j;
    alarm_t alarm;
    uint32_t* status;

    all_alarm_status(&status);
    printf("all alarm status = 0x%08x\n", *status);

//    for (i = 0; i < ERR_END; i++) {
//        for (j = 1; j >= 0; j--) {
//            if (read_alarm(i, j, &alarm) == 0 && alarm.flag == 1) {
//                print_alarm(&alarm);
//            }
//        }
//    }
			uint8_t num=get_alarm_num();
	 for(i=0;i<num;i++){
		 read_alarm(i,&alarm);
		 print_alarm(&alarm);
	 }
}
//add by yw 20260127 end
uint16_t ShellFlag = 0;

static char ChHold;
static char ChBuf[SHELL_CMDLEN_MAX];
static uint8_t ChIdx = 0;
uint8_t ArgVld = 0;
uint8_t ArgNum;
char *ArgPtr[SHELL_ARGNUM_MAX];

void shell_help(uint8_t argc, char **argv);

Shell_Cmd_t shell_cmds[] = {
    {"help",      "show cmds list",                                         shell_help},
    {"ver",       "show version",                                           Cmd_Ver},
    {"reset",     "MCU soft reset",                                         Cmd_Reset},
    {"plot",      "send values to PC for plotting, format: plot <on/off>",  Cmd_Plot},
    {"adc",       "get MCU temperature and voltage",                        Cmd_Adc},
    {"date",      "show date",                                              Cmd_Date},
    {"time",      "show time",                                              Cmd_Time},
    {"upgrade",   "upgrade MCU by ymodem, type 'upgrade help' for more",    Cmd_Upgrade},
    {"saveparam", "save all current parameters to flash",                   Cmd_SaveParam},
    {"pipe",      "series of pipe cmds, type 'pipe help' for more",         Cmd_Pipe},
    {"test",      "series of test cmds, type 'test help' for more",         Cmd_Test},
    {"calib",     "series of calibration cmds, type 'calib help' for more", Cmd_Calib},
    {"clr",       "clear cumulative flow",                                  Cmd_Clr},
    {"mux",       "set mux addr",                                           Cmd_Mux},
    {"nb",        "series of nb cmds, type 'nb help' for more",             Cmd_Nb},
    {"ir",        "switch ir work mode, format: ir mode <check/shell>",     Cmd_Ir},
    {"param",     "set/get param, type 'param help' for more",              Cmd_Param},
    {"bill",      "show hour/day/month bill, type 'bill help' for more",    Cmd_Bill},//add by yw 20260127
    {"alarm",     "show alarm",                                             Cmd_Alarm},//add by yw 20260127
    {NULL,        NULL,                                                     NULL}
};

void shell_help(uint8_t argc, char **argv)
{
    uint16_t i;

    printf("   [commands]     [description]\n");
    printf("--------------------------------------------------\n");
    for (i = 0; shell_cmds[i].name != NULL; i++) {
        printf("    %-10s    :%s.\n", shell_cmds[i].name, shell_cmds[i].help);
    }
    printf("\n");
}

void CmdToArg(uint8_t ChLen)
{
    uint8_t Idx;
    char PreCh, ch;

    ArgNum = 0;
    PreCh = ' ';
    for(Idx=0; Idx<ChLen; Idx++){
        ch = ChBuf[Idx];
        if (ch==' '){
            ChBuf[Idx] = '\0';
        } else if (PreCh==' '){
            ArgPtr[ArgNum++] = &ChBuf[Idx];
            if (ArgNum>=SHELL_ARGNUM_MAX){
                break;
            }
        }
        PreCh = ch;
    }
}

// call the following function within ISR
void ShellRxCh(uint8_t ch)
{
    // OS style for newline
    // Windows: "\r\n" or "\13\10"
    // Unix   : '\n'   or '\10'
    // Mac    : '\r'   or '\13'
    if (ChHold=='\r' && ch=='\n'){
        // ignore it, because '\n' or '\r' is handled
    }else if (ch=='\r' || ch=='\n'){
        ChBuf[ChIdx] = '\0';
        ShellFlag |= SHELL_FLAG_ARG_VLD;
    }else if (ch=='\b' && ChIdx>0){
        ShellFlag |= SHELL_FLAG_DEL_CH;
    }else if (ch>=32 && ch<=126 && ChIdx<(SHELL_CMDLEN_MAX-1)){
        ChBuf[ChIdx] = ch;
        ShellFlag |= SHELL_FLAG_ECHO_CH;
    }

    ChHold = ch;
}

void ShellCmdAnalyze(uint8_t argc, char **argv)
{
    uint16_t i;

    if (argc==0){
        return;
    }

    for (i = 0; shell_cmds[i].name != NULL; i++) {
        if (strcmp(argv[0], shell_cmds[i].name) == 0) {
            shell_cmds[i].func(argc, argv);
            return;
        }
    }

    printf("Unknown command. Type 'help' for list.\n");
}

// call the following function outside ISR
void ShellHandler(void)
{
    if (ShellFlag & SHELL_FLAG_ECHO_CH){
        ShellFlag &= ~SHELL_FLAG_ECHO_CH;
        print_ch(ChBuf[ChIdx]);
        ChIdx++;
    } else if (ShellFlag & SHELL_FLAG_ARG_VLD){
        ShellFlag &= ~SHELL_FLAG_ARG_VLD;
        CmdToArg(ChIdx);
        ChIdx = 0;

        printf("\n");
        ShellCmdAnalyze(ArgNum, ArgPtr);
        print_str("cmd>");
    } else if (ShellFlag & SHELL_FLAG_DEL_CH){
        ShellFlag &= ~SHELL_FLAG_DEL_CH;
        print_str("\b \b");   // delete ch
        ChIdx--;
    }
}