Chinaunix首页 | 论坛 | 博客

天行健，君子以自强不息domyself.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

number007cool

  • 博客访问： 2006428
  • 博文数量： 356
  • 博客积分： 8284
  • 博客等级： 中将
  • 技术积分： 4580
  • 用 户 组： 普通用户
  • 注册时间： 2009-05-15 20:25
个人简介

天行健，君子以自强不息

文章分类

全部博文（356）

文章存档

2018年（1）

2016年（4）

2015年（13）

2014年（14）

2013年（2）

2012年（25）

2011年（43）

2010年（65）

2009年（189）

我的朋友
最近访客
推荐博文
相关博文
基于ds3232的高精度万年历

分类： C/C++

2014-01-20 19:11:37

用的样片，首次在热转印印制电路板中使用贴片元器件。一版成功。
由于用138做片选，所以要用共阴数码管，共阳的没办法动态扫描。
好了，程序如下：
/*
硬件:STC89C52RC+数码管+DS3232
软件:Keil3
创建时间:        2014.1.18
最后修改时间:    2014.1.20
*/

#include "reg52.h"
#define uchar unsigned char
#define uint  unsigned int

#define ADDRTC  0xd0    /* DS3232地址 (write) */
#define ACK     0
#define NACK    1
#define  PD   P0
#define  PW      P2


sbit    scl = P2^6;             /* I2C SCK */
sbit    sda = P2^7;                /* I2C SDA */

sbit    key1=P3^3;
sbit    key2=P3^4;
sbit    key3=P3^5;

sbit    JDQ= P3^6;// 继电器，低电平有效           
sbit    RING = P3^7;//蜂鸣器，低电平有效
sbit    LE=P2^5;  //LE所存端,始终给高电平即可    
sbit    PW0=P2^0;
sbit    PW1=P2^1;
sbit    PW2=P2^2;
sbit    DS18B20=P2^3;



uchar code duan[10] ={0x03,0x3f,0x91,0xc1,0x65,0x49,0x09,0xe3,0x01,0x41};
uchar code wei[4]={0,4,2,6};


void uart_printf(unsigned char *buff);
void    start();
void    stop();
uchar   i2cwrite(uchar d);
uchar   i2cread(char);
void    hex2asc(uchar);
void    writebyte();
void    initialize_DS3232();
void    rd_temp();
void    frq_out_tog();
void    init_alrm();

 
uchar bcd2hex(uchar x)
{
    return ( ((x&0xf0)>>4)*10 + (x&0x0f) );
}


unsigned char hex2bcd(unsigned char byBCDVal)
{
    return (unsigned char)(byBCDVal/10*16 + byBCDVal%10);
}

/************************* Global Variables ***************************/
xdata   uchar   sec, min, hr, dy, dt, mn, yr;
/**************************** functions ******************************/
void start()          
{
        sda = 1;  scl = 1;
        sda = 0;
}
void stop()           
{
        sda = 0;  sda = 0;
        scl = 1;  scl = 1;  sda = 1;
}
uchar i2cwrite(uchar d)         
{
    uchar i;

    scl = 0;
    for (i = 0;i < 8; i++)
    {
            if (d & 0x80)
                    sda = 1; /* Send the msbits first */
            else
                    sda = 0;
            scl = 0;
            scl = 1;
            d = d << 1;     /* do shift here to increase scl high time */
            scl = 0;
    }
    sda = 1;        /* Release the sda line */
    scl = 0;
    scl = 1;
    i = sda;
    if (i)
    {
        //printf("Ack bit missing  %02X\n",(unsigned int)d);
    }
    scl = 0;
    return(i);
}
uchar i2cread(char b)   /* ----------------------------------- */
{
    uchar i, d;

    d = 0;
    sda = 1;             /* Let go of sda line */
    scl = 0;
    for (i = 0; i < 8; i++) /* read the msb first */
    {
            scl = 1;
            d = d << 1;
            d = d | (unsigned char)sda;
            scl = 0;
    }
    sda = b;          /* low for ack, high for nack */
    scl = 1;
    scl = 0;

    sda = 1;          /* Release the sda line */
    return d;
}


void    initialize_DS3232()     /* ----- set time & date; user data entry ------ */
/* Note: NO error checking is done on the user entries! */
{
    
    yr=14;
    mn=1;
    dt=19;


    dy=7;
    hr=20;
    min=25;
    sec=10;

      
    yr=hex2bcd(yr);
    mn=hex2bcd(mn);
    dt=hex2bcd(dt);
    dy=hex2bcd(dy);

    hr=hex2bcd(hr);
    min=hex2bcd(min);
    sec=hex2bcd(sec);

    start();
    i2cwrite(ADDRTC);       /* write slave address, write 1339 */
    i2cwrite(0x00); /* write register address, 1st clock register */
    i2cwrite(sec);
    i2cwrite(min);
    i2cwrite(hr);
    i2cwrite(dy);
    i2cwrite(dt);
    i2cwrite(mn);
    i2cwrite(yr);
    i2cwrite(0x10); /* enable sqw, 1hz output */
    stop();
}
void    disp_regs()     /* --- display date/time on LCD display --- */
{
    uchar str[24];
    uchar i=0;
    start();
    i2cwrite(ADDRTC);
    i2cwrite(0x0f);
    i2cwrite(0);            /* clear alarm flags */
    stop();

    start();
    i2cwrite(ADDRTC);
    i2cwrite(0);
    start();
    i2cwrite(ADDRTC | 1);
    sec = i2cread(ACK);
    min = i2cread(ACK);
    hr = i2cread(ACK);
    dy = i2cread(ACK);
    dt = i2cread(ACK);
    mn = i2cread(ACK);
    yr = i2cread(NACK);

    sec=bcd2hex(sec);
    min=bcd2hex(min);
    hr=bcd2hex(hr);
    dy=bcd2hex(dy);
    dt=bcd2hex(dt);
    mn=bcd2hex(mn);
    yr=bcd2hex(yr);
    

    stop();

    str[i++]=yr/10+'0';
    str[i++]=yr%10+'0';
    str[i++]='-';
    str[i++]=mn/10+'0';
    str[i++]=mn%10+'0';
    str[i++]='-';
    str[i++]=dt/10+'0';
    str[i++]=dt%10+'0';



    str[i++]=' ';
    str[i++]=hr/10+'0';
    str[i++]=hr%10+'0';
    str[i++]=':';
    str[i++]=min/10+'0';
    str[i++]=min%10+'0';
    str[i++]=':';
    str[i++]=sec/10+'0';
    str[i++]=sec%10+'0';

    str[i++]=' ';
    str[i++]=' ';
    str[i++]=dy%10+'0';

    str[i++]='\r';
    str[i]='\n';
    //uart_printf(str);

}
void    rd_temp()       /* -------- display temperature -------- */
{
    char    str[22];
    int     itemp;
    float   ftemp;

    do
    {
        start();
        i2cwrite(ADDRTC);
        i2cwrite(0x0e);         /* address of control register */
        start();
        i2cwrite(ADDRTC + 1);   /* send the device address for read */
        itemp = i2cread(NACK);  /* get the control register value */
        stop();
    }       
    while(itemp & 0x20);            /* wait until CNVT bit goes inactive */

    start();
    i2cwrite(ADDRTC);
    i2cwrite(0x11);                 /* address of temperature MSB */
    start();
    i2cwrite(ADDRTC + 1);           /* send the device address for read */
    itemp = ( (int) i2cread(ACK) << 2 );
    itemp += ( i2cread(NACK) >> 6);
    stop();
    if(itemp & 0x1000)      itemp += 0xe000;        /* if sign bit set, make 16 bit 2's comp */

    itemp=itemp>>2;

    str[0]=itemp/100+'0';
    str[1]=itemp%100/10+'0';
    str[2]=itemp%10+'0';


    uart_printf(str);
    uart_printf("\r\n");

    ftemp = 0.03125 * (float) itemp;        /* convert to degrees C */
}
void    frq_out_tog()   /* --- toggle en32khz bit to enable/disable sqw --- */
{
uchar   val;

        start();
        i2cwrite(ADDRTC);
        i2cwrite(0x0f);                 /* control/status reg address */
        start();
        i2cwrite(ADDRTC + 1);           /* send the device address for read */
        val = i2cread(NACK);
        stop();
        val ^= 0x08;    /* toggle en32khz bit */
        start();
        i2cwrite(ADDRTC);
        i2cwrite(0x0f);                 /* control/status reg address */
        i2cwrite(val);
        stop();
}
void    init_alrm()     /* --- enable alarm 1 for once-per-second --- */
{
        start();
        i2cwrite(ADDRTC);
        i2cwrite(7);            /* 1st alarm 1 reg address */
        i2cwrite(0x80); /* mask alarm register */
        i2cwrite(0x80);
        i2cwrite(0x80);
        i2cwrite(0x80);
        stop();

        start();
        i2cwrite(ADDRTC);
        i2cwrite(0x0e); /* control/status reg address */
        i2cwrite(0x05); /* enable interrupts, alarm 1 output */
}
void    comm_init()     /* ------ reset DS3232 comm interface ------ */
{
    do      /* because the DS3232 I2C interface is active for both supplies */
    {       /*  after a micro reset, we must get the comm into a known state */
        sda = 1;        /* make sure master has released SDA */
        scl = 1;
        if(sda) /* if sda is high, generate a start */
        {
                sda = 0;        /* The DS3232 will recognize a valid start */
                sda = 1;        /*  condition anywhere in a I2C data transfer */
        }
        scl = 0;
    }       
    while(sda == 0);        /* if the DS3232 is holding sda low, try again */
}
void uart_init()
{
   TMOD|=0x20;     //TMOD＝0
   TH1=0xf3;      //12MHZ   ，BPS：4800，N，8，1,0xf3=243
   TL1=0xf3;
   
   TR1=1;

   PCON=0x80;     //SMOD=1,方式一,8位数据位，一位起始位和一位结束位
            //
   SCON=0x50;     //串口通信控制寄存器  模式一

   EA=1;
  // ES=1;  //打开串口中断
   //REN=1;
 
}

