C2000 设计时钟时中断无法返回，有中断标志清零
//#############################################################################
//
//  File:   Example_F2802xCputimer.c
//
//  Title:  F2802x CPU Timer Example
//
//! addtogroup example_list
//!  

CPU Timer

//!
//!   This example configures CPU Timer0, 1, & 2 and increments
//!   a counter each time the timer asserts an interrupt.
//!
//!   Watch Variables:
//!   - timer0IntCount
//!   - timer1IntCount
//!   - timer2IntCount
//
//#############################################################################
// $TI Release: F2802x Support Library v3.02.00.00 $
// $Release Date: Mon May 27 06:44:48 CDT 2019 $
// $Copyright:
// Copyright (C) 2009-2019 Texas Instruments Incorporated - http://www.ti.com/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
//   Redistributions of source code must retain the above copyright
//   notice, this list of conditions and the following disclaimer.
//
//   Redistributions in binary form must reproduce the above copyright
//   notice, this list of conditions and the following disclaimer in the
//   documentation and/or other materials provided with the   
//   distribution.
//
//   Neither the name of Texas Instruments Incorporated nor the names of
//   its contributors may be used to endorse or promote products derived
//   from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// $
//#############################################################################
#include "delay.h"
#include "TM1638.h"
//unsigned char data DisBuffer[8]={0,0,0,0,0,0,0,0};    /*显示缓存区*/ //各个数码管显示的值
unsigned char DisBuffer[8]={0,0,0,0,0,0,0,0};    /*显示缓存区*/ //各个数码管显示的值
//unsigned char code tab[]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F,0x77,0x7C,0x39,0x5E,0x79,0x71,0x40,0xef};
unsigned char tab[]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F,0x77,0x7C,0x39,0x5E,0x79,0x71,0x40,0xef};
void LedDisplay(unsigned char data7,unsigned char data6,unsigned char data5,unsigned char data4,
               unsigned char data3,unsigned char data2,unsigned char data1,unsigned char data0);
