cmd_misc.c

TDK 6521 SOC 芯片 DEMO程序

/***************************************************************************
 * This code and information is provided "as is" without warranty of any   *
 * kind, either expressed or implied, including but not limited to the     *
 * implied warranties of merchantability and/or fitness for a particular   *
 * purpose.                                                                *
 *                                                                         *
 * Copyright (C) 2005 Teridian Semiconductor Corp. All Rights Reserved.     *
 ***************************************************************************/
//**************************************************************************
//  DESCRIPTION: 71M652x POWER METER - Demo Misc Command Routines. 
// 
//  AUTHOR:  MTF
//
//  HISTORY: see end of file
//**************************************************************************
// File:  CMD_MISC.C
//               
#include "options.h"
#if CLI
#include <ctype.h>
#include "eeprom.h"
#include "batmodes.h"
#include "battest.h"
#include "flash.h"
#include "help.h"
#include "io.h"
#include "library.h"
#include "main.h"
#include "meter.h"
#include "rtc.h"
#include "sercli.h"
#include "serial.h"
#include "error.h"
#include "cli.h"

/*** Public functions declared within this module  ***/
void send_rtc (void);

/*** Private functions declared within this module  ***/
// None.

/*** Private variables used within this module ***/
#define BUFFER_SIZE        64
static uint8x_t Buffer[ BUFFER_SIZE ];
static uint8x_t * xdata pBuffer;
static uint8r_t * code month[]
    = { "JAN", "FEB", "MAR", "APR", "MAY", "JUN", 
        "JUL", "AUG", "SEP", "OCT", "NOV", "DEC" };

static uint8r_t * code week_day[] 
    = { "SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT" };

#if BROWNOUT_BATMODE
//--------------------------------------------------------------------//
void cmd_batmode (void)               // 'B'attery modes.
{
    uint8_t data c;

    while (!done (&c))
    {
        c = toupper(c);
        switch (c)
        {
            default:
                cli_result = ERROR_ID;
                break;
            #if LCD_BATMODE
            case 'L':
                batmode_lcd ();
                break;
            #endif
            #if SLEEP_BATMODE
            case 'S':
                batmode_sleep ();
                break;
            #endif
            #if BATTERY_TEST
            case 'T':
                battest_start ();  // start a battery test
                break;
            #endif
            case 'W':
                {
                    uint16_t time_cnt;
                    done (&c);
                    c = toupper (c);
                    time_cnt = (uint16_t) get_long ();
                    if (cli_result == OK_ID)
                    {
                        if ('M' == c)
                            batmode_wait_minutes ( time_cnt );
                        else if ('S' == c)
                            batmode_wait_seconds ( time_cnt );
                        else
                        {
                            cli_result = ERROR_ID;
                        }
                    }
                }
                break;
        }
        if (c != 'T' && !batmode_is_brownout ())
        {
            start_tx_rslt ("Not in brownout mode.");
            send_crlf ();
            return;
        }
    }
}
#endif

#if FLASH
//--------------------------------------------------------------------//
void cmd_flash (void)
{                                       // FCn.n, FD, FR, FT..
    uint8_t data c;                         // ..FSc..cc and FWn.n...n commands.
    uint8r_t * xdata FAddr;
    uint8x_t * xdata FData;
    uint16_t xdata FLen;

    while (!done (&c))
    {
       switch (toupper (c))
       {
          case 'T':
             FAddr  = (uint8r_t *) get_short ();     // Address.
             FLen   = pBuffer - Buffer;
             memcpy_rx (FAddr, Buffer, FLen);
             break;

          case 'R':
             FAddr = (uint8r_t *) get_short ();      // Address.
             done (&c);                 // Skip delimiter.
             FLen = get_num_decimal (); // Length.
             memcpy_xr (Buffer, FAddr, FLen);
             send_crlf ();

             FData = Buffer;
             while (FLen--)
                send_hex (*FData++);   

             send_crlf ();
             break;           
          
          case 'S':
             pBuffer = Buffer;

             while (!done (&c))
                 *pBuffer++ = c;             
             break;

          case 'W':
             pBuffer = Buffer;

             do
                *pBuffer++ = get_num ();
             while ('.' == get_char_d (&c));

             cli_index = c;             // Unget character.
             break;           
       }
    }
}
#endif