void uart_putchar(unsigned char dat)
{
    SBUF=dat; //把数据送给sbuf缓存器中
    while(TI!=1);//发送标志位 TI如果发送了为1，没发送为0，没发送等待，到了退出循环
    TI=0;  //到了，TI清为0

}
void uart_printf(unsigned char *buff)
{

    while(*buff)
       uart_putchar(*buff++);
}
void delay(unsigned int k)    
{    
    unsigned int i,j;    
    for(i=0;i
    {    
    for(j=0;j<121;j++)    
    {;}
    }    
}
 void Seg_DisPlay(uint x)
 {
     uchar i,j;
    LE=1;

    PW0=0;
    PW1=0;
    PW2=0;
    PD=0xff-duan[x/1000];
    delay(5);

    PW0=0;
    PW1=0;
    PW2=1;
    PD=0xff-duan[x%1000/100];
    delay(5);

    PW0=0;
    PW1=1;
    PW2=0;
    PD=0xff-duan[x%100/10];
    delay(5);

    PW0=0;
    PW1=1;
    PW2=1;
    PD=0xff-duan[x%10];
    delay(5);


    
 }

void  Led_Test()
{
      char i,j;
    
     for(j=0;j<4;j++)
     {
         PW=wei[j] |(1<<5) ;
         for(i=0;i<10;i++)
         {
             PD= 0xff-duan[i];
            delay(200);
         }
     }
}
void   main    (void)  /* ------------------------------------------------ */
{
    comm_init();
    uart_init();
    //initialize_DS3232();
    //init_alrm();            /* enable alarm */
 
    while(1)
    {
        P1=0xFf-sec;
          //rd_temp();
        
          disp_regs();
          JDQ=1;
          RING=1;
          if(key1==0)
          {
                  Seg_DisPlay( (mn*100+dt) );
          }
          else if(key2==0)
          {
                  Seg_DisPlay( (sec) );
          }
          else if(key3==0)
          {
                Seg_DisPlay( (dy) );
          }
          else
          {
                  Seg_DisPlay( (hr*100+min) );
          }
        
           //delay(3000);
          
    }

}
原理图如下：

pcb图如下：

实物图如下：





总共做了两块，由于内置晶振并带有温度补偿，所以精度很高。跑了两天时间1秒不差！

最新版本程序：
main.c

点击(此处)折叠或打开

  1. /*
  2. 硬件:STC89C52RC+数码管(共阴，高电平亮)+DS3232
  3. 软件:Keil3
  4. 创建时间:        2014.1.18
  5. 最后修改时间:    2014.11.14        添加按键修改年月日时分秒星期的功能，添加DS18B20温度显示

  7. 管脚描述：

  9. 继电器输出：P36
  10. 蜂鸣器输出：P37
  11. 按键1-按键3:P33，P34，P35
  12. 红外线输入：P32
  13. LED1-LED8： P10-P17
  14. 数码管段选：P0
  15. 数码管位选：P20,P21,P22
  16. 74HC573-LE: P25
  17. DS18B20:    P23
  18. IIC_SCL:     P26
  19. IIC_SDA:    P27

  21. */
  22. #define CMD_RING_TMP         8
  23. #define CMD_RING_DATE        9
  24. #define CMD_RING_TIME        10

  26. #include "config.h"

  28. #define ADDRTC 0xd0 /* DS3232地址 (write) */
  29. #define ACK 0
  30. #define NACK 1
  31. #define PD P0
  32. #define PW     P2
  33. #define CHECK_BIT(value,x)     (value &( (1<<x) ) )?0:1

  35. uchar code     g_uchLedTab[]=
  36. {0,1,2,4,8,4,2,1,0,9,6,0,6,9,15,9,6,0,12,6,3,0,3,6,12,10,5,0,5,10};

  38. #define TAB_NUM            sizeof(g_uchLedTab)/sizeof(char)

  40. sbit scl = P2^6; /* I2C SCK */
  41. sbit sda = P2^7;                /* I2C SDA */

  43. sbit key1=P3^3;
  44. sbit key2=P3^4;
  45. sbit key3=P3^5;

  47. sbit JDQ= P3^6;// 继电器，低电平有效
  48. sbit RING = P3^7;//蜂鸣器，低电平有效
  49. sbit LE=P2^5; //LE所存端,始终给高电平即可    
  50. sbit PW0=P2^0;
  51. sbit PW1=P2^1;
  52. sbit PW2=P2^2;
  53. sbit DS18B20=P2^3;


  56. sbit     LED1=P1^0;
  57. sbit     LED2=P1^1;
  58. sbit     LED3=P1^2;
  59. sbit     LED4=P1^3;
  60. sbit     LED5=P1^4;

  62. sbit    yy_rst=P1^7;
  63. sbit yy_dat=P1^6;
  64. sbit yy_busy=P1^5;



  68. uchar code duan[10] ={0x03,0x3f,0x91,0xc1,0x65,0x49,0x09,0xe3,0x01,0x41};
  69. uchar code wei[4]={0,4,2,6};
  70. uchar g_bNotDisSeg=0;

  72. void uart_printf(unsigned char *buff);
  73. void start();
  74. void stop();
  75. uchar i2cwrite(uchar d);
  76. uchar i2cread(char);
  77. void hex2asc(uchar);
  78. void writebyte();
  79. void initialize_DS3232();
  80. void rd_temp();
  81. void frq_out_tog();
  82. void init_alrm();

  84. void delay(unsigned int k);    
  85. uchar bcd2hex(uchar x)
  86. {
  87.     return ( ((x&0xf0)>>4)*10 + (x&0x0f) );
  88. }


  91. unsigned char hex2bcd(unsigned char byBCDVal)
  92. {
  93.     return (unsigned char)(byBCDVal/10*16 + byBCDVal%10);
  94. }

  96. /************************* Global Variables ***************************/
  97. uchar xdata sec, min, hr, dy, dt, mn, yr;
  98. /**************************** functions ******************************/
  99. void start()
  100. {
  101.         sda = 1; scl = 1;
  102.         sda = 0;
  103. }
  104. void stop()
  105. {
  106.         sda = 0; sda = 0;
  107.         scl = 1; scl = 1; sda = 1;
  108. }
  109. uchar i2cwrite(uchar d)
  110. {
  111.     uchar i;

  113.     scl = 0;
  114.     for (i = 0;i < 8; i++)
  115.     {
  116.      if (d & 0x80)
  117.      sda = 1; /* Send the msbits first */
  118.      else
  119.      sda = 0;
  120.      scl = 0;
  121.      scl = 1;
  122.      d = d << 1; /* do shift here to increase scl high time */
  123.      scl = 0;
  124.     }
  125.     sda = 1; /* Release the sda line */
  126.     scl = 0;
  127.     scl = 1;
  128.     i = sda;
  129.     if (i)
  130.     {
  131.         //printf("Ack bit missing %02X\n",(unsigned int)d);
  132.     }
  133.     scl = 0;
  134.     return(i);
  135. }
  136. uchar i2cread(char b) /* ----------------------------------- */
  137. {
  138.     uchar i, d;

  140.     d = 0;
  141.     sda = 1; /* Let go of sda line */
  142.     scl = 0;
  143.     for (i = 0; i < 8; i++) /* read the msb first */
  144.     {
  145.             scl = 1;
  146.             d = d << 1;
  147.             d = d | (unsigned char)sda;
  148.             scl = 0;
  149.     }
  150.     sda = b; /* low for ack, high for nack */
  151.     scl = 1;
  152.     scl = 0;

  154.     sda = 1; /* Release the sda line */
  155.     return d;
  156. }


  159. void initialize_DS3232() /* ----- set time & date; user data entry ------ */
  160. /* Note: NO error checking is done on the user */
  161. {
  162.     
  163.     yr=14;//year
  164.     mn=6;//month
  165.     dt=29;//day


  168.     dy=7;
  169.     hr=11;//hour
  170.     min=48;//minute
  171.     sec=30;//second

  173.     
  174.     yr=hex2bcd(yr);
  175.     mn=hex2bcd(mn);
  176.     dt=hex2bcd(dt);
  177.     dy=hex2bcd(dy);

  179.     hr=hex2bcd(hr);
  180.     min=hex2bcd(min);
  181.     sec=hex2bcd(sec);

  183.     start();
  184.     i2cwrite(ADDRTC); /* write slave address, write 1339 */
  185.     i2cwrite(0x00); /* write register address, 1st clock register */
  186.     i2cwrite(sec);
  187.     i2cwrite(min);
  188.     i2cwrite(hr);
  189.     i2cwrite(dy);
  190.     i2cwrite(dt);
  191.     i2cwrite(mn);
  192.     i2cwrite(yr);
  193.     i2cwrite(0x10); /* enable sqw, 1hz output */
  194.     stop();
  195. }

  197. void ReInitialDS3232(void)
  198. {
  199.         
  200.     yr=hex2bcd(yr);
  201.     mn=hex2bcd(mn);
  202.     dt=hex2bcd(dt);
  203.     dy=hex2bcd(dy);

  205.     hr=hex2bcd(hr);
  206.     min=hex2bcd(min);
  207.     sec=hex2bcd(sec);

  209.     start();
  210.     i2cwrite(ADDRTC); /* write slave address, write 1339 */
  211.     i2cwrite(0x00); /* write register address, 1st clock register */
  212.     i2cwrite(sec);
  213.     i2cwrite(min);
  214.     i2cwrite(hr);
  215.     i2cwrite(dy);
  216.     i2cwrite(dt);
  217.     i2cwrite(mn);
  218.     i2cwrite(yr);
  219.     i2cwrite(0x10); /* enable sqw, 1hz output */
  220.     stop();
  221. }
  222. void disp_regs() /* --- display date/time on LCD display --- */
  223. {
  224.     uchar str[24];
  225.     uchar i=0;
  226.     start();
  227.     i2cwrite(ADDRTC);
  228.     i2cwrite(0x0f);
  229.     i2cwrite(0); /* clear alarm flags */
  230.     stop();

  232.     start();
  233.     i2cwrite(ADDRTC);
  234.     i2cwrite(0);
  235.     start();
  236.     i2cwrite(ADDRTC | 1);
  237.     sec = i2cread(ACK);
  238.     min = i2cread(ACK);
  239.     hr = i2cread(ACK);
  240.     dy = i2cread(ACK);
  241.     dt = i2cread(ACK);
  242.     mn = i2cread(ACK);
  243.     yr = i2cread(NACK);

  245.     sec=bcd2hex(sec);
  246.     min=bcd2hex(min);
  247.     hr=bcd2hex(hr);
  248.     dy=bcd2hex(dy);
  249.     dt=bcd2hex(dt);
  250.     mn=bcd2hex(mn);
  251.     yr=bcd2hex(yr);
  252.     

  254.     stop();

  256.     str[i++]=yr/10+'0';
  257.     str[i++]=yr%10+'0';
  258.     str[i++]='-';
  259.     str[i++]=mn/10+'0';
  260.     str[i++]=mn%10+'0';
  261.     str[i++]='-';
  262.     str[i++]=dt/10+'0';
  263.     str[i++]=dt%10+'0';



  267.     str[i++]=' ';
  268.     str[i++]=hr/10+'0';
  269.     str[i++]=hr%10+'0';
  270.     str[i++]=':';
  271.     str[i++]=min/10+'0';
  272.     str[i++]=min%10+'0';
  273.     str[i++]=':';
  274.     str[i++]=sec/10+'0';
  275.     str[i++]=sec%10+'0';

  277.     str[i++]=' ';
  278.     str[i++]=' ';
  279.     str[i++]=dy%10+'0';

  281.     str[i++]='\r';
  282.     str[i]='\n';
  283.     //uart_printf(str);

  285. }
  286. void rd_temp() /* -------- display temperature -------- */
  287. {
  288.     char xdata str[22];
  289.     int xdata itemp;
  290.     float xdata ftemp;

  292.     do
  293.     {
  294.         start();
  295.         i2cwrite(ADDRTC);
  296.         i2cwrite(0x0e); /* address of control register */
  297.         start();
  298.         i2cwrite(ADDRTC + 1); /* send the device address for read */
  299.         itemp = i2cread(NACK); /* get the control register value */
  300.         stop();
  301.     }
  302.     while(itemp & 0x20); /* wait until CNVT bit goes inactive */

  304.     start();
  305.     i2cwrite(ADDRTC);
  306.     i2cwrite(0x11); /* address of temperature MSB */
  307.     start();
  308.     i2cwrite(ADDRTC + 1); /* send the device address for read */
  309.     itemp = ( (int) i2cread(ACK) << 2 );
  310.     itemp += ( i2cread(NACK) >> 6);
  311.     stop();
  312.     if(itemp & 0x1000) itemp += 0xe000; /* if sign bit set, make 16 bit 2's comp */

  314.     itemp=itemp>>2;

  316.     str[0]=itemp/100+'0';
  317.     str[1]=itemp%100/10+'0';
  318.     str[2]=itemp%10+'0';


  321.     uart_printf(str);
  322.     uart_printf("\r\n");

  324.     ftemp = 0.03125 * (float) itemp; /* convert to degrees C */
  325. }
  326. void frq_out_tog() /* --- toggle en32khz bit to enable/disable sqw --- */
  327. {
  328. uchar val;

  330.         start();
  331.         i2cwrite(ADDRTC);
  332.         i2cwrite(0x0f); /* control/status reg address */
  333.         start();
  334.         i2cwrite(ADDRTC + 1); /* send the device address for read */
  335.         val = i2cread(NACK);
  336.         stop();
  337.         val ^= 0x08; /* toggle en32khz bit */
  338.         start();
  339.         i2cwrite(ADDRTC);
  340.         i2cwrite(0x0f); /* control/status reg address */
  341.         i2cwrite(val);
  342.         stop();
  343. }
  344. void init_alrm() /* --- enable alarm 1 for once-per-second --- */
  345. {
  346.         uchar ahour=13;
  347.         uchar amin=43;
  348.         uchar asec=0;

  350.         ahour=hex2bcd(ahour);
  351.         amin= hex2bcd(amin);
  352.         asec= hex2bcd(asec);

  354.         start();
  355.         i2cwrite(ADDRTC);
  356.         i2cwrite(7); /* 1st alarm 1 reg address */

  358.         i2cwrite(asec); /* mask alarm register */
  359.         i2cwrite(amin);
  360.         i2cwrite(ahour|0x80);
  361.         i2cwrite(0x80);

  363.         i2cwrite(0x80); /* mask alarm register */
  364.         i2cwrite(0x80);
  365.         i2cwrite(0x80);
  366.         i2cwrite(0x80);
  367.   
  368.         //i2cwrite(0x0e); /* control/status reg address */
  369.         i2cwrite(0x05); /* enable interrupts, alarm 1 output */
  370.         ///i2cwrite(0);
  371.         stop();
  372. }
  373. void comm_init() /* ------ reset DS3232 comm interface ------ */
  374. {
  375.     do /* because the DS3232 I2C interface is active for both supplies */
  376.     { /* after a micro reset, we must get the comm into a known state */
  377.         sda = 1; /* make sure master has released SDA */
  378.         scl = 1;
  379.         if(sda) /* if sda is high, generate a start */
  380.         {
  381.                 sda = 0; /* The DS3232 will recognize a valid start */
  382.                 sda = 1; /* condition anywhere in a I2C data transfer */
  383.         }
  384.         scl = 0;
  385.     }
  386.     while(sda == 0); /* if the DS3232 is holding sda low, try again */
  387. }
  388. void uart_init()
  389. {
  390.    TMOD|=0x20; //TMOD＝0
  391.    TH1=0xf3; //12MHZ ，BPS：4800，N，8，1,0xf3=243
  392.    TL1=0xf3;
  393.    
  394.    TR1=1;

  396.    PCON=0x80; //SMOD=1,方式一,8位数据位，一位起始位和一位结束位
  397.             //
  398.    SCON=0x50; //串口通信控制寄存器 模式一

  400.    EA=1;
  401.    ES=1; //打开串口中断
  402.    REN=1;
  403.   
  404. }

  406. void uart_putchar(unsigned char dat)
  407. {
  408.     SBUF=dat; //把数据送给sbuf缓存器中
  409.     while(TI!=1);//发送标志位 TI如果发送了为1，没发送为0，没发送等待，到了退出循环
  410.     TI=0; //到了，TI清为0

  412. }
  413. void uart_printf(unsigned char *buff)
  414. {

  416.     while(*buff)
  417.        uart_putchar(*buff++);
  418. }

  420. typedef struct
  421. {
  422.     BYTE hour;
  423.     BYTE minute;
  424.     BYTE second;
  425.     BYTE week;
  426. }mtime_t;
  427. typedef struct
  428. {
  429.     //WORD rsv[2];
  430.     WORD year;
  431.     BYTE month;
  432.     BYTE day;
  433. }mdate_t;
  434. typedef struct
  435. {
  436.     mdate_t date;
  437.     mtime_t time;
  438. }date_time_t;
  439. typedef struct
  440. {
  441.     uchar     byIntFlag;
  442.     uchar byWritePoint;
  443.     uint    dwOutCnt;
  444.     uchar    byRxBuf[16];
  445. }serial_t;
  446. serial_t g_rx; ////////////////////////////////////////////////////////
  447. void uart() interrupt 4
  448. {
  449.     if(RI == 1) // RI = 0;
  450.     {
  451.         g_rx.byIntFlag=1;
  452.         if(g_rx.byWritePoint<16)
  453.         {     
  454.             g_rx.byRxBuf[g_rx.byWritePoint]=SBUF;
  455.             g_rx.byWritePoint++;
  456.         }
  457.         RI=0;
  458.     }
  459.     ///if(TI == 1) {SBUF = txt[i++]; TI = 0;}
  460. }
  461. /*
  462. BYTE GetWeekday(int year,BYTE mon,BYTE day)
  463. {
  464. //    BYTE TAB_X[12]={6,2,2,5,0,3,5,1,4,6,2,4}, ucWeekDay;
  465. //    return ((year + year/4 - ( (mon<3)&&(year%4==0) ) + TAB_X[mon] + day )%7+4)%7;
  466.     int xdata r[13]={0,0,3,3,6,1,4,6,2,5,0,3,5};
  467.     year %= 400;
  468.     if((year==0||year%4==0&&year%100!=0)&&mon<3)
  469.         return ((year+year/4-year/100+r[mon]+day+5)%7);
  470.     else
  471.         return ((year+year/4-year/100+r[mon]+day+6)%7);
  472. }    */


  475. void delay(unsigned int k)    
  476. {    
  477.     unsigned int i,j;    
  478.     for(i=0;i<k;i++)
  479.     {    
  480.     for(j=0;j<50;j++)    
  481.     {;}
  482.     }    
  483. }
  484.  void Seg_DisPlay(uint x)
  485.  {
  486.      uint tmp;

  488.     if(!g_bNotDisSeg)
  489.     {
  490.         tmp=x/1000;
  491.         LE=1;
  492.     
  493.         PW0=0;
  494.         PW1=0;
  495.         PW2=0;
  496.         PD=(!tmp)?(0):(0xff-duan[tmp]);
  497.         delay(5);
  498.     
  499.         PW0=0;
  500.         PW1=0;
  501.         PW2=1;
  502.         PD=0xff-duan[x%1000/100];
  503.         delay(5);
  504.     
  505.         PW0=0;
  506.         PW1=1;
  507.         PW2=0;
  508.         PD=0xff-duan[x%100/10];
  509.         delay(5);
  510.     
  511.         PW0=0;
  512.         PW1=1;
  513.         PW2=1;
  514.         PD=0xff-duan[x%10];
  515.         delay(5);
  516.     }
  517.     else
  518.     {
  519.         LE=1;
  520.         PW0=0;
  521.         PW1=0;
  522.         PW2=0;
  523.         PD=0;
  524.         delay(5);
  525.     
  526.         PW0=0;
  527.         PW1=0;
  528.         PW2=1;
  529.         PD=0;
  530.         delay(5);
  531.     
  532.         PW0=0;
  533.         PW1=1;
  534.         PW2=0;
  535.         PD=0;
  536.         delay(5);
  537.     
  538.         PW0=0;
  539.         PW1=1;
  540.         PW2=1;
  541.         PD=0;
  542.         delay(5);    
  543.     }    
  544.  }
  545.  void ReadTime(void)
  546.  {
  547.       start();
  548.     i2cwrite(ADDRTC);
  549.     i2cwrite(0x0f);
  550.     i2cwrite(0); /* clear alarm flags */
  551.     stop();

  553.     start();
  554.     i2cwrite(ADDRTC);
  555.     i2cwrite(0);
  556.     start();
  557.     i2cwrite(ADDRTC | 1);
  558.     sec = i2cread(ACK);
  559.     min = i2cread(ACK);
  560.     hr = i2cread(ACK);
  561.     dy = i2cread(ACK);
  562.     dt = i2cread(ACK);
  563.     mn = i2cread(ACK);
  564.     yr = i2cread(NACK);

  566.     sec=bcd2hex(sec);
  567.     min=bcd2hex(min);
  568.     hr=bcd2hex(hr);
  569.     dy=bcd2hex(dy);
  570.     dt=bcd2hex(dt);
  571.     mn=bcd2hex(mn);
  572.     yr=bcd2hex(yr);
  573.     
  574.     stop();
  575.  }
  576.  void Set_SegDis(uchar mode,uint setdata)
  577.  {
  578.      
  579.     LE=1;

  581.     PW0=0;
  582.     PW1=0;
  583.     PW2=0;
  584.     PD=0xff-duan[mode];
  585.     delay(5);

  587.     PW0=0;
  588.     PW1=0;
  589.     PW2=1;
  590.     PD=0; //高电平显示，低电平不亮，共阴数码管
  591.     delay(5);

  593.     PW0=0;
  594.     PW1=1;
  595.     PW2=0;
  596.     PD=0xff-duan[setdata%100/10];
  597.     delay(5);

  599.     PW0=0;
  600.     PW1=1;
  601.     PW2=1;
  602.     PD=0xff-duan[setdata%10];
  603.     delay(5);    
  604.  }

  606. void Led_Test()
  607. {
  608.      char i,j;
  609.     
  610.      for(j=0;j<4;j++)
  611.      {
  612.      PW=wei[j] |(1<<5) ;
  613.          for(i=0;i<10;i++)
  614.          {
  615.              PD= 0xff-duan[i];
  616.             delay(200);
  617.          }
  618.      }
  619. }
  620. void MusicBase(uchar z)
  621. {
  622.     yy_rst=1;
  623.     delay(4);
  624.     yy_rst=0;
  625.     delay(4);
  626.     while(z>0)
  627.     {
  628.         yy_dat=1;
  629.         delay(4);
  630.         yy_dat=0;
  631.         delay(4);
  632.         z--;
  633.     }
  634.     while(!yy_busy);
  635.     //delay(100);
  636.     yy_rst=1;
  637.     delay(4);
  638.     yy_rst=0;
  639.     delay(4);
  640. }
  641. void MusicNumber(uchar z)
  642. {
  643.     if(z>10)
  644.     {
  645.         MusicBase(z/10+1);
  646.         MusicBase(z%10+1);
  647.     }
  648.     else
  649.     {
  650.          MusicBase(z+1);
  651.     }
  652. }
  653. void MusicHave10Number(uchar z)
  654. {


  657.     if(z<=10)
  658.     {
  659.         
  660.         MusicBase(z+1);
  661.     }
  662.     else if(z<=19)//19-11
  663.     {
  664.         MusicBase(11);//10
  665.         MusicBase(z%10+1);    
  666.     }
  667.     else if( z<100 )//20-99
  668.     {
  669.         MusicBase(z/10+1);
  670.         MusicBase(11);//10
  671.         if( z%10 !=0 )
  672.             MusicBase(z%10+1);
  673.     }


  676. }
  677. void MusicRingHead(void)
  678. {
  679.     MusicBase(25);
  680.     MusicBase(22);
  681. }
  682. void MusicDate(uchar year,uchar mon,uchar day)
  683. {    
  684.     MusicBase(3);
  685.     MusicBase(1);
  686.     MusicBase(year/10+1);
  687.     MusicBase(year%10+1);
  688.     MusicBase(16);

  690.     MusicHave10Number(mon);
  691.     MusicBase(17);
  692.     MusicHave10Number(day);
  693.     MusicBase(18);
  694. }
  695. void MusicTime(uchar hour,uchar min)
  696. {
  697.     
  698.     MusicHave10Number(hour);
  699.     MusicBase(13);
  700.     MusicHave10Number(min);
  701.     MusicBase(14);
  702. }
  703. void MusicRingInit(void)
  704. {

  706.     yy_rst=0;
  707.     
  708. }
  709. void MusicSayTime(uchar hour)
  710. {
  711.     MusicHave10Number(hour);
  712.     MusicBase(13);
  713. }

  715.  void MusicTemprature(float t)
  716.  {
  717.      uchar point_1;
  718.     if(t==85.0)
  719.         return;
  720.      MusicBase(23);// 现在温度是

  722.      if(t==0.0)
  723.     {
  724.         //MusicBase(1);//0 度
  725.         //MusicBase(20);
  726.         return;    
  727.     }
  728.     if(t<0)
  729.     {
  730.         t=-t;
  731.         MusicBase(31);    //负
  732.     }
  733.     if(t<10)
  734.     {
  735.         point_1=((uint)(t*10))%10;

  737.         MusicBase( (uint)(t)/10);
  738.         if(point_1!=0)
  739.         {
  740.         MusicBase(13);//"."
  741.         MusicBase( ((uint)(t*10))%10 +1 );
  742.         }
  743.         MusicBase(20);
  744.         return;
  745.     }
  746.     if(t<100)
  747.     {
  748.         MusicHave10Number( (uint)(t) );
  749.         
  750.         point_1= ((uint)(t*10))%10;
  751.         if(point_1!=0)
  752.         {
  753.             MusicBase(13);//"."
  754.             MusicBase( ((uint)(t*10))%10 +1 );
  755.         }
  756.         MusicBase(20);    
  757.         return;
  758.     }
  759.  }
  760.  
  761. void MusciWeek(uchar week)
  762. {
  763.     MusicBase(19);
  764.     MusicBase(week+1);
  765. }
  766. void LedShine(uint sec)
  767. {
  768.     LED1=CHECK_BIT(sec,0);
  769.     LED2=CHECK_BIT(sec,1);
  770.     LED3=CHECK_BIT(sec,2);
  771.     LED4=CHECK_BIT(sec,3);
  772.     LED5=CHECK_BIT(sec,4);
  773. }
  774. uchar KeyScan_SetDS3232(uchar settmp)
  775. {
  776.          if( (key2==0) &&(key1))
  777.         {
  778.             delay(300);
  779.             if(key2==0)
  780.             {
  781.             settmp++;
  782.             if(settmp>99)
  783.                 settmp=0;
  784.             }
  785.         }
  786.     
  787.         if( (key3==0) && (key1) )
  788.         {
  789.             delay(300);
  790.             if(key3==0)
  791.             {
  792.             settmp--;
  793.             if(settmp<=0)
  794.                 settmp=99;
  795.             }
  796.         }
  797.         return settmp;
  798. }
  799. void HardTestCmd(uchar uch_Cmd)
  800. {    
  801.     switch(uch_Cmd)
  802.     {
  803.         case CMD_RING_TMP:
  804.         
  805.         ;
  806.         case CMD_RING_TIME:
  807.          //    MusicRingHead();
  808.             MusicTime(hr,min);
  809.         ;break;
  810.         case CMD_RING_DATE:
  811.         //    MusicRingHead();
  812.             MusicDate(yr,mn,dt);
  813.         ;break;
  814.     }
  815. }
  816. void ComParse(void)
  817. {
  818.     date_time_t *pdt;
  819.     int ilp;
  820.     if(g_rx.byIntFlag==1)
  821.     {
  822.         g_rx.dwOutCnt++;
  823.         if(    g_rx.dwOutCnt>10)
  824.         {
  825.              g_rx.dwOutCnt=0;
  826.              if(g_rx.byWritePoint==8)
  827.              {
  828.                   pdt=(date_time_t *)g_rx.byRxBuf;

  830.                 if(pdt->time.week>7)
  831.                 {
  832.                     HardTestCmd(pdt->time.week);
  833.                     pdt->time.week = 7;
  834.                 }
  835.                 else
  836.                 {
  837.                     for(ilp=0;ilp<8;ilp++)
  838.                     {
  839.                         //delay(100);lz20150801
  840.                         uart_putchar(g_rx.byRxBuf[ilp]);
  841.                     }
  842.                     pdt->date.year=g_rx.byRxBuf[0]+g_rx.byRxBuf[1]*256-2000;
  843.                     yr=    pdt->date.year;
  844.                     mn= pdt->date.month;
  845.                     dt= pdt->date.day;
  846.     
  847.                     dy= pdt->time.week;
  848.                     hr= pdt->time.hour;
  849.                     min=pdt->time.minute;
  850.                     sec=pdt->time.second;
  851.     
  852.                     ReInitialDS3232();
  853.                     g_rx.byIntFlag=0;
  854.                     g_rx.byWritePoint=0;
  855.                      g_rx.dwOutCnt=0;
  856.                 }
  857.             
  858.              }
  859.              else
  860.              {
  861.                  g_rx.byIntFlag=0;
  862.                 g_rx.byWritePoint=0;
  863.                  g_rx.dwOutCnt=0;
  864.              }
  865.         }
  866.     }
  867. }
  868. void SetDS3232(void)
  869. {
  870.     uchar settmp;
  871.     uchar mode=1;
  872.     uint tick;
  873.     while( !key1 ) //key1 pressed
  874.     {
  875.          Seg_DisPlay(tick);
  876.         if(tick++>200)
  877.         {
  878.             while(key1)//等待key1松掉
  879.             {
  880.                 Seg_DisPlay(tick);    
  881.             }
  882.             
  883.             delay(2000);
  884.             ReadTime();
  885.             while(1)//main loop
  886.             {
  887.                 if(key1==0)
  888.                 {
  889.                     delay(300);
  890.                     if(key1==0)
  891.                     {
  892.                             mode++;
  893.                             if(mode>7)
  894.                             mode=1;    
  895.                     }
  896.                 }
  897.             
  898.                 switch(mode)
  899.                 {
  900.                     case 1:settmp=yr;break;
  901.                     case 2:settmp=mn;break;
  902.                     case 3:settmp=dt;break;
  903.                     case 4:settmp=hr;break;
  904.                     case 5:settmp=min;break;
  905.                     case 6:settmp=sec;break;
  906.                     case 7:settmp=dy;break;//星期
  907.                 }
  908.                 settmp=KeyScan_SetDS3232(settmp);
  909.                 switch(mode) //write
  910.                 {
  911.                     case 1:yr=settmp;break;
  912.                     case 2:mn=settmp;break;
  913.                     case 3:dt=settmp;break;
  914.                     case 4:hr=settmp;break;
  915.                     case 5:min=settmp;break;
  916.                     case 6:sec=settmp;break;
  917.                     case 7:dy=settmp;break;//星期    
  918.                 }
  919.                 if( (key1==0) && (key2==0) )
  920.                 {
  921.                 
  922.                     delay(600);
  923.                     if( (key1==0) && (key2==0) )
  924.                     {
  925.                          ReInitialDS3232();
  926.                          tick=600;
  927.                          while(tick-->0)
  928.                          {
  929.                               Seg_DisPlay(tick);
  930.                          }
  931.                         
  932.                          goto out;
  933.                     }
  934.                 }
  935.                 Set_SegDis(mode,settmp);

  937.             }//end of main loop
  938.         }
  939.     }
  940.     out:;
  941. }
  942. ////xdata uchar sec, min, hr, dy, dt, mn, yr;
  943. void main (void) /* ------------------------------------------------ */
  944. {
  945.     uint tick=0;
  946.     uint ul_systick=0;
  947.     float ftmp;
  948.     uint xdata dwtmp,dwTickPressedKey=0;
  949.     uchar secset=0;

  951.     uchar bflag=0;
  952.     unsigned char xdata yl_month,yl_day;
  953.     unsigned short xdata yl_year;

  955.     comm_init();
  956.     uart_init();
  957.     MusicRingInit();
  958.     //initialize_DS3232();
  959.     //init_alrm(); /* enable alarm */
  960.       SetDS3232();

  962.     while(1)
  963.     {

  965.      ComParse();
  966.         //P1=0xFf-sec;
  967.          // rd_temp();
  968.          ul_systick++;
  969.         
  970.          disp_regs();
  971.          if( (hr>=7) && (hr<=21) )
  972.          {
  973.              g_bNotDisSeg=0;//早上7点到晚上8点之间，数码管可以由关闭状态自动恢复
  974.          }
  975.          if( (hr>=8) && (hr<=21)) //早上8点到晚上24点led闪烁，其他时间不闪烁，影响睡眠
  976.          {
  977.                  if(!g_bNotDisSeg)
  978.                      LedShine(g_uchLedTab[ ul_systick/30%TAB_NUM ] );
  979.                 else
  980.                     LedShine(0);
  981.          }
  982.          else
  983.          {
  984.               LedShine(0);
  985.          }
  986.               if( (!key2)&&(!key3)==1)
  987.              {
  988.                      MusicRingHead();
  989.                     MusicTime(hr,min);
  990.                 
  991.                      Seg_DisPlay( (mn*100+dt) );
  992.              }
  993.              if( (!key1)&&(!key3) )
  994.              {
  995.                       MusicRingHead();
  996.                     MusicDate(yr,mn,dt);
  997.                     MusicTime(hr,min);
  998.                      Seg_DisPlay( (mn*100+dt) );
  999.              }
  1000.              if(key1==0)
  1001.              {
  1002.                  if(key2==0)
  1003.                      tick++;
  1004.                     bflag=0;

  1006.                  Seg_DisPlay( (mn*100+dt) );
  1007.                  g_bNotDisSeg=0;//恢复数码管显示
  1008.             
  1009.              }
  1010.              else if(key2==0)
  1011.              {
  1012.                      GetLunar(2000+yr,mn,dt,&yl_year,&yl_month,&yl_day);
  1013.                      Seg_DisPlay( (yl_month*100) + yl_day );
  1014.                     //Seg_DisPlay(yr );
  1015.                     if( (key1!=0) && (key3!=0) )
  1016.                         dwTickPressedKey++;
  1017.                     else
  1018.                         dwTickPressedKey=0;
  1019.                         
  1020.                     if(dwTickPressedKey>=350)//长按5s
  1021.                     {
  1022.                         dwTickPressedKey=0;
  1023.                         g_bNotDisSeg=1;    //关闭数码管显示
  1024.                     }
  1025.              }
  1026.              else if(key3==0)//显示温度和星期2314-->23.1摄氏度，星期4
  1027.              {
  1028.                      g_bNotDisSeg=0;//恢复数码管显示
  1029.                      ftmp=ReadTemperature();
  1030.                     if (ftmp == 85.0)
  1031.                             ftmp=ReadTemperature();
  1032.                     if( (ftmp>=0) && (ftmp<100) )
  1033.                     {
  1034.                      dwtmp=ftmp*10;
  1035.                      Seg_DisPlay( (dwtmp*10+dy) );
  1036.                     
  1037.                     }
  1038.                     else
  1039.                     {
  1040.                         Seg_DisPlay( (dy) );
  1041.                     }                    
  1042.                     MusicTemprature(ftmp);
  1043.                     MusciWeek(dy);
  1044.              }
  1045.              else
  1046.              {
  1047.                      Seg_DisPlay( (hr*100+min) );
  1048.              }
  1049.     
  1050.              if ( (min==30) && (hr==7) &&(sec<2) )
  1051.              {
  1052.                       MusicTime(hr,min);;
  1053.              }
  1054.              if(min==0)
  1055.              {
  1056.                       if(hr>=8 && hr<=23 && sec<1)
  1057.                     {    
  1058.                          MusicSayTime(hr);
  1059.                     }
  1060.                      if(hr!=12 && sec<3)
  1061.                      {
  1062.                         RING=0;
  1063.                         JDQ=0;
  1064.                     }
  1065.                     else if(hr==12 && sec<5)
  1066.                     {
  1067.                         RING=0;
  1068.                         JDQ=0;
  1069.                     }
  1070.              }
  1071.             
  1072.                 else
  1073.                 {
  1074.                   RING=1;
  1075.                     JDQ=1;
  1076.                  }
  1077.          
  1078.               if(tick>300)
  1079.              {
  1080.                      tick=0;
  1081.                     secset=sec;
  1082.                      while(1)
  1083.                     {
  1084.                         Seg_DisPlay(secset);
  1085.                         
  1086.                         if(key2==0 && key1!=0)
  1087.                         {
  1088.                             
  1089.                             if(secset<59)
  1090.                             {secset++;;}
  1091.                             bflag=1    ;
  1092.                             tick=0;
  1093.                             delay(100);
  1094.                         }    
  1095.                         else if(key3==0)
  1096.                         {
  1097.                             if(secset>0)
  1098.                             {
  1099.                                 secset--;
  1100.                             
  1101.                             }
  1102.                                 bflag=1;
  1103.                                 tick=0;
  1104.                                 delay(100);
  1105.                         }
  1106.                         if( (key1==0) && (bflag==1) )
  1107.                         {
  1108.                             tick++;
  1109.                         }
  1110.                         if(tick>2)
  1111.                         {
  1112.                             tick=0;
  1113.                             bflag=0;
  1114.                             min=hex2bcd(min);
  1115.                             secset=hex2bcd(secset);
  1116.                             start();
  1117.                             i2cwrite(ADDRTC); /* write slave address, write 1339 */
  1118.                          i2cwrite(0x00); /* write register address, 1st clock register */
  1119.                          i2cwrite(secset);
  1120.                             i2cwrite(min);
  1121.                          stop();    
  1122.                             delay(10);
  1123.                             break;
  1124.                         }
  1125.                     }
  1126.              }
  1127.         
  1128.         
  1129.          //delay(3000);
  1130.         
  1131.     }

  1133. }
calender.c

点击(此处)折叠或打开

  1. /*
  2. 文件名：    calender.c
  3. 作者：        
  4. 创建日期：    2014.5.27
  5. 功能：        将公历转换成农历
  6. */
  7. #include "config.h"


  10. UINT8 code year_code[597]={
  11. 0x04,0xAe,0x53,0x0A,0x57,0x48,0x55,0x26,0xBd, // 1901-1903
  12. 0x0d,0x26,0x50,0x0d,0x95,0x44,0x46,0xAA,0xB9, // 1904-1906
  13. 0x05,0x6A,0x4d,0x09,0xAd,0x42,0x24,0xAe,0xB6, // 1907-1909
  14. 0x04,0xAe,0x4A,0x6A,0x4d,0xBe,0x0A,0x4d,0x52, // 1910-1912
  15. 0x0d,0x25,0x46,0x5d,0x52,0xBA,0x0B,0x54,0x4e, // 1913-1915
  16. 0x0d,0x6A,0x43,0x29,0x6d,0x37,0x09,0x5B,0x4B, // 1916-1918
  17. 0x74,0x9B,0xC1,0x04,0x97,0x54,0x0A,0x4B,0x48, // 1919-1921
  18. 0x5B,0x25,0xBC,0x06,0xA5,0x50,0x06,0xd4,0x45, // 1922-1924
  19. 0x4A,0xdA,0xB8,0x02,0xB6,0x4d,0x09,0x57,0x42, // 1925-1927
  20. 0x24,0x97,0xB7,0x04,0x97,0x4A,0x66,0x4B,0x3e, // 1928-1930
  21. 0x0d,0x4A,0x51,0x0e,0xA5,0x46,0x56,0xd4,0xBA, // 1931-1933
  22. 0x05,0xAd,0x4e,0x02,0xB6,0x44,0x39,0x37,0x38, // 1934-1936
  23. 0x09,0x2e,0x4B,0x7C,0x96,0xBf,0x0C,0x95,0x53, // 1937-1939
  24. 0x0d,0x4A,0x48,0x6d,0xA5,0x3B,0x0B,0x55,0x4f, // 1940-1942
  25. 0x05,0x6A,0x45,0x4A,0xAd,0xB9,0x02,0x5d,0x4d, // 1943-1945
  26. 0x09,0x2d,0x42,0x2C,0x95,0xB6,0x0A,0x95,0x4A, // 1946-1948
  27. 0x7B,0x4A,0xBd,0x06,0xCA,0x51,0x0B,0x55,0x46, // 1949-1951
  28. 0x55,0x5A,0xBB,0x04,0xdA,0x4e,0x0A,0x5B,0x43, // 1952-1954
  29. 0x35,0x2B,0xB8,0x05,0x2B,0x4C,0x8A,0x95,0x3f, // 1955-1957
  30. 0x0e,0x95,0x52,0x06,0xAA,0x48,0x7A,0xd5,0x3C, // 1958-1960
  31. 0x0A,0xB5,0x4f,0x04,0xB6,0x45,0x4A,0x57,0x39, // 1961-1963
  32. 0x0A,0x57,0x4d,0x05,0x26,0x42,0x3e,0x93,0x35, // 1964-1966
  33. 0x0d,0x95,0x49,0x75,0xAA,0xBe,0x05,0x6A,0x51, // 1967-1969
  34. 0x09,0x6d,0x46,0x54,0xAe,0xBB,0x04,0xAd,0x4f, // 1970-1972
  35. 0x0A,0x4d,0x43,0x4d,0x26,0xB7,0x0d,0x25,0x4B, // 1973-1975
  36. 0x8d,0x52,0xBf,0x0B,0x54,0x52,0x0B,0x6A,0x47, // 1976-1978
  37. 0x69,0x6d,0x3C,0x09,0x5B,0x50,0x04,0x9B,0x45, // 1979-1981
  38. 0x4A,0x4B,0xB9,0x0A,0x4B,0x4d,0xAB,0x25,0xC2, // 1982-1984
  39. 0x06,0xA5,0x54,0x06,0xd4,0x49,0x6A,0xdA,0x3d, // 1985-1987
  40. 0x0A,0xB6,0x51,0x09,0x37,0x46,0x54,0x97,0xBB, // 1988-1990
  41. 0x04,0x97,0x4f,0x06,0x4B,0x44,0x36,0xA5,0x37, // 1991-1993
  42. 0x0e,0xA5,0x4A,0x86,0xB2,0xBf,0x05,0xAC,0x53, // 1994-1996
  43. 0x0A,0xB6,0x47,0x59,0x36,0xBC,0x09,0x2e,0x50, // 1997-1999
  44. 0x0C,0x96,0x45,0x4d,0x4A,0xB8,0x0d,0x4A,0x4C, // 2000-2002
  45. 0x0d,0xA5,0x41,0x25,0xAA,0xB6,0x05,0x6A,0x49, // 2003-2005
  46. 0x7A,0xAd,0xBd,0x02,0x5d,0x52,0x09,0x2d,0x47, // 2006-2008
  47. 0x5C,0x95,0xBA,0x0A,0x95,0x4e,0x0B,0x4A,0x43, // 2009-2011
  48. 0x4B,0x55,0x37,0x0A,0xd5,0x4A,0x95,0x5A,0xBf, // 2012-2014
  49. 0x04,0xBA,0x53,0x0A,0x5B,0x48,0x65,0x2B,0xBC, // 2015-2017
  50. 0x05,0x2B,0x50,0x0A,0x93,0x45,0x47,0x4A,0xB9, // 2018-2020
  51. 0x06,0xAA,0x4C,0x0A,0xd5,0x41,0x24,0xdA,0xB6, // 2021-2023
  52. 0x04,0xB6,0x4A,0x69,0x57,0x3d,0x0A,0x4e,0x51, // 2024-2026
  53. 0x0d,0x26,0x46,0x5e,0x93,0x3A,0x0d,0x53,0x4d, // 2027-2029
  54. 0x05,0xAA,0x43,0x36,0xB5,0x37,0x09,0x6d,0x4B, // 2030-2032
  55. 0xB4,0xAe,0xBf,0x04,0xAd,0x53,0x0A,0x4d,0x48, // 2033-2035
  56. 0x6d,0x25,0xBC,0x0d,0x25,0x4f,0x0d,0x52,0x44, // 2036-2038
  57. 0x5d,0xAA,0x38,0x0B,0x5A,0x4C,0x05,0x6d,0x41, // 2039-2041
  58. 0x24,0xAd,0xB6,0x04,0x9B,0x4A,0x7A,0x4B,0xBe, // 2042-2044
  59. 0x0A,0x4B,0x51,0x0A,0xA5,0x46,0x5B,0x52,0xBA, // 2045-2047
  60. 0x06,0xd2,0x4e,0x0A,0xdA,0x42,0x35,0x5B,0x37, // 2048-2050
  61. 0x09,0x37,0x4B,0x84,0x97,0xC1,0x04,0x97,0x53, // 2051-2053
  62. 0x06,0x4B,0x48,0x66,0xA5,0x3C,0x0e,0xA5,0x4f, // 2054-2056
  63. 0x06,0xB2,0x44,0x4A,0xB6,0x38,0x0A,0xAe,0x4C, // 2057-2059
  64. 0x09,0x2e,0x42,0x3C,0x97,0x35,0x0C,0x96,0x49, // 2060-2062
  65. 0x7d,0x4A,0xBd,0x0d,0x4A,0x51,0x0d,0xA5,0x45, // 2063-2065
  66. 0x55,0xAA,0xBA,0x05,0x6A,0x4e,0x0A,0x6d,0x43, // 2066-2068
  67. 0x45,0x2e,0xB7,0x05,0x2d,0x4B,0x8A,0x95,0xBf, // 2069-2071
  68. 0x0A,0x95,0x53,0x0B,0x4A,0x47,0x6B,0x55,0x3B, // 2072-2074
  69. 0x0A,0xd5,0x4f,0x05,0x5A,0x45,0x4A,0x5d,0x38, // 2075-2077
  70. 0x0A,0x5B,0x4C,0x05,0x2B,0x42,0x3A,0x93,0xB6, // 2078-2080
  71. 0x06,0x93,0x49,0x77,0x29,0xBd,0x06,0xAA,0x51, // 2081-2083
  72. 0x0A,0xd5,0x46,0x54,0xdA,0xBA,0x04,0xB6,0x4e, // 2084-2086
  73. 0x0A,0x57,0x43,0x45,0x27,0x38,0x0d,0x26,0x4A, // 2087-2089
  74. 0x8e,0x93,0x3e,0x0d,0x52,0x52,0x0d,0xAA,0x47, // 2090-2092
  75. 0x66,0xB5,0x3B,0x05,0x6d,0x4f,0x04,0xAe,0x45, // 2093-2095
  76. 0x4A,0x4e,0xB9,0x0A,0x4d,0x4C,0x0d,0x15,0x41, // 2096-2098
  77. 0x2d,0x92,0xB5, // 2099
  78. };
  79. //月份天数数据表
  80. static code UINT8 day_code1[9]={0x0,0x1f,0x3b,0x5a,0x78,0x97,0xb5,0xd4,0xf3};
  81. static code UINT16 day_code2[3]={0x111,0x130,0x14e};



  85. static bit Get_Moon_Day(UINT8 month_p,UINT16 code_addr) //读取数据表中农历月的大月或小月,如果该月大返回1,小返回0*/
  86. {
  87.     UINT8 temp,temp1;
  88.     temp1=(month_p+3)/8;
  89.     temp=0x80>>((month_p+3)%8);
  90.     temp=year_code[code_addr+temp1]&temp;
  91.     if(temp==0){return(0);}else{return(1);}
  92. }
  93. unsigned int rotate_right(unsigned int x, int n)
  94. {
  95.  int save;
  96.  int i;
  97.  for(i=0;i<n;i++)
  98.  {
  99.  save=x&0x00000001;
  100.  x=x>>1;
  101.  save=save<<7;
  102.  x+=save;
  103.  }
  104.  return x;
  105. }
  106. void GetLunar(UINT16 year_src,UINT8 month,UINT8 day,UINT16 *Year,UINT8 *Month,UINT8 *Day)//,UINT8 *MonthDay)
  107. {
  108.    
  109.     UINT8 xdata temp1,temp2,temp3,month_p,year;
  110.     UINT16 xdata temp4,code_addr,year_tmp;
  111.     bit flag2,flag_y;
  112.     UINT8 xdata year_h,year_l;

  114.     year_tmp=year_src;
  115.     year_h=year_src/100; year_l=year_src%100; //求出高位和低位
  116.     year=year_l;
  117.     code_addr=year-1; //定位数据表地址
  118.     if(year_h>19)code_addr+=0x64;
  119.     code_addr*=3;


  122.     temp1=year_code[code_addr+2]&0x60; //取当年春节所在的公历月份
  123.     temp1=rotate_right(temp1,5);
  124.    
  125.     temp2=year_code[code_addr+2]&0x1f; //取当年春节所在的公历日
  126.    
  127.     temp3=temp2-1; //计算当年春节离当年元旦的天数,春节只会在公历1月或2月
  128.     if(temp1!=1)temp3+=0x1f;

  130.     if(month<10)
  131.         {
  132.                 temp4=day_code1[month-1]+day-1;
  133.         }
  134.     else
  135.         {
  136.                 temp4=day_code2[month-10]+day-1;
  137.         }

  139.     if((month>2)&&(year%0x04==0))temp4+=1; //如果公历月小于2月或者该年的2月非闰月,天数减1
  140.      
  141.     if (temp4>=temp3) //判断公历日在春节前还是春节后
  142.     {
  143.         //公历日在春节后或就是春节当日使用下面代码进行运算
  144.         temp4 -=temp3;
  145.         month = 1;
  146.         flag_y = 0;
  147.         month_p= 1; //month_p为月份指向,公历日在春节前或就是春节当日month_p指向首月

  149.         flag2=Get_Moon_Day(month_p,code_addr); //检查该农历月为大小还是小月,大月返回1,小月返回0
  150.                
  151.         if(flag2==0){temp1=29;}else{temp1=30;} //小月29天、大月30天
  152.                
  153.            
  154.         temp2=year_code[code_addr]&0xf0;
  155.         temp2=rotate_right(temp2,4); //从数据表中取该年的闰月月份,如为0则该年无闰月
  156.         while(temp4>=temp1)
  157.        {
  158.             temp4-=temp1;
  159.             month_p+=1;
  160.             if(month==temp2)
  161.             {
  162.                 flag_y=~flag_y;
  163.                 if(flag_y==0)month+=1;
  164.             }
  165.             else month+=1;
  166.             flag2=Get_Moon_Day(month_p,code_addr);
  167.             if(flag2==0)temp1=0x1d;
  168.             else temp1=0x1e;
  169.                        
  170.         }
  171.         day=temp4+1;

  173.     }
  174.     else
  175.     {
  176.         //公历日在春节前使用下面代码进行运算
  177.         temp3-=temp4;
  178.         if(year==0){year=99;year_h=19;}else{year-=1;}
  179.         code_addr-=3;
  180.         month = 0x0c;
  181.         temp2 = year_code[code_addr]&0xf0;
  182.         temp2 = rotate_right(temp2,4);
  183.         flag_y = 0;
  184.         if(temp2==0){month_p=12;}else{month_p=13;} //如果当年有闰月,一年有十三个月,月指向13,无闰月指向12
  185.         
  186.         flag2=Get_Moon_Day(month_p,code_addr);
  187.         if(flag2==0){temp1=29;}else{temp1=30;}


  190.         while(temp3>temp1)
  191.        {
  192.             temp3-=temp1;
  193.             month_p-=1;
  194.             if(flag_y==0)month-=1;
  195.             if(month==temp2)flag_y=~flag_y;
  196.             flag2=Get_Moon_Day(month_p,code_addr);
  197.             if(flag2==0){temp1=0x1d;}else{temp1=0x1e;}
  198.         }
  199.         day=temp1-temp3+1;
  200.     }
  201.    //*MonthDay=temp1;//农历的天数
  202.    *Year =((UINT16)year_h*100)+(UINT16)year; //将农历信息写进指定变量
  203.    *Month = month;
  204.    *Day = day;
  205. }
  206. int calender_test(int argc, char* argv[])
  207. {
  208.     UINT16 year;
  209.     UINT8 mon,day,monday;
  210.     UINT16 y;
  211.     UINT8 m,d;

  213.     while(1)
  214.     {
  215.         //printf("please input date\r\n");
  216.         //scanf("%d%d%d",&y,&m,&d);
  217.         //printf("intput date is %d-%d-%d\r\n",y,m,d);

  219.         GetLunar(y,m,d,&year,&mon,&day);//,&monday);

  221.         //printf("output date is %d-%d-%d,%d\r\n",year,mon,day,monday);

  223.     }
  224.     
  225.     return 0;
  226. }

上位机部分：
timeDlg.cpp

点击(此处)折叠或打开

  1. // timeDlg.cpp : implementation file
  2. //

  4. #include "stdafx.h"
  5. #include "ComConfig.h"
  6. #include "timeDlg.h"
  7. #include "Proctol.h"
  8. #include "ComConfigDlg.h"

  10. #ifdef _DEBUG
  11. #define new DEBUG_NEW
  12. #undef THIS_FILE
  13. static char THIS_FILE[] = __FILE__;
  14. #endif

  16. /////////////////////////////////////////////////////////////////////////////
  17. // timeDlg dialog


  20. timeDlg::timeDlg(CWnd* pParent /*=NULL*/)
  21.     : CDialog(timeDlg::IDD, pParent)
  22. {
  23.     //{{AFX_DATA_INIT(timeDlg)
  24.     m_edit_year = 2015;
  25.     m_edit_month = 2;
  26.     m_edit_day = 11;
  27.     m_edit_hour = 16;
  28.     m_edit_minute = 55;
  29.     m_edit_second = 33;
  30.     
  31.     //}}AFX_DATA_INIT
  32. }


  35. void timeDlg::DoDataExchange(CDataExchange* pDX)
  36. {
  37.     CDialog::DoDataExchange(pDX);
  38.     //{{AFX_DATA_MAP(timeDlg)
  39.     DDX_Text(pDX, IDC_EDIT_YEAR, m_edit_year);
  40.     DDX_Text(pDX, IDC_EDIT_MONTH, m_edit_month);
  41.     DDX_Text(pDX, IDC_EDIT_DAY, m_edit_day);
  42.     DDX_Text(pDX, IDC_EDIT_HOUR, m_edit_hour);
  43.     DDX_Text(pDX, IDC_EDIT_MINUTE, m_edit_minute);
  44.     DDX_Text(pDX, IDC_EDIT_SECOND, m_edit_second);
  45.     //}}AFX_DATA_MAP
  46. }


  49. BEGIN_MESSAGE_MAP(timeDlg, CDialog)
  50.     //{{AFX_MSG_MAP(timeDlg)
  51.     ON_BN_CLICKED(IDC_BUTTON_USE, OnButtonUse)
  52.     ON_BN_CLICKED(IDC_BUTTON_WRITE, OnButtonWrite)
  53.     ON_BN_CLICKED(IDC_BUTTON_DIRECTWRITE, OnButtonDirectwrite)
  54.     ON_BN_CLICKED(IDC_BUTTON_RING_TM, OnButtonRingTm)
  55.     ON_BN_CLICKED(IDC_BUTTON_RING_DT, OnButtonRingDt)
  56.     //}}AFX_MSG_MAP
  57. END_MESSAGE_MAP()

  59. /////////////////////////////////////////////////////////////////////////////
  60. // timeDlg message handlers

  62. void timeDlg::OnButtonUse()
  63. {
  64.     // TODO: Add your control notification handler code here
  65.     CTime mytime=CTime::GetCurrentTime();

  67.     date_time_t date;
  68.     
  69.     date.date.year=mytime.GetYear();
  70.     date.date.month    =mytime.GetMonth();
  71.     date.date.day    =mytime.GetDay();

  73.     date.time.hour    =mytime.GetHour();
  74.     date.time.minute=mytime.GetMinute();
  75.     date.time.second=mytime.GetSecond();

  77.     char temp[5]={0x67,0x01,0x00,0x22,0x00};
  78.     

  80.     printf("%d %d\r\n",sizeof(temp),strlen(temp));
  81.     
  82.     m_port.WriteToPort(temp,5);

  84. }



  88. bool timeDlg::OpenLastPort()
  89. {
  90.     CString strCom[5];
  91.     //InitSlider(1,80,10);
  92.     int exitingSerialNumber=m_port.EnumAllComPort(strCom);
  93.     char szBuf[100];
  94.     
  95.     if ( exitingSerialNumber>0 )
  96.     {
  97.     
  98.             DWORD dwComPort;    
  99.             char szTmp[10];
  100.             strcpy(szTmp,strCom[exitingSerialNumber-1]);
  101.             dwComPort=(DWORD)atoi(szTmp+3);
  102.             for(int i=0;i<exitingSerialNumber;i++)    
  103.                 printf("%s\r\n",strCom[i]);
  104.             if(    m_port.InitPort(this,dwComPort, 4800) )
  105.             {
  106.                     printf("use %s\r\n",strCom[exitingSerialNumber-1]);
  107.                     sprintf(szBuf,"use %s\r\n",strCom[exitingSerialNumber-1]);
  108.                     WriteinfoDisplay(szBuf,TP_NEW);

  110.                     m_port.StartMonitoring();
  111.                     m_port.m_bSerialPortIsOpen=TRUE;
  112.             }
  113.             else
  114.             {
  115.                 printf("open %s baud 4800 error\r\n",strCom[exitingSerialNumber-1]);
  116.                 sprintf("open %s baud 4800 error\r\n",strCom[exitingSerialNumber-1]);
  117.                 WriteinfoDisplay(szBuf,TP_NEW);

  119.             }
  120.     }
  121.     else
  122.     {
  123.         printf("没有有效可以打开的串口\r\n");
  124.         WriteinfoDisplay("没有有效可以打开的串口\r\n",TP_NEW);
  125.     }
  126.     return TRUE;
  127. }

  129. BOOL timeDlg::OnInitDialog()
  130. {
  131.     CDialog::OnInitDialog();
  132.     
  133.     // TODO: Add extra initialization here
  134.     OpenLastPort();
  135.     return TRUE; // return TRUE unless you set the focus to a control
  136.      // EXCEPTION: OCX Property Pages should return FALSE
  137. }
  138. //根据年月日计算星期
  139. BYTE GetWeekday(DWORD year,BYTE mon,BYTE day)
  140. {
  141.     DWORD r[13]={0,0,3,3,6,1,4,6,2,5,0,3,5};
  142.     year %= 400;
  143.     if((year==0||year%4==0&&year%100!=0)&&mon<3)
  144.         return BYTE((year+year/4-year/100+r[mon]+day+5)%7);
  145.     else
  146.         return BYTE((year+year/4-year/100+r[mon]+day+6)%7);
  147. }
  148. //与电脑系统时间对时，系统对时
  149. void timeDlg::OnButtonWrite()
  150. {
  151.     // TODO: Add your control notification handler code here
  152.     date_time_t mdate;
  153.     CTime mytime=CTime::GetCurrentTime();
  154.     WORD wLen;
  155.     char szBuf[100];
  156.     mdate.date.year=mytime.GetYear();
  157.     mdate.date.month    =mytime.GetMonth();
  158.     mdate.date.day    =mytime.GetDay();

  160.     mdate.time.hour    =mytime.GetHour();
  161.     mdate.time.minute=mytime.GetMinute();
  162.     mdate.time.second=mytime.GetSecond();
  163.     mdate.time.week=GetWeekday(mdate.date.year,    mdate.date.month,    mdate.date.day);
  164.     printf("系统设定时间为:%04d-%02d-%02d,%02d:%02d,%d:%02d\r\n",
  165.     mdate.date.year,mdate.date.month,mdate.date.day,
  166.     mdate.time.hour,mdate.time.minute,mdate.time.second,
  167.     mdate.time.week);
  168.     wLen=sizeof(mdate);

  170.     sprintf(szBuf,"系统设定时间为:%04d-%02d-%02d,%02d:%02d,%d:%02d\r\n",
  171.     mdate.date.year,mdate.date.month,mdate.date.day,
  172.     mdate.time.hour,mdate.time.minute,mdate.time.second,
  173.     mdate.time.week);
  174.     wLen=sizeof(mdate);
  175.     
  176.     WriteinfoDisplay(szBuf,TP_ADD);
  177.     m_port.ClearComRecvFifo();//很重要，下位机发送串口数据可能存在多余乱码
  178.     try
  179.     {
  180.         m_port.WriteToPort( (char *)&mdate,sizeof(mdate) );
  181.     }
  182.     catch (...)
  183.     {
  184.         AfxMessageBox("串口无效");
  185.     }
  186. }
  187. //将界面设置时间对时，手动对时
  188. void timeDlg::OnButtonDirectwrite()
  189. {
  190.     // TODO: Add your control notification handler code here
  191.     char szBuf[100];
  192.     CComConfigDlg *dlg=(CComConfigDlg *)AfxGetMainWnd();

  194.     UpdateData(TRUE);
  195.     date_time_t date;
  196.     date.date.year=m_edit_year;
  197.     date.date.month    =m_edit_month;
  198.     date.date.day    =m_edit_day;
  199.     date.time.hour    =m_edit_hour;
  200.     date.time.minute=m_edit_minute;
  201.     date.time.second=m_edit_second;
  202.     date.time.week    =0;//无效，单片机根据写入的年月日计算出星期
  203.     printf("手动设定时间为:%04d-%02d-%02d,%02d:%02d,%d:%02d\r\n",
  204.     date.date.year,date.date.month,date.date.day,
  205.     date.time.hour,date.time.minute,date.time.second,
  206.     date.time.week);
  207.     sprintf(szBuf,"手动设定时间为:%04d-%02d-%02d,%02d:%02d,%d:%02d\r\n",
  208.     date.date.year,date.date.month,date.date.day,
  209.     date.time.hour,date.time.minute,date.time.second,
  210.     date.time.week);
  211.     WriteinfoDisplay(szBuf,TP_ADD);
  212.     m_port.ClearComRecvFifo();//很重要，下位机发送串口数据可能存在多余乱码
  213.     try
  214.     {
  215.         m_port.WriteToPort( (char *)&date,sizeof(date) );
  216.     }
  217.     catch (...)
  218.     {
  219.         AfxMessageBox("串口无效");
  220.     }


  223. //    dlg->m_cmod.SavePLC( &(dlg->m_cmod) );
  224. }

  226. void timeDlg::OnButtonRingTm()
  227. {
  228.     // TODO: Add your control notification handler code here
  229.     date_time_t mdate;
  230.         CTime mytime=CTime::GetCurrentTime();

  232.     mdate.date.year=mytime.GetYear();
  233.     mdate.date.month    =mytime.GetMonth();
  234.     mdate.date.day    =mytime.GetDay();

  236.     mdate.time.hour    =mytime.GetHour();
  237.     mdate.time.minute=mytime.GetMinute();
  238.     mdate.time.second=mytime.GetSecond();
  239.     mdate.time.week    =CMD_RING_TIME;
  240.     m_port.ClearComRecvFifo();//很重要，下位机发送串口数据可能存在多余乱码
  241.     try
  242.     {
  243.         m_port.WriteToPort( (char *)&mdate,sizeof(mdate) );
  244.     }
  245.     catch (...)
  246.     {
  247.         AfxMessageBox("串口无效");
  248.     }
  249. }

  251. void timeDlg::OnButtonRingDt()
  252. {
  253.     // TODO: Add your control notification handler code here
  254.     date_time_t mdate;
  255.     CTime mytime=CTime::GetCurrentTime();
  256.     mdate.date.year=mytime.GetYear();
  257.     mdate.date.month    =mytime.GetMonth();
  258.     mdate.date.day    =mytime.GetDay();

  260.     mdate.time.hour    =mytime.GetHour();
  261.     mdate.time.minute=mytime.GetMinute();
  262.     mdate.time.second=mytime.GetSecond();
  263.     mdate.time.week    =CMD_RING_DATE;
  264.     m_port.ClearComRecvFifo();//很重要，下位机发送串口数据可能存在多余乱码
  265.     try
  266.     {
  267.         m_port.WriteToPort( (char *)&mdate,sizeof(mdate) );
  268.     }
  269.     catch (...)
  270.     {
  271.         AfxMessageBox("串口无效");
  272.     }
  273. }

  275. void timeDlg::WriteinfoDisplay(CString strInfo,BYTE byType)
  276. {
  277.     static CString strDis;
  278.     CString strTmp;
  279.     static char szLine =0;
  280.     switch(byType)
  281.     {
  282.         case TP_ADD:
  283.         strDis +=strInfo;
  284.         break;
  285.         case TP_NEW:
  286.         strDis = strInfo;
  287.         break;
  288.         case TP_CLEAR:
  289.         strDis="";
  290.         break;
  291.     }
  292.     szLine ++;
  293.     GetDlgItem(IDC_STATIC_INFO)->SetWindowText(strDis);
  294.     if(szLine >=11)
  295.     {
  296.         szLine =0;
  297.         strDis ="";
  298.     }
  299. }
CSerial.cpp

点击(此处)折叠或打开

  1. /*
  2. **    FILENAME            CSerialPort.cpp
  3. **
  4. **    PURPOSE                This class can read, write and watch one serial port.
  5. **                        It sends messages to its owner when something happends on the port
  6. **                        The class creates a thread for reading and writing so the main
  7. **                        program is not blocked.
  8. **
  9. **    CREATION DATE        15-09-1997
  10. **    LAST MODIFICATION    12-11-1997
  11. **
  12. **    AUTHOR                Remon Spekreijse
  13. **
  14. **
  15. */

  17. #include "stdafx.h"
  18. #include "SerialPort.h"
  19. //#include "timeDlg.h"

  21. #include "mtype.h"
  22. #include "mqueue.h"

  24. #include <assert.h>
  25. #include "Proctol.h"

  27. #include "ComConfig.h"
  28. #include "ComConfigDlg.h"
  29. #include "timeDlg.h"

  31. uint8 rcv_buf[1000];
  32. //uint8 snd_buf[1000];


  35. //
  36. // Constructor
  37. //
  38. CSerialPort::CSerialPort()
  39. {
  40.     m_hComm = NULL;

  42.     // initialize overlapped structure members to zero
  43.     m_ov.Offset = 0;
  44.     m_ov.OffsetHigh = 0;

  46.     // create events
  47.     m_ov.hEvent = NULL;
  48.     m_hWriteEvent = NULL;
  49.     m_hShutdownEvent = NULL;

  51.     m_szWriteBuffer = NULL;

  53.     m_bThreadAlive = FALSE;
  54.     m_bSerialPortIsOpen=FALSE;
  55. }

  57. //
  58. // Delete dynamic memory
  59. //
  60. CSerialPort::~CSerialPort()
  61. {
  62.     do
  63.     {
  64.         SetEvent(m_hShutdownEvent);
  65.     } while (m_bThreadAlive);

  67.     TRACE("Thread ended\n");

  69.     delete [] m_szWriteBuffer;
  70. }

  72. uint8 ReadFull(void)
  73. {

  75.     return 0;
  76. }

  78. uint8 ReadEmpty(void)
  79. {

  81.     return 0;
  82. }
  83. //
  84. // Initialize the port. This can be port 1 to 4.
  85. //
  86. BOOL CSerialPort::InitPort(CWnd* pPortOwner,    // the owner (CWnd) of the port (receives message)
  87.                          UINT portnr,        // portnumber (1..4)
  88.                          UINT baud,            // baudrate
  89.                          char parity,        // parity
  90.                          UINT databits,        // databits
  91.                          UINT stopbits,        // stopbits
  92.                          DWORD dwCommEvents,    // EV_RXCHAR, EV_CTS etc
  93.                          UINT writebuffersize)    // size to the writebuffer
  94. {
  95.     assert(portnr > 0 && portnr < 55);
  96.     assert(pPortOwner != NULL);

  98.     // if the thread is alive: Kill
  99.     if (m_bThreadAlive)
  100.     {
  101.         do
  102.         {
  103.             SetEvent(m_hShutdownEvent);
  104.         } while (m_bThreadAlive);
  105.         TRACE("Thread ended\n");
  106.     }
  107.     
  108.     //InitQueue(void)
  109.     

  111.     QueueCreate( (uint8 *)rcv_buf,sizeof(rcv_buf),sizeof(uint8),NULL,NULL);
  112. //    QueueCreate( (uint8 *)snd_buf,sizeof(snd_buf),sizeof(uint8),NULL,NULL);
  113.     
  114.     // create events
  115.     if (m_ov.hEvent != NULL)
  116.         ResetEvent(m_ov.hEvent);
  117.     m_ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

  119.     if (m_hWriteEvent != NULL)
  120.         ResetEvent(m_hWriteEvent);
  121.     m_hWriteEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
  122.     
  123.     if (m_hShutdownEvent != NULL)
  124.         ResetEvent(m_hShutdownEvent);
  125.     m_hShutdownEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

  127.     // initialize the event objects
  128.     m_hEventArray[0] = m_hShutdownEvent;    // highest priority
  129.     m_hEventArray[1] = m_ov.hEvent;
  130.     m_hEventArray[2] = m_hWriteEvent;

  132.     // initialize critical section
  133.     InitializeCriticalSection(&m_csCommunicationSync);
  134.     
  135.     // set buffersize for writing and save the owner
  136.     m_pOwner = pPortOwner;

  138.     if (m_szWriteBuffer != NULL)
  139.         delete [] m_szWriteBuffer;
  140.     m_szWriteBuffer = new char[writebuffersize];

  142.     m_nPortNr = portnr;

  144.     m_nWriteBufferSize = writebuffersize;
  145.     m_dwCommEvents = dwCommEvents;

  147.     BOOL bResult = FALSE;
  148.     char *szPort = new char[50];
  149.     char *szBaud = new char[50];

  151.     // now it
  152.     EnterCriticalSection(&m_csCommunicationSync);

  154.     // if the port is already opened: close it
  155.     if (m_hComm != NULL)
  156.     {
  157.         CloseHandle(m_hComm);
  158.         m_hComm = NULL;
  159.     }

  161.     // prepare port strings
  162.     sprintf(szPort, "COM%d", portnr);
  163.     sprintf(szBaud, "baud=%d parity=%c data=%d stop=%d", baud, parity, databits, stopbits);

  165.     // get a handle to the port
  166.     m_hComm = CreateFile(szPort,                        // communication port string (COMX)
  167.                      GENERIC_READ | GENERIC_WRITE,    // read/write types
  168.                      0,                                // comm devices must be opened with exclusive access
  169.                      NULL,                            // no security attributes
  170.                      OPEN_EXISTING,                    // comm devices must use OPEN_EXISTING
  171.                      FILE_FLAG_OVERLAPPED,            // Async I/O
  172.                      0);                            // template must be 0 for comm devices

  174.     if (m_hComm == INVALID_HANDLE_VALUE)
  175.     {
  176.         // port not found
  177.         delete [] szPort;
  178.         delete [] szBaud;

  180.         return FALSE;
  181.     }

  183.     // set the timeout values
  184.     m_CommTimeouts.ReadIntervalTimeout = 1000;
  185.     m_CommTimeouts.ReadTotalTimeoutMultiplier = 1000;
  186.     m_CommTimeouts.ReadTotalTimeoutConstant = 1000;
  187.     m_CommTimeouts.WriteTotalTimeoutMultiplier = 1000;
  188.     m_CommTimeouts.WriteTotalTimeoutConstant = 1000;

  190.     // configure
  191.     if (SetCommTimeouts(m_hComm, &m_CommTimeouts))
  192.     {                        
  193.         if (SetCommMask(m_hComm, dwCommEvents))
  194.         {
  195.             if (GetCommState(m_hComm, &m_dcb))
  196.             {
  197.                 m_dcb.fRtsControl = RTS_CONTROL_ENABLE;        // set RTS bit
  198.                 if (BuildCommDCB(szBaud, &m_dcb))
  199.                 {
  200.                     if (SetCommState(m_hComm, &m_dcb))
  201.                         ; // normal operation... continue
  202.                     else
  203.                         ProcessErrorMessage("SetCommState()");
  204.                 }
  205.                 else
  206.                     ProcessErrorMessage("BuildCommDCB()");
  207.             }
  208.             else
  209.                 ProcessErrorMessage("GetCommState()");
  210.         }
  211.         else
  212.             ProcessErrorMessage("SetCommMask()");
  213.     }
  214.     else
  215.         ProcessErrorMessage("SetCommTimeouts()");

  217.     delete [] szPort;
  218.     delete [] szBaud;

  220.     // flush the port
  221.     PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);

  223.     // release critical section
  224.     LeaveCriticalSection(&m_csCommunicationSync);

  226.     TRACE("Initialisation for communicationport %d completed.\nUse Startmonitor to communicate.\n", portnr);

  228.     return TRUE;
  229. }

  231. //
  232. // The CommThread Function.
  233. //
  234. UINT CSerialPort::CommThread(LPVOID pParam)
  235. {
  236.     // Cast the void pointer passed to the thread back to
  237.     // a pointer of CSerialPort class
  238.     CSerialPort *port = (CSerialPort*)pParam;
  239.     
  240.     // Set the status variable in the dialog class to
  241.     // TRUE to indicate the thread is running.
  242.     port->m_bThreadAlive = TRUE;    
  243.         
  244.     // Misc. variables
  245.     DWORD BytesTransfered = 0;
  246.     DWORD Event = 0;
  247.     DWORD CommEvent = 0;
  248.     DWORD dwError = 0;
  249.     COMSTAT comstat;
  250.     BOOL bResult = TRUE;
  251.         
  252.     // Clear comm buffers at startup
  253.     if (port->m_hComm)        // check if the port is opened
  254.         PurgeComm(port->m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);

  256.     // begin forever loop. This loop will run as long as the thread is alive.
  257.     for (;;)
  258.     {

  260.         // Make a call to WaitCommEvent(). This call will return immediatly
  261.         // because our port was created as an async port (FILE_FLAG_OVERLAPPED
  262.         // and an m_OverlappedStructerlapped structure specified). This call will cause the
  263.         // m_OverlappedStructerlapped element m_OverlappedStruct.hEvent, which is part of the m_hEventArray to
  264.         // be placed in a non-signeled state if there are no bytes available to be read,
  265.         // or to a signeled state if there are bytes available. If this event handle
  266.         // is set to the non-signeled state, it will be set to signeled when a
  267.         // character arrives at the port.

  269.         // we do this for each

  271.         bResult = WaitCommEvent(port->m_hComm, &Event, &port->m_ov);

  273.         if (!bResult)
  274.         {
  275.             // If WaitCommEvent() returns FALSE, process the last error to determin
  276.             // the reason..
  277.             switch (dwError = GetLastError())
  278.             {
  279.             case ERROR_IO_PENDING:     
  280.                 {
  281.                     // This is a normal return value if there are no bytes
  282.                     // to read at the port.
  283.                     // Do nothing and continue
  284.                     break;
  285.                 }
  286.             case 87:
  287.                 {
  288.                     // Under Windows NT, this value is returned for some reason.
  289.                     // I have not investigated why, but it is also a valid reply
  290.                     // Also do nothing and continue.
  291.                     break;
  292.                 }
  293.             default:
  294.                 {
  295.                     // All other error codes indicate a serious error has
  296.                     // occured. Process this error.
  297.                     port->ProcessErrorMessage("WaitCommEvent()");
  298.                     break;
  299.                 }
  300.             }
  301.         }
  302.         else
  303.         {
  304.             // If WaitCommEvent() returns TRUE, check to be sure there are
  305.             // actually bytes in the buffer to read.
  306.             //
  307.             // If you are reading more than one byte at a time from the buffer
  308.             // (which this program does not do) you will have the situation occur
  309.             // where the first byte to arrive will cause the WaitForMultipleObjects()
  310.             // function to stop waiting. The WaitForMultipleObjects() function
  311.             // resets the event handle in m_OverlappedStruct.hEvent to the non-signelead state
  312.             // as it returns.
  313.             //
  314.             // If in the time between the reset of this event and the call to
  315.             // ReadFile() more bytes arrive, the m_OverlappedStruct.hEvent handle will be set again
  316.             // to the signeled state. When the call to ReadFile() occurs, it will
  317.             // read all of the bytes from the buffer, and the program will
  318.             // loop back around to WaitCommEvent().
  319.             //
  320.             // At this point you will be in the situation where m_OverlappedStruct.hEvent is set,
  321.             // but there are no bytes available to read. If you proceed and call
  322.             // ReadFile(), it will return immediatly due to the async port setup, but
  323.             // GetOverlappedResults() will not return until the next character arrives.
  324.             //
  325.             // It is not desirable for the GetOverlappedResults() function to be in
  326.             // this state. The thread shutdown event (event 0) and the WriteFile()
  327.             // event (Event2) will not work if the thread is blocked by GetOverlappedResults().
  328.             //
  329.             // The solution to this is to check the buffer with a call to ClearCommError().
  330.             // This call will reset the event handle, and if there are no bytes to read
  331.             // we can loop back through WaitCommEvent() again, then proceed.
  332.             // If there are really bytes to read, do nothing and proceed.
  333.         
  334.             bResult = ClearCommError(port->m_hComm, &dwError, &comstat);

  336.             if (comstat.cbInQue == 0)
  337.                 continue;
  338.         }    // end if bResult

  340.         // Main wait function. This function will normally block the thread
  341.         // until one of nine events occur that require action.
  342.         Event = WaitForMultipleObjects(3, port->m_hEventArray, FALSE, INFINITE);

  344.         switch (Event)
  345.         {
  346.         case 0:
  347.             {
  348.                 // Shutdown event. This is event zero so it will be
  349.                 // the higest priority and be serviced first.

  351.                  port->m_bThreadAlive = FALSE;
  352.                 
  353.                 // Kill this thread. break is not needed, but makes me feel better.
  354.                 AfxEndThread(100);
  355.                 break;
  356.             }
  357.         case 1:    // read event
  358.             {
  359.                 GetCommMask(port->m_hComm, &CommEvent);
  360.                 if (CommEvent & EV_CTS)
  361.                     ::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_CTS_DETECTED, (WPARAM) 0, (LPARAM) port->m_nPortNr);
  362.                 if (CommEvent & EV_RXFLAG)
  363.                     ::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_RXFLAG_DETECTED, (WPARAM) 0, (LPARAM) port->m_nPortNr);
  364.                 if (CommEvent & EV_BREAK)
  365.                     ::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_BREAK_DETECTED, (WPARAM) 0, (LPARAM) port->m_nPortNr);
  366.                 if (CommEvent & EV_ERR)
  367.                     ::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_ERR_DETECTED, (WPARAM) 0, (LPARAM) port->m_nPortNr);
  368.                 if (CommEvent & EV_RING)
  369.                     ::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_RING_DETECTED, (WPARAM) 0, (LPARAM) port->m_nPortNr);
  370.                 
  371.                 if (CommEvent & EV_RXCHAR)
  372.                     // Receive character event from port.
  373.                     ReceiveChar(port, comstat);
  374.                     
  375.                 break;
  376.             }
  377.         case 2: // write event，串口发送事件响应
  378.             {
  379.                 // Write character event from port
  380.                 WriteChar(port);
  381.                 break;
  382.             }

  384.         } // end switch

  386.     } // close forever loop

  388.     return 0;
  389. }

  391. //
  392. // start comm watching
  393. //
  394. BOOL CSerialPort::StartMonitoring()
  395. {
  396.     if (!(m_Thread = AfxBeginThread(CommThread, this)))
  397.         return FALSE;
  398.     TRACE("Thread started\n");
  399.     AfxBeginThread(SerialParseThread,this);
  400.     return TRUE;    
  401. }

  403. //
  404. // Restart the comm thread
  405. //
  406. BOOL CSerialPort::RestartMonitoring()
  407. {
  408.     TRACE("Thread resumed\n");
  409.     m_Thread->ResumeThread();
  410.     return TRUE;    
  411. }


  414. //
  415. // Suspend the comm thread
  416. //
  417. BOOL CSerialPort::StopMonitoring()
  418. {
  419.     TRACE("Thread suspended\n");
  420.     m_Thread->SuspendThread();
  421.     return TRUE;    
  422. }


  425. //
  426. // If there is a error, give the right message
  427. //
  428. void CSerialPort::ProcessErrorMessage(char* ErrorText)
  429. {
  430.     char *Temp = new char[200];
  431.     
  432.     LPVOID lpMsgBuf;

  434.     FormatMessage(
  435.         FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
  436.         NULL,
  437.         GetLastError(),
  438.         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
  439.         (LPTSTR) &lpMsgBuf,
  440.         0,
  441.         NULL
  442.     );

  444.     sprintf(Temp, "WARNING: %s Failed with the following error: \n%s\nPort: %d\n", (char*)ErrorText, lpMsgBuf, m_nPortNr);
  445.     MessageBox(NULL, Temp, "Application Error", MB_ICONSTOP);
  446.     printf("%s\r\n",Temp);

  448.     LocalFree(lpMsgBuf);
  449.     delete[] Temp;
  450. }

  452. //
  453. // Write a character.
  454. //
  455. void CSerialPort::WriteChar(CSerialPort* port)
  456. {
  457.     BOOL bWrite = TRUE;
  458.     BOOL bResult = TRUE;

  460.     DWORD BytesSent = 0;

  462.     ResetEvent(port->m_hWriteEvent);

  464.     // Gain ownership of the critical section
  465.     EnterCriticalSection(&port->m_csCommunicationSync);

  467.     if (bWrite)
  468.     {
  469.         // Initailize variables
  470.         port->m_ov.Offset = 0;
  471.         port->m_ov.OffsetHigh = 0;

  473.         // Clear buffer
  474.         PurgeComm(port->m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);
  475.         DWORD dwLen=port->m_dwWriteBufferLen;

  477.         bResult = WriteFile(port->m_hComm,                            // Handle to COMM Port
  478.                             port->m_szWriteBuffer,                    // Pointer to message buffer in calling finction
  479.                             dwLen,                                    // Length of message to send
  480.                             &BytesSent,                                // Where to store the number of bytes sent
  481.                             &port->m_ov);                            // Overlapped structure

  483.         // deal with any error codes
  484.         if (!bResult)
  485.         {
  486.             DWORD dwError = GetLastError();
  487.             switch (dwError)
  488.             {
  489.                 case ERROR_IO_PENDING:
  490.                     {
  491.                         // continue to GetOverlappedResults()
  492.                         BytesSent = 0;
  493.                         bWrite = FALSE;
  494.                         break;
  495.                     }
  496.                 default:
  497.                     {
  498.                         // all other error codes
  499.                         port->ProcessErrorMessage("WriteFile()");
  500.                     }
  501.             }
  502.         }
  503.         else
  504.         {
  505.             LeaveCriticalSection(&port->m_csCommunicationSync);
  506.         }
  507.     } // end if(bWrite)

  509.     if (!bWrite)
  510.     {
  511.         bWrite = TRUE;
  512.     
  513.         bResult = GetOverlappedResult(port->m_hComm,    // Handle to COMM port
  514.                                      &port->m_ov,        // Overlapped structure
  515.                                      &BytesSent,        // Stores number of bytes sent
  516.                                      TRUE);             // Wait flag

  518.         LeaveCriticalSection(&port->m_csCommunicationSync);

  520.         // deal with the error code
  521.         if (!bResult)
  522.         {
  523.             port->ProcessErrorMessage("GetOverlappedResults() in WriteFile()");
  524.         }    
  525.     } // end if (!bWrite)

  527.     // Verify that the data size send equals what we tried to send
  528.     if (BytesSent != strlen((char*)port->m_szWriteBuffer))
  529.     {
  530.         TRACE("WARNING: WriteFile() error.. Bytes Sent: %d; Message Length: %d\n", BytesSent, strlen((char*)port->m_szWriteBuffer));
  531.     }
  532. }

  534. //
  535. // Character received. Inform the owner
  536. //
  537. void CSerialPort::ReceiveChar(CSerialPort* port, COMSTAT comstat)
  538. {
  539.     BOOL bRead = TRUE;
  540.     BOOL bResult = TRUE;
  541.     DWORD dwError = 0;
  542.     DWORD BytesRead = 0;
  543.     unsigned char RXBuff;

  545.     for (;;)
  546.     {
  547.         // Gain ownership of the comm port critical section.
  548.         // This process guarantees no other part of this program
  549.         // is using the port object.
  550.         
  551.         EnterCriticalSection(&port->m_csCommunicationSync);

  553.         // ClearCommError() will update the COMSTAT structure and
  554.         // clear any other errors.
  555.         
  556.         bResult = ClearCommError(port->m_hComm, &dwError, &comstat);

  558.         LeaveCriticalSection(&port->m_csCommunicationSync);

  560.         // start forever loop. I use this type of loop because I
  561.         // do not know at runtime how many loops this will have to
  562.         // run. My solution is to start a forever loop and to
  563.         // break out of it when I have processed all of the
  564.         // data available. Be careful with this approach and
  565.         // be sure your loop will exit.
  566.         // My reasons for this are not as clear in this sample
  567.         // as it is in my production code, but I have found this
  568.         // solutiion to be the most efficient way to do this.
  569.         
  570.         if (comstat.cbInQue == 0)
  571.         {
  572.             // break out when all bytes have been read
  573.             break;
  574.         }
  575.                         
  576.         EnterCriticalSection(&port->m_csCommunicationSync);

  578.         if (bRead)
  579.         {

  581.             try
  582.             {
  583.                 bResult = ReadFile(port->m_hComm,        // Handle to COMM port
  584.                              &RXBuff,                // RX Buffer Pointer
  585.                              1,                    // Read one byte
  586.                              &BytesRead,            // Stores number of bytes read
  587.                              &port->m_ov);        // pointer to the m_ov structure
  588.             }
  589.             catch (...)
  590.             {
  591.                 //bResult        
  592.             }
  593.         
  594.             // deal with the error code
  595.             if (!bResult)
  596.             {
  597.                 switch (dwError = GetLastError())
  598.                 {
  599.                     case ERROR_IO_PENDING:     
  600.                         {
  601.                             // asynchronous i/o is still in progress
  602.                             // Proceed on to GetOverlappedResults();
  603.                             bRead = FALSE;
  604.                             break;
  605.                         }
  606.                     default:
  607.                         {
  608.                             // Another error has occured. Process this error.
  609.                             port->ProcessErrorMessage("ReadFile()");
  610.                             break;
  611.                         }
  612.                 }
  613.             }
  614.             else
  615.             {
  616.                 // ReadFile() returned complete. It is not necessary to call GetOverlappedResults()
  617.                 bRead = TRUE;
  618.             }
  619.         } // close if (bRead)

  621.         if (!bRead)
  622.         {
  623.             bRead = TRUE;
  624.             bResult = GetOverlappedResult(port->m_hComm,    // Handle to COMM port
  625.                                          &port->m_ov,        // Overlapped structure
  626.                                          &BytesRead,        // Stores number of bytes read
  627.                                          TRUE);             // Wait flag

  629.             // deal with the error code
  630.             if (!bResult)
  631.             {
  632.                 port->ProcessErrorMessage("GetOverlappedResults() in ReadFile()");
  633.             }    
  634.         } // close if (!bRead)
  635.                 
  636.         LeaveCriticalSection(&port->m_csCommunicationSync);

  638.         // notify parent that a byte was received
  639.         ::SendMessage((port->m_pOwner)->m_hWnd, WM_COMM_RXCHAR, (WPARAM) RXBuff, (LPARAM) port->m_nPortNr);

  641.         QueueWrite(rcv_buf,&RXBuff,1);

  643.         //printf("%02x\r\n",RXBuff);
  644.     } // end forever loop

  646. }

  648. //
  649. // Write a string to the port
  650. //
  651. void CSerialPort::WriteToPort(char* string)
  652. {        
  653.     assert(m_hComm != 0);
  654.     m_dwWriteBufferLen=sizeof(m_szWriteBuffer);
  655.     memset(m_szWriteBuffer, 0, m_dwWriteBufferLen);
  656.     strcpy(m_szWriteBuffer, string);
  657.     
  658.     // set event for write
  659.     SetEvent(m_hWriteEvent);
  660. }

  662. void CSerialPort::WriteToPort(char *string, WORD wLen)
  663. {
  664.     assert(m_hComm != 0);
  665.     m_dwWriteBufferLen=wLen;
  666.     memset(m_szWriteBuffer, 0, wLen);
  667.     memcpy(m_szWriteBuffer,string,wLen);
  668.     // set event for write
  669.     SetEvent(m_hWriteEvent);
  670. }


  673. //
  674. // Return the device control block
  675. //
  676. DCB CSerialPort::GetDCB()
  677. {
  678.     return m_dcb;
  679. }

  681. //
  682. // Return the communication event masks
  683. //
  684. DWORD CSerialPort::GetCommEvents()
  685. {
  686.     return m_dwCommEvents;
  687. }

  689. //
  690. // Return the output buffer size
  691. //
  692. DWORD CSerialPort::GetWriteBufferSize()
  693. {
  694.     return m_nWriteBufferSize;
  695. }



  699. extern ComConfigApp theApp;

  701. //串口接收解析线程
  702. UINT CSerialPort::SerialParseThread(void *param)
  703. {
  704.     BYTE byrecv[100];
  705.     char szBuf[1000];
  706.     CComConfigDlg *dlg =(CComConfigDlg *)theApp.m_pMainWnd;
  707.     while (1)
  708.     {
  709.         DWORD dwLen;
  710.         dwLen=QueueNData(rcv_buf,1);
  711.         if(dwLen>=7)
  712.         {
  713.         
  714.             for (UINT32 ilp=0;ilp<dwLen;ilp++)
  715.             {
  716.                 if ( QueueRead(byrecv + ilp ,rcv_buf,1)!=QUEUE_OK )
  717.                 {
  718.                     break;
  719.                 }
  720.             //    printf("%d\t",byrecv[ilp]);
  721.             
  722.             }
  723.             //printf("\r\n");lz20150801

  725.             date_time_t *dt;
  726.             dt=(date_time_t *)byrecv;
  727.             printf("万年历反馈时间:%04d-%02d-%02d,%02d:%02d:%02d,%d\r\n",
  728.                 dt->date.year,dt->date.month,dt->date.day,
  729.                 dt->time.hour,dt->time.minute,dt->time.second,
  730.                 dt->time.week);

  732.             sprintf(szBuf,"万年历反馈时间:%04d-%02d-%02d,%02d:%02d:%02d,%d\r\n",
  733.                 dt->date.year,dt->date.month,dt->date.day,
  734.                 dt->time.hour,dt->time.minute,dt->time.second,
  735.                 dt->time.week);
  736.             dlg->m_timeDlg.WriteinfoDisplay(szBuf,TP_ADD);

  738.             QueueFlush(rcv_buf);
  739.             
  740.         }
  741.         Sleep(1);
  742.     }

  744.     return TRUE;
  745. }

  747. int CSerialPort::EnumAllComPort(CString *pStr)
  748. {
  749.     int i = 0;
  750.     CHAR Name[25];
  751.     UCHAR szPortName[25];
  752.     LONG Status;
  753.     DWORD dwIndex = 0;
  754.     DWORD dwName;
  755.     DWORD dwSizeofPortName;
  756.     DWORD Type;
  757.     HKEY hKey;
  758.     LPCTSTR data_Set = "HARDWARE\\DEVICEMAP\\SERIALCOMM\\";
  759.     long ret0 = (::RegOpenKeyEx(HKEY_LOCAL_MACHINE, data_Set, 0, KEY_READ, &hKey));

  761.     do
  762.     {
  763.             dwName = sizeof(Name);
  764.             dwSizeofPortName = sizeof(szPortName);
  765.             Status = RegEnumValue(hKey, dwIndex++, Name, &dwName, NULL, &Type,
  766.                     szPortName, &dwSizeofPortName);

  768.             if ((Status == ERROR_SUCCESS) || (Status == ERROR_MORE_DATA))
  769.             {
  770.                     pStr[i] = CString(szPortName); // 串口字符串保存
  771.                     i++;// 串口计数
  772.             }
  773.     }
  774.     while ((Status == ERROR_SUCCESS) || (Status == ERROR_MORE_DATA));

  776.     RegCloseKey(hKey);
  777.     return i;

  779. }

  781. BOOL CSerialPort::ClearComRecvFifo()
  782. {
  783.     QueueFlush(rcv_buf);

  785.     return TRUE;
  786. }





阅读(2584) | 评论(0) | 转发(0) |
0

上一篇：电子指南针

下一篇：ubuntu14.10 修改源

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6