//
// Included Files
//
#include "DSP28x_Project.h"     // Device Headerfile and Examples Include File
#include "common/include/clk.h"
#include "common/include/flash.h"
#include "common/include/gpio.h"
#include "common/include/pie.h"
#include "common/include/pll.h"
#include "common/include/timer.h"
#include "common/include/wdog.h"
//
// Function Prototypes
//
__interrupt void cpu_timer0_isr(void);
__interrupt void cpu_timer1_isr(void);
__interrupt void cpu_timer2_isr(void);
int i=0;
int miao1=0,fen1=0,shi1=0;
int shi_H1=0,shi_L1=0,fen_H1=0,fen_L1=0,miao_H1=0,miao_L1=0;
int flag=0;
int miao2=0,fen2=0,shi2=0;
int shi_H2=0,shi_L2=0,fen_H2=0,fen_L2=0,miao_H2=0,miao_L2=0;
//
// Globals
//
unsigned long timer0IntCount;
unsigned long timer1IntCount;
unsigned long timer2IntCount;
CLK_Handle myClk;
FLASH_Handle myFlash;
GPIO_Handle myGpio;
PIE_Handle myPie;
TIMER_Handle myTimer0, myTimer1, myTimer2;
//
// Main
//
void main(void)
{
    CPU_Handle myCpu;
    PLL_Handle myPll;
    WDOG_Handle myWDog;
    //
    // Initialize all the handles needed for this application
    //
    myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));
    myCpu = CPU_init((void *)NULL, sizeof(CPU_Obj));
    myFlash = FLASH_init((void *)FLASH_BASE_ADDR, sizeof(FLASH_Obj));
    myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));
    myPie = PIE_init((void *)PIE_BASE_ADDR, sizeof(PIE_Obj));
    myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj));
    myTimer0 = TIMER_init((void *)TIMER0_BASE_ADDR, sizeof(TIMER_Obj));
    myTimer1 = TIMER_init((void *)TIMER1_BASE_ADDR, sizeof(TIMER_Obj));
    myTimer2 = TIMER_init((void *)TIMER2_BASE_ADDR, sizeof(TIMER_Obj));
    myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));
    timer0IntCount = 0;
    timer1IntCount = 0;
    timer2IntCount = 0;
    //
    // Step 1. Initialize System Control:
    // PLL, WatchDog, enable Peripheral Clocks
    // This example function is found in the f2802x_SysCtrl.c file.
    //
    //InitSysCtrl();
    //
    // Perform basic system initialization
    //
    WDOG_disable(myWDog);
    CLK_enableAdcClock(myClk);
    (*Device_cal)();
    //
    // Select the internal oscillator 1 as the clock source
    //
    CLK_setOscSrc(myClk, CLK_OscSrc_Internal);
    //
    // Setup the PLL for x10 /2 which will yield 50Mhz = 10Mhz * 10 / 2
    //
    PLL_setup(myPll, PLL_Multiplier_10, PLL_DivideSelect_ClkIn_by_2);
    //
    // Disable the PIE and all interrupts
    //
    PIE_disable(myPie);
    PIE_disableAllInts(myPie);
    CPU_disableGlobalInts(myCpu);
    CPU_clearIntFlags(myCpu);
    //
    // Step 2. Initialize GPIO:
    // This example function is found in the f2802x_Gpio.c file and
    // illustrates how to set the GPIO to it's default state.
    //
    //InitGpio();  // Skipped for this example
    //
    // Step 3. Clear all interrupts and initialize PIE vector table:
    // Disable CPU interrupts
    //
    //DINT;
    //
    // Initialize the PIE control registers to their default state.
    // The default state is all PIE interrupts disabled and flags
    // are cleared.
    // This function is found in the f2802x_PieCtrl.c file.
    //
    //InitPieCtrl();
    //
    // Disable CPU interrupts and clear all CPU interrupt flags:
    //
    //IER = 0x0000;
    //IFR = 0x0000;
    //
    // Initialize the PIE vector table with pointers to the shell Interrupt
    // Service Routines (ISR).
    // This will populate the entire table, even if the interrupt
    // is not used in this example.  This is useful for debug purposes.
    // The shell ISR routines are found in f2802x_DefaultIsr.c.
    // This function is found in f2802x_PieVect.c.
    //
    //InitPieVectTable();
    PIE_setDebugIntVectorTable(myPie);
    PIE_enable(myPie);
    //
    // Interrupts that are used in this example are re-mapped to
    // ISR functions found within this file.
    //
    EALLOW;            // This is needed to write to EALLOW protected registers
    PIE_registerPieIntHandler(myPie, PIE_GroupNumber_1, PIE_SubGroupNumber_7,
                              (intVec_t)&cpu_timer0_isr);
    PIE_registerSystemIntHandler(myPie, PIE_SystemInterrupts_TINT1,
                                 (intVec_t)&cpu_timer1_isr);
    PIE_registerSystemIntHandler(myPie, PIE_SystemInterrupts_TINT2,
                                 (intVec_t)&cpu_timer2_isr);
    EDIS;    // This is needed to disable write to EALLOW protected registers
    //
    // Step 4. Initialize the Device Peripheral. This function can be
    // found in f2802x_CpuTimers.c
    //
    //InitCpuTimers();   // For this example, only initialize the Cpu Timers
    TIMER_stop(myTimer0);
    TIMER_stop(myTimer1);
    TIMER_stop(myTimer2);
#if (CPU_FRQ_50MHZ)
    //
    // Configure CPU-Timer 0, 1, and 2 to interrupt every second:
    // 50MHz CPU Freq, 1 second Period (in uSeconds)
    //
    //ConfigCpuTimer(&CpuTimer0, 50, 1000000);
    TIMER_setPeriod(myTimer0, 50 * 1000000);
    //ConfigCpuTimer(&CpuTimer1, 50, 1000000);
    TIMER_setPeriod(myTimer1, 50 * 1000000);
    //ConfigCpuTimer(&CpuTimer2, 50, 1000000);
    TIMER_setPeriod(myTimer2, 50 * 1000000);
#endif
#if (CPU_FRQ_40MHZ)
    //
    // Configure CPU-Timer 0, 1, and 2 to interrupt every second:
    // 40MHz CPU Freq, 1 second Period (in uSeconds)
    //
    //ConfigCpuTimer(&CpuTimer0, 40, 1000000);
    TIMER_setPeriod(myTimer0, 40 * 1000000);
    //ConfigCpuTimer(&CpuTimer1, 40, 1000000);
    TIMER_setPeriod(myTimer1, 40 * 1000000);
    //ConfigCpuTimer(&CpuTimer2, 40, 1000000);
    TIMER_setPeriod(myTimer2, 40 * 1000000);