#if REAL_TIME_DATE
void cmd_rtc (void)                     // 'RT' (R)eal (T)ime Clock controls.
{
    uint8_t data c;

    while (!done (&c))
    {
       switch (toupper (c))
       {
          #if RTC_COMPENSATION
          case 'A':
             {
             bool slow;
             slow = get_num ();
             done (&c);                 // Skip delimiter.
             RTC_Adjust_Trim (slow, get_long ());            
             break;
             }
          #endif

          case 'D':                     // Day of year.
             RTClk_Read (); 
                                        // First, get current time.
             Rtc_Time_Date.Year = get_num_decimal (); 
             done (&c);                 // Skip delimiter.
             c = get_num_decimal ();
             Rtc_Time_Date.Month = max (c, 1); 
             done (&c);                 // Skip delimiter.
             Rtc_Time_Date.Date = get_num_decimal (); 
             done (&c);                 // Skip delimiter.
             c = get_num_decimal ();    
             Rtc_Time_Date.Day = max (c, 1); 

             RTClk_Write ();
             break;

          case 'R':
             send_rtc ();
             break;

          case 'T':                     // Time of day.
             Rtc_Time_Date.Hour = get_num_decimal (); 
             done (&c);                 // Skip delimiter.
             Rtc_Time_Date.Min = get_num_decimal (); 
             done (&c);                 // Skip delimiter.
             Rtc_Time_Date.Sec = get_num_decimal (); 

             RTClk_Write ();
             break;
       }
    }
}

#endif

#if REAL_TIME_DATE
void send_rtc (void)
{
    RTClk_Read ();
    start_tx_rslt ("2");
    send_digit (Rtc_Time_Date.Year / 100); 
    send_digit (Rtc_Time_Date.Year / 10 % 10); 
    send_digit (Rtc_Time_Date.Year % 10); 
    send_char (' ');
    start_tx_rslt (month[ Rtc_Time_Date.Month - 1 ]); 
    send_char (' ');
    send_byte (Rtc_Time_Date.Date); 
    start_tx_rslt (week_day[ Rtc_Time_Date.Day - 1 ]);
    send_char (' ');
    send_digit (Rtc_Time_Date.Hour / 10); 
    send_digit (Rtc_Time_Date.Hour % 10); 
    send_char (':');
    send_digit (Rtc_Time_Date.Min / 10); 
    send_digit (Rtc_Time_Date.Min % 10); 
    send_char (':');
    send_digit (Rtc_Time_Date.Sec / 10); 
    send_digit (Rtc_Time_Date.Sec % 10); 
    send_crlf ();
}
#endif

#if CLI_EEPROM && EEPROM
void cmd_eeprom (void)
{
    static uint8_t active = FALSE;
    static struct EEPROM_t xdata rx;
    static struct EEPROM_t xdata tx;
    uint8_t data c;

    if (CE0 & CE_EN)
    {
        start_tx_rslt ("To run EEPROM turn CE off.");
        send_crlf ();
    }
    else
    {
        while (!done (&c))
        {
            switch (toupper (c))
            {
                case 'C':
                    active = get_num ();
                    if ( cli_result == OK_ID )
                        EEProm_Config (active, PAGE_SIZE, WRITE_TIME);
                    else
                        active = 0;
                    break;

                case 'E':
                    if ( cli_result == OK_ID )
                    {
                        start_tx_rslt ("Erasing EEPROM; please wait...");
                        send_crlf ();
                        rx.status = memclr_pr (); // clear the EEPROM
                        while (_PENDING == *rx.status)
                            main_background ();
                    }
                    break;

                case 'R':
                    if (active)
                    {
                        rx.buffer = Buffer;
                        rx.addr = get_long ();
                        done (&c);                 // Skip delimiter.