#endif
    TIMER_setPreScaler(myTimer0, 0);
    TIMER_reload(myTimer0);
    TIMER_setEmulationMode(myTimer0,
                           TIMER_EmulationMode_StopAfterNextDecrement);
    TIMER_enableInt(myTimer0);
    TIMER_setPreScaler(myTimer1, 0);
    TIMER_reload(myTimer1);
    TIMER_setEmulationMode(myTimer1,
                           TIMER_EmulationMode_StopAfterNextDecrement);
    TIMER_enableInt(myTimer1);
    TIMER_setPreScaler(myTimer2, 0);
    TIMER_reload(myTimer2);
    TIMER_setEmulationMode(myTimer2,
                           TIMER_EmulationMode_StopAfterNextDecrement);
    TIMER_enableInt(myTimer2);
    //
    // To ensure precise timing, use write-only instructions to write to the
    // entire register. Therefore, if any of the configuration bits are changed
    // in ConfigCpuTimer and InitCpuTimers (in f2802x_CpuTimers.h), the
    // below settings must also be updated.
    //
   
    //
    // Use write-only instruction to set TSS bit = 0
    //
    //CpuTimer0Regs.TCR.all = 0x4001;
    TIMER_start(myTimer0);
   
    //
    // Use write-only instruction to set TSS bit = 0
    //
    //CpuTimer1Regs.TCR.all = 0x4001;
    TIMER_start(myTimer1);
   
    //
    // Use write-only instruction to set TSS bit = 0
    //
    //CpuTimer2Regs.TCR.all = 0x4001;
    TIMER_start(myTimer2);
    //
    // Step 5. User specific code, enable interrupts:
    //
    //
    // Enable CPU int1 which is connected to CPU-Timer 0, CPU int13
    // which is connected to CPU-Timer 1, and CPU int 14, which is connected
    // to CPU-Timer 2
    //
    CPU_enableInt(myCpu, CPU_IntNumber_1);
    CPU_enableInt(myCpu, CPU_IntNumber_13);
    CPU_enableInt(myCpu, CPU_IntNumber_14);
    //
    // Enable TINT0 in the PIE: Group 1 interrupt 7
    //
    PIE_enableTimer0Int(myPie);
    //
    // Enable global Interrupts and higher priority real-time debug events
    //
    CPU_enableGlobalInts(myCpu);       // Enable Global interrupt INTM
    CPU_enableDebugInt(myCpu);         // Enable Global realtime interrupt DBGM
    //
    // Step 6. IDLE loop. Just sit and loop forever (optional)
    //
//    for(;;);

    EALLOW;
    GpioCtrlRegs.GPAPUD.bit.GPIO28 = 0;   // Enable pullup on GPIO28
    GpioDataRegs.GPASET.bit.GPIO28 = 1;   // Load output latch
    GpioCtrlRegs.GPAMUX2.bit.GPIO28 = 0;  // GPIO28 = GPIO28
    GpioCtrlRegs.GPADIR.bit.GPIO28 = 1;   // GPIO28 = output
    GpioCtrlRegs.GPAPUD.bit.GPIO29 = 0;   // Enable pullup on GPIO29
    GpioDataRegs.GPASET.bit.GPIO29 = 1;   // Load output latch
    GpioCtrlRegs.GPAMUX2.bit.GPIO29 = 0;  // GPIO29 = GPIO29
    GpioCtrlRegs.GPADIR.bit.GPIO29 = 1;   // GPIO29 = output
    GpioCtrlRegs.GPBPUD.bit.GPIO34 = 0;   // Enable pullup on GPIO34
    GpioDataRegs.GPBSET.bit.GPIO34 = 1;   // Load output latch
    GpioCtrlRegs.GPBMUX1.bit.GPIO34 = 0;  // GPIO34 = GPIO34
    GpioCtrlRegs.GPBDIR.bit.GPIO34 = 1;   // GPIO34 = output
    EDIS;

    unsigned char key_value;
    LedDisplay(2,0,1,4,0,8,0,8);
    delay_ms(1000);

    while(1)
   {
    key_value=Read_key();
    switch (key_value)
    {
        case 1:
        flag = 1;
        break;
        case 2 :
        flag = 2;
        break;
        case 3 :
        LedDisplay(0,0,0,0,0,0,0,3);
        break;
        case 4 :
        LedDisplay(0,0,0,0,0,0,0,4);
        break;
        case 5 :
        LedDisplay(0,0,0,0,0,0,0,5);
        break;
        case 6 :
        LedDisplay(0,0,0,0,0,0,0,6);
        break;
        case 7 :
        LedDisplay(0,0,0,0,0,0,0,7);
        break;
        case 8 :
        LedDisplay(0,0,0,0,0,0,0,8);
        break;
        case 9:
        LedDisplay(0,0,0,0,0,0,0,9);
        break;
        case 10 :
        LedDisplay(0,0,0,0,0,0,1,0);
        break;
        case 11 :
        LedDisplay(0,0,0,0,0,0,1,1);
        break;
        case 12 :
        LedDisplay(0,0,0,0,0,0,1,2);
        break;
        case 13 :
        LedDisplay(0,0,0,0,0,0,1,3);
        break;
        case 14 :
        LedDisplay(0,0,0,0,0,0,1,4);
        break;
        case 15:
        LedDisplay(0,0,0,0,0,0,1,5);
        break;
        case 16 :
        LedDisplay(0,0,0,0,0,0,1,6);
        break;
        default :
        break;//LedDisplay(0,0,0,0,0,0,0,0);
    }
   }
}
//
// cpu_timer0_isr -
//
__interrupt void
cpu_timer0_isr(void)
{
    timer0IntCount++;
    //
    // Acknowledge this interrupt to receive more interrupts from group 1
    //
    //PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;
    PIE_clearInt(myPie, PIE_GroupNumber_1);//中断标记清零
    //
    if(flag==1)
    {
    LedDisplay(shi_H1 , shi_L1 , 16 , fen_H1 , fen_L1 , 16 , miao_H1 , miao_L1);
    i++;
    if(i == 1000){
        i = 0;  //满一秒清零
        miao1++; //i = 1000 为一，秒标志位加 1
        if(flag == 1)
            {
                LedDisplay(shi_H1 , shi_L1 , 16 , fen_H1 , fen_L1 , 16 , miao_H1 , miao_L1);
            }
        if(miao1 == 60){
            miao1 = 0;  //满一分清零
            fen1++;
            if(flag == 1)
            {
                LedDisplay(shi_H1 , shi_L1 , 16 , fen_H1 , fen_L1 , 16 , miao_H1 , miao_L1);
            }
            if(fen1 == 60){
                fen1 = 0;  //满一时清零
                miao1 = 0;
                shi1++;
                if(flag == 1)
                    {
                        LedDisplay(shi_H1 , shi_L1 , 16 , fen_H1 , fen_L1 , 16 , miao_H1 , miao_L1);
                    }
                if(shi1 == 24){
                    shi1 = 0;  //24小时制
                    fen1 = 0;
                    miao1 = 0;
                    if(flag == 1)
                        {
                            LedDisplay(shi_H1 , shi_L1 , 16 , fen_H1 , fen_L1 , 16 , miao_H1 , miao_L1);
                        }
                }
             }
          }
          miao_L1 = miao1%10;  //秒个位
          miao_H1 = miao1/10;  //秒十位
          fen_L1 = fen1%10;  //分个位
          fen_H1 = fen1/10;  //分十位
          shi_L1 = shi1%10;  //时个位
          shi_H1 = shi1/10;  //时十位
    }
          //LedDisplay(shi_H1 , shi_L1 , 16 , fen_H1 , fen_L1 , 16 , miao_H1 , miao_L1);
    }
    if(flag==1)
    {
    LedDisplay(shi_H1 , shi_L1 , 16 , fen_H1 , fen_L1 , 16 , miao_H1 , miao_L1);
    i++;
    if(i == 1500){
        i = 0;  //满一秒清零
        miao1++; //i = 1000 为一，秒标志位加 1
        if(flag == 1)
            {
                LedDisplay(shi_H1 , shi_L1 , 16 , fen_H1 , fen_L1 , 16 , miao_H1 , miao_L1);
            }
        if(miao1 == 60){
            miao1 = 0;  //满一分清零
            fen1++;
            if(flag == 1)
                {
                    LedDisplay(shi_H1 , shi_L1 , 16 , fen_H1 , fen_L1 , 16 , miao_H1 , miao_L1);
                }
            if(fen1 == 60){
                fen1 = 0;  //满一时清零
                miao1 = 0;
                shi1++;
                if(flag == 1)
                    {
                        LedDisplay(shi_H1 , shi_L1 , 16 , fen_H1 , fen_L1 , 16 , miao_H1 , miao_L1);
                    }
                if(shi1 == 24){
                    shi1 = 0;  //24小时制
                    fen1 = 0;
                    miao1 = 0;
                    if(flag == 1)
                        {
                             LedDisplay(shi_H1 , shi_L1 , 16 , fen_H1 , fen_L1 , 16 , miao_H1 , miao_L1);
                        }
                }
             }
          }
          miao_L1 = miao1%10;  //秒个位
          miao_H1 = miao1/10;  //秒十位
          fen_L1 = fen1%10;  //分个位
          fen_H1 = fen1/10;  //分十位
          shi_L1 = shi1%10;  //时个位
          shi_H1 = shi1/10;  //时十位
    }
          //LedDisplay(shi_H1 , shi_L1 , 16 , fen_H1 , fen_L1 , 16 , miao_H1 , miao_L1);
    }
     if(flag==2)
     {
         LedDisplay(shi_H2 , shi_L2 , 16 , fen_H2 , fen_L2 , 16 , miao_H2 , miao_L2);
         i++;
         if(i == 1000){
             i = 0;  //满一秒清零
             miao2++; //i = 1000 为一，秒标志位加 1
             if(flag == 2)
                 {
                     LedDisplay(shi_H2 , shi_L2 , 16 , fen_H2 , fen_L2 , 16 , miao_H2 , miao_L2);
                 }
             if(miao2 == 60){
                 miao2 = 0;  //满一分清零
                 fen2++;
                 if(flag == 2)
                    {
                        LedDisplay(shi_H2 , shi_L2 , 16 , fen_H2 , fen_L2 , 16 , miao_H2 , miao_L2);
                    }
                 if(fen2 == 60){
                     fen2 = 0;  //满一时清零
                     miao2 = 0;
                     shi2++;
                     if(flag == 2)
                        {
                             LedDisplay(shi_H2 , shi_L2 , 16 , fen_H2 , fen_L2 , 16 , miao_H2 , miao_L2);
                        }
                     if(shi2 == 24){
                         shi2 = 0;  //24小时制
                         fen2 = 0;
                         miao2 = 0;
                         if(flag == 2)
                            {
                                LedDisplay(shi_H2 , shi_L2 , 16 , fen_H2 , fen_L2 , 16 , miao_H2 , miao_L2);
                            }
                     }
                  }
               }
               miao_L2 = miao2%10;  //秒个位
               miao_H2 = miao2/10;  //秒十位
               fen_L2 = fen2%10+2;  //分个位
               fen_H2 = fen2/10;  //分十位
               shi_L2 = shi2%10;  //时个位
               shi_H2 = shi2/10+1;  //时十位
         }
               //LedDisplay(shi_H2 , shi_L2 , 16 , fen_H2 , fen_L2 , 16 , miao_H2 , miao_L2);
     }
     if(flag==2)
         {
             LedDisplay(shi_H2 , shi_L2 , 16 , fen_H2 , fen_L2 , 16 , miao_H2 , miao_L2);
             i++;
             if(i == 1500){
                 i = 0;  //满一秒清零
                 miao2++; //i = 1000 为一，秒标志位加 1
                 if(flag == 2)
                    {
                        LedDisplay(shi_H2 , shi_L2 , 16 , fen_H2 , fen_L2 , 16 , miao_H2 , miao_L2);
                    }
                 if(miao2 == 60){
                     miao2 = 0;  //满一分清零
                     fen2++;
                     if(flag == 2)
                        {
                            LedDisplay(shi_H2 , shi_L2 , 16 , fen_H2 , fen_L2 , 16 , miao_H2 , miao_L2);
                        }
                     if(fen2 == 60){
                         fen2 = 0;  //满一时清零
                         miao2 = 0;
                         shi2++;
                         if(flag == 2)
                             {
                                LedDisplay(shi_H2 , shi_L2 , 16 , fen_H2 , fen_L2 , 16 , miao_H2 , miao_L2);
                             }
                         if(shi2 == 24){
                             shi2 = 0;  //24小时制
                             fen2 = 0;
                             miao2 = 0;
                             if(flag == 2)
                                {
                                    LedDisplay(shi_H2 , shi_L2 , 16 , fen_H2 , fen_L2 , 16 , miao_H2 , miao_L2);
                                }
                         }
                      }
                   }
                   miao_L2 = miao2%10;  //秒个位
                   miao_H2 = miao2/10;  //秒十位
                   fen_L2 = fen2%10+2;  //分个位
                   fen_H2 = fen2/10;  //分十位
                   shi_L2 = shi2%10;  //时个位
                   shi_H2 = shi2/10+1;  //时十位
             }
                   //LedDisplay(shi_H2 , shi_L2 , 16 , fen_H2 , fen_L2 , 16 , miao_H2 , miao_L2);
         }
}

//
// cpu_timer1_isr -
//
__interrupt void
cpu_timer1_isr(void)
{
    timer1IntCount++;
}
//
// cpu_timer2_isr -
//
__interrupt void
cpu_timer2_isr(void)
{
    timer2IntCount++;
}

void LedDisplay(unsigned char data0,unsigned char data1,unsigned char data2,unsigned char data3,
               unsigned char data4,unsigned char data5,unsigned char data6,unsigned char data7)
{
    unsigned char  writedata0,writedata1,writedata2,writedata3,writedata4,writedata5,writedata6,writedata7;
    writedata0=(tab[data7]&0x01)+((tab[data6]&0x01)<<1)+((tab[data5]&0x01)<<2)+((tab[data4]&0x01)<<3)+((tab[data3]&0x01)<<4)
        +((tab[data2]&0x01)<<5)+((tab[data1]&0x01)<<6)+((tab[data0]&0x01)<<7);
    writedata1=((tab[data7]&0x02)>>1)+((tab[data6]&0x02))+((tab[data5]&0x02)<<1)+((tab[data4]&0x02)<<2)+((tab[data3]&0x02)<<3)
        +((tab[data2]&0x02)<<4)+((tab[data1]&0x02)<<5)+((tab[data0]&0x02)<<6);
    writedata2=((tab[data7]&0x04)>>2)+((tab[data6]&0x04)>>1)+((tab[data5]&0x04))+((tab[data4]&0x04)<<1)+((tab[data3]&0x04)<<2)
        +((tab[data2]&0x04)<<3)+((tab[data1]&0x04)<<4)+((tab[data0]&0x04)<<5);
    writedata3=((tab[data7]&0x08)>>3)+((tab[data6]&0x08)>>2)+((tab[data5]&0x08)>>1)+((tab[data4]&0x08))+((tab[data3]&0x08)<<1)
        +((tab[data2]&0x08)<<2)+((tab[data1]&0x08)<<3)+((tab[data0]&0x08)<<4);
    writedata4=((tab[data7]&0x10)>>4)+((tab[data6]&0x10)>>3)+((tab[data5]&0x10)>>2)+((tab[data4]&0x10)>>1)+((tab[data3]&0x10))
        +((tab[data2]&0x10)<<1)+((tab[data1]&0x10)<<2)+((tab[data0]&0x10)<<3);
    writedata5=((tab[data7]&0x20)>>5)+((tab[data6]&0x20)>>4)+((tab[data5]&0x20)>>3)+((tab[data4]&0x20)>>2)+((tab[data3]&0x20)>>1)
        +((tab[data2]&0x20))+((tab[data1]&0x20)<<1)+((tab[data0]&0x20)<<2);
    writedata6=((tab[data7]&0x40)>>6)+((tab[data6]&0x40)>>5)+((tab[data5]&0x40)>>4)+((tab[data4]&0x40)>>3)+((tab[data3]&0x40)>>2)
        +((tab[data2]&0x40)>>1)+((tab[data1]&0x40))+((tab[data0]&0x40)<<1);
    writedata7=((tab[data7]&0x80)>>7)+((tab[data6]&0x80)>>6)+((tab[data5]&0x80)>>5)+((tab[data4]&0x80)>>4)+((tab[data3]&0x80)>>3)
        +((tab[data2]&0x80)>>2)+((tab[data1]&0x80)>>1)+((tab[data0]&0x80));
    Write_COM(0x8a);//亮度
    Write_COM(0x40); //写 数据命令
//    GpioDataRegs.GPBDAT.bit.GPIO34 =0;
    STB = 0;
    TM1638_Write(0xc0);     //写地址命令
    TM1638_Write(writedata0);
    TM1638_Write(0x80);
    TM1638_Write(writedata1);
    TM1638_Write(0x00);
    TM1638_Write(writedata2);
    TM1638_Write(0x00);
    TM1638_Write(writedata3);
    TM1638_Write(0x00);
    TM1638_Write(writedata4);
    TM1638_Write(0x00);
    TM1638_Write(writedata5);
    TM1638_Write(0x00);
    TM1638_Write(writedata6);
    TM1638_Write(0x00);
    TM1638_Write(writedata7);
    TM1638_Write(0x00);
    STB=1;
}//
// End of File
//