1．  实例目的：

本实例完全建立在计算机软件的基础上，利用PROTEUS软件构建一个单片机系统，利用VB编写一个计算机控制软件和单片机系统串行通信，计算机上的控制软件可以发送一个值在0——999之间的数，在单片机系统上显示出来，单片机系统上也可输入一个相同值域的数并在计算机控制软件上显示出来。本实例主要是为了展示虚拟串行通信的仿真。

2．  系统配置

本实例虽然简单，但是要想看到想要的仿真结果，建立虚拟的串口连接是必不可少的。要想仿真串行通信，必须要把单片机系统上的串行口与计算机上的串行口连接，这样他们之间才能传输数据，但由于是仿真，实际没有相连接，所以需要创建一对虚拟串行口并使他们相连，这里我使用的是这个软件Virtual Serial Ports Driver XP 5.1(VSPD XP),打开后的界面如图1所示。在右面“ADD PAIR”按钮的旁边的下拉选项中一个选择“COM3”，一个选择

“COM4”，然后点击“ADD PAIR”按钮，这样就完成了虚拟串口“COM3”和“COM4”的连接，完成后如图1所示。简单吧？！

       另外，你还要选择一个串口调试软件作为你的调试软件，因为当你单片机系统弄完以后而计算机上的控制软件还没有编时，没有串口调试软件的话，你就没法知道你单片机系统正确与否。这种软件网上多如牛毛，随便找一个。我的软件为SSCOM32，界面如图2所示。

功能与用法这里就不一一介绍了，反正既能接收又能发送，实例需要的功能他都可以调试。

3．单片机系统

单片机硬件：

电路如图3所示。

本实例采用的单片机依然是PIC16F877，他含有UASRT模块，有了它才能进行串行通信。显示部分采用3位数码管共阳输出。键盘采用矩阵键盘。这里需要特别说明的是，由于是仿真，没有采用电平转换芯片MAX232将TTL电平转换成RS232的电平，实际这一步是必需的。串行口的设置需要特别注意，由于本实例单片机程序中设置的波特率是9600，8位数据，无奇偶校验，所以串行口也要一样设置，这里由于建立的是“COM3”“COM4”之间的虚拟连接，端口号一定要设置成“COM3”或“COM4”，这是关键！如图4所示。

单片机软件：

单片机软件主要由以下几个部分组成：初始化程序，显示程序，键盘输入程序，串行接收程序，串行发送程序。

程序采用C语言，简单明了，经过PICC编译通过。

全部程序如下：

/************************************************************

* 标题：PCtoPIC                                             *

* 用途：用于上位机与单片机之间的通讯（本例为下位机软件）    *

* 时间：2009年1月4日                                      *

* 作者：WUJIEFLASH                                        *

************************************************************/                      

#include <pic.h>

//预定义

#define uch unsigned char

//显示用码表

const uch shu[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x98,0xff};

//变量

int data,temp1,temp2,temp3,temp;

uch flag,keylock;

uch point,buffer[3];      

//初始化

void init()

{

       TRISB=0;

       PORTB=0;

       TRISC=0;

       PORTC=0;

       keylock=1;//初始化键盘按键标志位，用于锁定按键

       //USART部件初始化

       SPBRG=0x19;//设置波特率为9600bps

       TXSTA=0x04;//选择异步高速8位数据传输模式

       RCSTA=0x80;//允许串行端口工作

       TRISC=0x80;//设置为高阻态，防止干扰

       TXEN=1;//发送允许

       CREN=1;//接收允许

       PEIE=1; //开放外设中断

       RCIE=1; //开放串行口中断

       ei();    //开放总中断

}

//显示需要的延时

void delay()

{

       int i;

       for(i=0;i<1000;i++);     

}

//发送子程序

void send_usart()

{

       uch i;

       for(i=0;i<3;i++)//每次发3个数据

       {

              if(i==0)TXREG=data/100+0x30;//求得百位

              if(i==1)TXREG=data%100/10+0x30; //求得十位

              if(i==2)TXREG=data%10+0x30; //求得个位

              while(1)

              {

                     if(TXIF==1)break;//等待发送完成

              }

       }

}

//中断接收子程序

void interrupt receive(void)

{

       if(point<3)//是否已经接收到3个数据

       buffer[point++]=RCREG-48;//没有，继续接收

       else point=0;//是，指针复位

       data=buffer[0]*100+buffer[1]*10+buffer[2];//组合成三位数

}

//数码管显示

void display(int dis_data)

{

       int dis_data_ge,dis_data_shi,dis_data_bai;

       dis_data_ge =dis_data%10;//个位

       dis_data_shi=dis_data%100/10;//十位

       dis_data_bai=dis_data/100;    //百位

       if(dis_data==0)//若数据为0，只显示1位

       {

              dis_data_ge=0;

              dis_data_shi=10;

              dis_data_bai=10;

       }

       if(dis_data<10)//若数据小于10，则十位与百位关闭显示

       {

              dis_data_shi=10;

              dis_data_bai=10;

       }

       if(dis_data<100)//若数据小于100，则只显示两位

       {

              dis_data_bai=10;

       }

       RC0=0;

       RC1=0;

       RC2=1;

       PORTB=shu[dis_data_ge];//个位送显

       delay();

       RC0=0;

       RC2=0;

       RC1=1;

       PORTB=shu[dis_data_shi];//十位送显

       delay();

       RC1=0;

       RC2=0;

       RC0=1;

       PORTB=shu[dis_data_bai];//百位送显

       delay();  

}

//键盘（线反转法）

void presskey()

{

       uch line,column,key;

       TRISD=0x07;

       PORTD=0xf0;

       column=PORTD & 0x07;//取列码

       TRISD=0xf0;

       PORTD=0x0f;

       line=PORTD&0xf0;//取行码

       key=line|column;//合成键值

       if(key==0)keylock=0;//保证每次只按一次键

       if(keylock==0)

       {

              if(key!=0)keylock=1;

              switch(key)//查找键值

              {

                     case 0x11:temp=3;flag++;break;

                     case 0x12:temp=2;flag++;break;

                     case 0x14:temp=1;flag++;break;

                     case 0x21:temp=4;flag++;break;

                     case 0x22:temp=5;flag++;break;

                     case 0x24:temp=6;flag++;break;

                     case 0x41:temp=9;flag++;break;

                     case 0x42:temp=8;flag++;break;

                     case 0x44:temp=7;flag++;break;

                     case 0x82:temp=0;flag++;break;

                     case 0x81:flag=4;send_usart();break;//发送

                     case 0x84:flag=0;data=0;break;//清零键

              }

       }

       if(flag==1)//第一次按键

       {

              if(temp==0)flag=0;//若按0，则忽略

              temp1=temp;

              data=temp1;

       }

       if(flag==2)//第二次按键

       {

              temp2=temp;

              data=temp1*10+temp2;//原来的个位变成十位

       }

       if(flag==3)//第三次按键

       {

              temp3=temp;

              data=temp1*100+temp2*10+temp3;//原来的十位变成百位

              flag=4;//屏蔽按键

       }    

}

//主程序

main()

{

       init();

       while(1)

       {

              presskey();

              display(data);

       }

}

4．  计算机控制软件

上位机软件是用VB编写的，功能很简单，主要有发送和接收两个功能。软件的界面如图5所示。

软件主要有2个“TextBox”，3个按钮，和一些文本控件组成。

现把所有程序都贴出来：

Private Sub Cmdquit_Click()

i = MsgBox("您要离开吗？", vbQuestion Or vbYesNo, "温馨提示")

If i = 6 Then

Shell "explorer.exe http://blog.163.com/wujieflash"

End

End If

End Sub

Private Sub Cmdsend_Click()

If Len(Text1.Text) = 1 Then MSComm1.Output = "0" + "0" + Text1.Text   '不满3位补足3位再发送

If Len(Text1.Text) = 2 Then MSComm1.Output = "0" + Text1.Text

If Len(Text1.Text) = 3 Then MSComm1.Output = Text1.Text

End Sub

Private Sub cmdzero_Click()

Text2.Text = ""

Text1.Text = ""

End Sub

Private Sub Form_Load()

MSComm1.Settings = "9600,n,8,1"    '设置数据传输率和发送字符格式

MSComm1.CommPort = 4               '设置通讯串口为4

MSComm1.InputLen = 0               '设置或返回一次从接受缓冲器中读取所有字节数

MSComm1.InBufferSize = 512         '设置接收缓冲区512BYTE

MSComm1.InBufferCount = 0

MSComm1.OutBufferSize = 512        '设置发送缓冲区512BYTE

MSComm1.OutBufferCount = 0

MSComm1.RThreshold = 3             '每3个字符到接收缓冲区都触发接收事件

MSComm1.SThreshold = 1

MSComm1.PortOpen = True

End Sub

Private Sub Label6_Click()

Shell "explorer.exe http://blog.163.com/wujieflash"  '我博客的超连接，多多捧场

End Sub

Private Sub MSComm1_OnComm()

Text2.Text = MSComm1.Input

End Sub

Private Sub Text1_KeyPress(KeyAscii As Integer)

If KeyAscii < Asc("0") Or KeyAscii > Asc("9") Then

KeyAscii = 0

MsgBox ("请输入数字字符！")

End If

End Sub

软件是简单了点，但功能却齐全的。

5．  总结

这次搞得这个实例仿真的确有点麻烦，不过的确能了解很多关于这串行通信方面的知识，经过自己亲自动手实现，感觉也是蛮不错的。我想大多和我一样的菜鸟或正在找寻这方面资料的朋友一定会获益非浅的。

摘要：对PWM控制芯片SG3524与SG3525的工作性能作了介绍和比较，通过实验得出了SG3525在软起动功能上较SG3524有很大的改进。

关键词：SG3524；SG3525；脉宽调制；软起动

0    引言

    目前，开关电源越来越广泛地应用于各行各业中，是各种用电设备的重要组成部分。在开关电源的设计过程中，常常使用各种PWM的IC。因此，作为开关电源的设计者，有必要熟悉各种PWM的集成芯片的性能差别，才能在设计的时候灵活应用。下面主要针对常用的SG3524与SG3525两种芯片进行对比分析。

1    SG3524与SG3525

    SG3524是定频PWM电路，采用16引脚标准DIP封装。其各引脚功能如图1(a)所示，内部框图如图1(b)所示。

（a）SG3524的引脚

（b）内部框图

图1    SG3524引脚及内部框图

    脚9可以通过对地接阻容网络，补偿系统的幅频和相频响应特性。根据试验结果，对地接电容就可以实现软起动功能。

    SG3525也是定频PWM电路，采用16引脚标准DIP封装。其各引脚功能如图2(a)所示，内部框图如图2(b)所示。脚8为软起动端。

 （a）SG3525的引脚

（b）内部框图

图2    SG3525引脚及内部框图

2    SG3525相对SG3524的改进

    SG3525在SG3524的基础上，主要作了以下改进。

    1）增设欠压锁定电路    电路主要作用是当IC输入电压<8V时，集成块内部电路锁定，停止工作（基准源及必要电路除外），使之消耗电流降至很小（约2mA）。

    2）有软起动电路    比较器的反相端即软起动控制端脚8可外接软起动电容。该电容由内部5V基准参考电压的50μA恒流源充电，使占空比由小到大（50％）变化。

    3）比较器有两个反相输入端    SG3524的误差放大器、电流控制器和关闭控制3个信号共用一个反相输入端，现改为增加一个反相输入端，误差放大器与关闭电路各自送至比较器的反相端。这样，便避免了彼此相互影响，有利于误差放大器和补偿网络工作精度的提高。

    4）增加PWM锁存器使关闭作用更可靠    比较器（脉冲宽度调制）输出送到PWM锁存器，锁存器由关闭电路置位，由振荡器输出时间脉冲复位。这样，当关闭电路动作，即使过电流信号立即消失，锁存器也可维持一个周期的关闭控制，直到下一个周期时钟信号使锁存器复位为止。

    5）振荡器作了较大改进    SG3524中的振荡器只有CT及RT两引脚，充电和放电回路是相同的。SG3525的振荡器，除了CT及RT引脚外，增加了放电引脚7、同步引脚3。RT阻值决定对CT充电的内部恒流值，CT的放电则由脚5及脚7之间外接的电阻值RD决定。把充电和放电回路分开，有利于通过RD来调节死区的时间，这是重大的改进。在SG3525中增加了同步引脚3专为外同步用，为多个SG3525的联用提供了方便。

    6）输出级作了结构性改进    电路结构改为确保其输出电平处于高电平，或低电平状态。另外，为了适应驱动MOSFET的需要，末级采用了推挽式电路，使关断速度更快。

    SG3525增加的工作性能在实际应用中具有重要意义。例如，脚8增加的软起动功能，避免了开关电源在开机瞬间的电流冲击，可能造成的末级功率开关管的损坏。

3    实验结果

    对SG3525与SG3524的软起动功能作了对比试验。图3给出了SG3525与SG3524软起动试验的原理图。图4给出了SG3525脚8接100μF电容和SG3524脚9接100μF电容时，在通电2s和5s时的输出脉宽波形图。

（a）采用SG3525

（b）采用SG3524

图3    软起动试验原理图

（a）SG3524通电2s的波形

（b）SG3525通电2s的波形

（c）SG3524通电5s的波形

（d）SG3525通电5s的波形

图4    两种控制器分别在启动2s及5s后的波形

    从图4的波形以及表1和表2的数据比较可以看到，虽然SG3524与SG3525都可以实现软起动功能，但是，由于SG3525本身设计了软起动电路，因此，在实际实现软起动的过程中，由其内部的恒流源给外部电容充电，工作时不会影响到其它的电路，而SG3524要实现软起动，就要与误差放大器、电流控制器等同用一个反相端，就会彼此互相影响。另外，在相同电容量的情况下，SG3525更有利于提高软起动时间。

表1    SG3525脚8接不同的对地电容时的软起动时间

脚8对地电容C/μF	软启动时间t/s
10	0.58
22	1.26
33	1.84
47	2.33
100	4.76

表2    SG3524脚9接不同的对地电容时的软起动时间

脚9对地电容C/μF	软启动时间t/s
10	0.29
22	0.58
33	0.97
47	1.16
100	2.23

4结语     通过实验证明，SG3525的软起动性能优于SG3524。

    最近终于有空更新了,花了几天时间,弄出个小东西,虽然有很多种实现方式在网上流传了,但我却从没有试过,乘有时间,也弄出了四种方式的显示,各位帮忙看看,哪里还有不好的地方,希不吝指教.

一.原理及仿真图

此种为从右往左显示.

此中为从左往右显示

此种为从下往上显示

此种为从上往下显示

    原理图说明:

1.本实例采用微芯PIC16F877A单片机,此单片机适合初学者

2.点阵采用24X24点,左边为行线,采用U1-U3三个74LS373地址所存芯片,复用单片机RB端口.

右边为列线,采用U4-U6三个74LS373地址所存芯片,复用单片机RD端口.

3.单片机RC端口控制六片373的选通.

4.显示原理:24列列线轮流拉为低电平时,行线输出行玛,通过一定延时,字符即可显示,并通过计算,即可实现上述四种显示方式.

二.程序(已附解释,PICC 8.05 通过)

#include<pic.h>
#define uch unsigned char
int offset;//定义偏置变量，以使字符运动

//以下为需显示的字符数组
const uch zxhn[]=
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 0x00,0x00,0x00,0x10,0x30,0xE0,0x60,0x00,0x80,0x00,0xF0,0xF0,0x10,0x00,0xF0,0xE0,
 0x20,0x00,0x00,0xF0,0xF0,0x10,0x00,0x00,0x00,0x81,0x83,0x8E,0xCE,0xE0,0x78,0x76,
 0x3D,0x00,0xFF,0x7F,0x04,0x38,0xFF,0xFF,0x00,0x3C,0x38,0xFF,0xFF,0x00,0x00,0x00,
 0x00,0x00,0x00,0x00,0x3F,0x3F,0x20,0x10,0x18,0x0E,0x07,0x00,0x00,0x00,0x1F,0x1F,
 0x00,0x00,0x00,0x3F,0x3F,0x00,0x00,0x00,  //"洲",
 0x00,0x00,0x00,0x30,0x60,0x00,0x80,0x70,0x30,0x90,0x40,0x40,0x40,0x40,0xE0,0xE0,
 0x40,0x40,0x40,0x40,0xE0,0xE0,0x40,0x00,0x00,0x41,0x49,0x49,0x49,0xFF,0xFF,0x49,
 0x6D,0x6D,0x4B,0x9C,0x8C,0x40,0xFF,0xFF,0x01,0x8E,0x8C,0x40,0xFF,0xFF,0x00,0x00,
 0x00,0x40,0x20,0x10,0x0C,0x07,0x01,0x00,0x00,0x03,0x03,0x11,0x10,0x30,0x3F,0x1F,
 0x11,0x11,0x10,0x70,0x3F,0x3F,0x00,0x00,  //"翔"
 0x00,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xC0,0xC0,0x80,0x00,0x00,0xE0,0xF8,0x38,
 0x10,0x00,0x00,0x00,0x80,0x80,0x00,0x00,0x00,0x00,0x02,0x04,0x18,0xB0,0xE0,0xFC,
 0x9F,0x23,0x10,0x0C,0x07,0xC3,0xFD,0x3D,0x3D,0xE5,0x19,0x07,0x03,0x03,0x01,0x00,
 0x00,0x10,0x08,0x04,0x03,0x41,0x20,0x21,0x27,0x1F,0x18,0x0C,0x06,0x03,0x01,0x00,
 0x00,0x03,0x0F,0x1C,0x38,0x18,0x10,0x10,  //"欢"
 0x00,0x00,0x00,0x10,0x30,0xE0,0xC0,0x00,0x00,0xC0,0xC0,0x20,0x30,0x38,0x10,0xF0,
 0xC0,0x40,0x40,0x40,0xE0,0xC0,0x40,0x00,0x00,0x00,0x08,0x08,0x08,0xFC,0xFC,0x08,
 0x80,0xFF,0xFF,0x40,0x20,0x20,0x00,0xFF,0xFF,0x40,0x80,0x80,0xFF,0xFF,0x00,0x00,
 0x00,0x00,0x18,0x18,0x0C,0x07,0x07,0x0C,0x08,0x18,0x10,0x10,0x30,0x30,0x30,0x37,
 0x37,0x30,0x30,0x31,0x30,0x30,0x10,0x08,  //"迎"
 0x00,0x00,0x00,0x00,0x80,0xC0,0x70,0x30,0x10,0x00,0x00,0xC0,0x70,0x78,0x50,0x40,
 0x40,0x40,0x40,0xC0,0xE0,0x40,0x40,0x00,0x00,0x08,0x04,0x02,0x03,0xFF,0x7F,0x00,
 0x40,0x22,0x11,0x9C,0x0E,0x44,0xC0,0xFF,0x7F,0x01,0x06,0x09,0x38,0x70,0x00,0x00,
 0x00,0x00,0x10,0x30,0x3C,0x1F,0x00,0x1F,0x3F,0x31,0x30,0x30,0x37,0x37,0x30,0x38,
 0x3E,0x18,0x01,0x02,0x0E,0x1C,0x18,0x00,       //"您"
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};  

const uch col[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};//列码

//初始化子程序
void init()
{
 ADCON1=0x06;//初始化RA口为普通数字端口
 TRISA=0X20;
 PORTA=0;
 TRISB=0;
 PORTB=0;
 TRISC=0;
 PORTC=0;
 TRISD=0;
 PORTD=0;
}

//延时子程序
void delay1ms()
{
 uch i;

 for(i=0;i<150;i++)
 { NOP();
 }
}

//从右往左显示
void display1()
{
 uch i,j,k,t,n;
 int m=0;//字符定位变量
 for(n=0;n<6;n++)
 {
  for(offset=0;offset<24;offset++)//偏置最多24位
  {
  for(t=0;t<4;t++)//每个位置显示4次
  {
  for(i=0;i<24;i++)//取数，每行24列，故取24个数
  {
   PORTD=0xff;//一开始先把列置高电平，关显示
   PORTC=0x70;
   NOP();
   PORTC=0;
   
   PORTB=zxhn[i+offset+m];//取行码
   if((i+offset)>23)PORTB=zxhn[i+offset+48+m];
   RC0=1;
   NOP();
   RC0=0;

   PORTB=zxhn[i+24+offset+m];
   if((i+offset)>23)PORTB=zxhn[i+offset+72+m];
   RC1=1;
   NOP();
   RC1=0;

   PORTB=zxhn[i+48+offset+m];
   if((i+offset)>23)PORTB=zxhn[i+offset+96+m];
   RC2=1;
   NOP();
   RC2=0;

   j=i/8;//求需要选通的行线

   k=i%8;//求需要选通的列线

   PORTD=col[k];
   switch(j)
   {
    case 0:  RC4=1; NOP(); RC4=0; break;
    case 1:  RC5=1; NOP(); RC5=0; break;
    case 2:  RC6=1; NOP(); RC6=0; break;
   }
   delay1ms(); //视觉暂留 
  }
  }
  }
 m=m+72;//定位下一个初始字符
 }
}

//从左往右显示
void display2()
{
 uch i,j,k,t,n,tt1,tt2,tt3;
 int m=0;//字符定位变量
 for(n=0;n<6;n++)
 {
  for(offset=24;offset>0;offset--)//偏置最多24位
  {
  for(t=0;t<4;t++)//每个位置显示4次
  {
  for(i=24;i>0;i--)//取数，每行24列，故取24个数
  {
   if((i+offset)>23)
   {
    tt1=zxhn[i+offset-24+m];
    tt2=zxhn[i+offset+m];
    tt3=zxhn[i+offset+24+m];
   }
   else
   {
    tt1=zxhn[i+offset+m+72];
    tt2=zxhn[i+offset+m+96];
    tt3=zxhn[i+120+offset+m];
   }
   
   PORTD=0xff;//一开始先把列置高电平，关显示
   PORTC=0x70;
   NOP();
   PORTC=0;
   
   PORTB=tt1;  //取行码
   RC0=1;
   NOP();
   RC0=0;
   PORTB=tt2;
   RC1=1;
   NOP();
   RC1=0;
   PORTB=tt3;
   RC2=1;
   NOP();
   RC2=0;

   j=(i-1)/8;//求需要选通的373
   k=(i-1)%8;//求需要选通的列线

   PORTD=col[k];
   switch(j)
   {
    case 0:  RC4=1; NOP(); RC4=0; break;
    case 1:  RC5=1; NOP(); RC5=0; break;
    case 2:  RC6=1; NOP(); RC6=0; break;
   }
   delay1ms(); //视觉暂留 
  }
  }
  }
 m=m+72;
 }
}

//从下往上显示
void display3()
{
 uch i,j,k,t,n,tt1,tt2,tt3,l;
 int m=0;//字符定位变量
 for(n=0;n<18;n++)
 {
  for(l=0;l<7;l++)//滚动8位
  {
  for(t=0;t<3;t++)//每个位置显示4次
  {
  for(i=0;i<24;i++)//取数，每行24列，故取24个数
  {
   tt1=(zxhn[i+m]>>l)|(zxhn[i+24+m]<<(8-l));
   tt2=(zxhn[i+24+m]>>l)|(zxhn[i+48+m]<<(8-l));
   tt3=(zxhn[i+48+m]>>l)|(zxhn[i+72+m]<<(8-l));
   
   PORTD=0xff;//一开始先把列置高电平，关显示
   PORTC=0x70;
   NOP();
   PORTC=0;
   
   PORTB=tt1;  //取行码
   RC0=1;
   NOP();
   RC0=0;
   PORTB=tt2;
   RC1=1;
   NOP();
   RC1=0;
   PORTB=tt3;
   RC2=1;
   NOP();
   RC2=0;

   j=i/8;//求需要选通的373
   k=i%8;//求需要选通的列线

   PORTD=col[k];
   switch(j)
   {
    case 0:  RC4=1; NOP(); RC4=0; break;
    case 1:  RC5=1; NOP(); RC5=0; break;
    case 2:  RC6=1; NOP(); RC6=0; break;
   }
   delay1ms(); //视觉暂留 
  }
  }
  }
 m=m+24;
 }
}

//从上往下显示
void display4()
{
 uch i,j,k,t,n,tt1,tt2,tt3,l,a,b;
 int m=0;//字符定位变量
 for(n=0;n<6;n++)
 {
  for(l=0;l<24;l++)
  {
  for(t=0;t<3;t++)//每个位置显示4次
  {
  for(i=0;i<24;i++)//取数，每行24列，故取24个数
  {
   a=l/8;
   b=l%8;
   if(a==0)
   {
   tt1=(zxhn[i+m]<<b)|(zxhn[i+120+m]>>(8-b));
   tt2=(zxhn[i+24+m]<<b)|(zxhn[i+m]>>(8-b));
   tt3=(zxhn[i+48+m]<<b)|(zxhn[i+24+m]>>(8-b));
   }
   if(a==1)
   {
   tt1=(zxhn[i+m+120]<<b)|(zxhn[i+96+m]>>(8-b));
   tt2=(zxhn[i+m]<<b)|(zxhn[i+m+120]>>(8-b));
   tt3=(zxhn[i+24+m]<<b)|(zxhn[i+m]>>(8-b));
   }
   if(a==2)
   {
   tt1=(zxhn[i+m+96]<<b)|(zxhn[i+72+m]>>(8-b));
   tt2=(zxhn[i+m+120]<<b)|(zxhn[i+96+m]>>(8-b));
   tt3=(zxhn[i+m]<<b)|(zxhn[i+m+120]>>(8-b));
   }
   
   PORTD=0xff;//一开始先把列置高电平，关显示
   PORTC=0x70;
   NOP();
   PORTC=0;
   
   PORTB=tt1;  //取行码
   RC0=1;
   NOP();
   RC0=0;
   PORTB=tt2;
   RC1=1;
   NOP();
   RC1=0;
   PORTB=tt3;
   RC2=1;
   NOP();
   RC2=0;

   j=i/8;//求需要选通的行线
   k=i%8;//求需要选通的列线

   PORTD=col[k];
   switch(j)
   {
    case 0:  RC4=1; NOP(); RC4=0; break;
    case 1:  RC5=1; NOP(); RC5=0; break;
    case 2:  RC6=1; NOP(); RC6=0; break;
   }
   delay1ms(); //视觉暂留 
  }
  }
  }
 m=m+72;
 }
}

void main()
{
 uch mo;
 init();
 while(1)
 {
  display1();
  display2();
  display3();
  display4();
 }
}

三.总结

虽然已有四种方式显示了,但我觉得可以尝试更多的方式,例如,可以象滚轮子一样,旋转着从左滚到右显示,只是数据处理的量可能大了些,已经有两个自由度了,而我的四种只有一个自由度.由于本人水平有限,没有想到什么好的思路,不过希望抛砖引玉,写出这种显示方式.

    最近工作需要,要控制直流电机的转速,以前没有做过类似的项目,查了好多东西,终于鼓捣出一个,实际效果还可以,现在仿真出来,供大家参考,如有更好的建议也可以告诉我.

原理图如下

我简要说明一下

1.电源部分:

220伏交流经整流,再经过R3的降压和D10的稳压,提供一个和电网电压频率一样的同步信号.这一路再经过7815,提供控制电路部分的直流电源+15V.

2.电机控制部分

AC220V经整流出来经过一个可控硅和电机串联接入回路,通过控制可控硅的通断频率来控制电机的通断,从而控制了转速,这里D7的主要作用就是在电机线圈不通电的时候,把多余的能量释放掉.

3.控制部分

主要通过控制程控管Q3的通断,来产生一定平率的脉冲,通过光偶加到可控硅的门极,从而控制电机速度.

控制程控管的信号主要有三个:1.电压给定信号,通过调节R4,R5,R6三个电位器给定一个电压信号,中间一个也是一个调速的旋钮.2.同步信号,当电网电压过零点时,5处会产生一个0电压信号,使C7通过Q1放电,等待下一个周期来临.

3.反馈信号,从电机线圈端采样反馈到程控管的控制极,使输出信号更加平稳.程控管开通的长短有C7决定.

仿真输出波形图1:

调速旋钮R5改变一以后:

 红色为电机线圈端的波形,绿色为程控管正极的波形.

从波形来看,调速效果还可以,达到预想的效果

以下为自己做的实验板:

因为最近自己想开发一款产品,但芯片比较贵,我就试着去免费申请,结果真的拿到了.现在我把可以申请免费样片的网址都罗列出来,希望和我一样有心没钱的人也能享受开发的乐趣.

1、推荐铁电存储器（未见量的限制,据说最多有人申请了100片，不知真假.）

介绍：铁电存储器（FRAM）产品将ROM的非易失性数据存储特性和RAM的无限次读写、高速读写以及低功耗等优势结合在一起。FRAM产品包括各种接口和多种密度，像工业标准的串行和并行接口，工业标准的封装类型，以及4Kbit、6Kbit、64Kbit、256Kbit和1Mbit等密度。

申请地址：http://www.huazhoucn.com/mianfei.aspx

申请注意：填写好企业、姓名等内容，不然可能收不到。当然可以多几个人申请，嘿嘿

2、VK系列UART（一次最多2片）

介绍：维肯公司主要提供集成电路，射频电子标签读卡模块,医疗电子产品,汽车电子产品等在类的电子产品和整体解决方案。

申请地址：http://www.vkic.com/usermanage/login.asp

申请注意：属企业级的申请，要填正确公司、姓名、联系方式。

3、ADI公司（最多索取3种产品，每种2片）

介绍：ADI含几乎所有的模拟器件产品。

申请地址：http://www.analog.com/intl/china/orderSamples/

4、Maxim公司（最多索取3种产品，每种2片）

介绍：Maxim公司免费提供Maxim/Dallas样品，以方便您评估测试其性能之用。

申请地址：http://www.maxim-ic.com.cn/samples/

申请注意：需填写该表格中的“最终产品”和“预计年用量” 两项内容

5、Microchip Technology Inc（最多索取5种，每种1片）

介绍：单片机和模拟半导体供应商

申请地址：http://sample.microchip.com/Default.aspx?testCookies=true

申请注意：时间较长，2个星期

6、TI（(最多提供 8 种不同型号的器件样片) ）

介绍：模拟和 DSP 技术

申请地址：http://focus.ti.com.cn/cn/general/docs/gencontent.tsp?contentId=29859&DCMP=TI-cn_Home_Tracking&HQS=v?

OT+home_b_samples

申请注意：在申请前组织下运用

7、成都国腾

介绍：IC接口类、IC电源类、IC存储类、IC消费类、IC其它产品、IP类、IC通讯类

申请地址：http://www.gticc.com/cn/khfw-ypsq1.htm

8、南京沁恒

介绍：涵盖电子电路、单片机和DSP、可编程器件、计算机硬件体系构架、计算机BIOS和系统软件

申请地址：http://www.wch.cn/technique/index2.asp

申请注意：客户需自付快递运费

9、飞思卡尔

申请地址：http://www.freescale.com/webapp/sps/site/homepage.jsp?nodeId=010984007869597059286929489

10、美国微芯科技公司

介绍：以太网控制器

申请地址：http://www.skyhic.com/

11、北天星

介绍：ATMEL、RAMTRON、ALLIANCE、TAISOL、ATCHIP、UTC、ESI、VIMICRO、Philips、MXIC、ST等原厂的各种芯片样品

申请地址：http://www.po-star.

12、深圳市英蓓特信息技术有限公司

介绍：嵌入式开发

申请地址：http://www.embed.com.cn/yangpian/index.asp?company_id=5089

注意：邮资自付

13、润金法

介绍：单片机

申请地址：http://www.ic365.com.cn/asp/apply.asp

注意：向企业，个人有些困难

14、双龙电子

介绍：SUNSHINE（编程器）、HILO（编程器/仿真器）、MICROTEK（仿真器）、ADVANTECH（编程器）、LEAP（编程器）、XELTEK（编程器）、

ENPLAS（Seckt）、3M（Socket）、CHIPTOOL（Socket）、ATMEL AVR（仿真器）

申请地址：http://www.sl.com.cn/

15、杭州利尔达科技

介绍：TI、ROHM、SIPEX、CATALYST、RAINSUN 等诸多国际著名半导体产品

申请地址：http://www.lierda.com/

16、泰仁发

介绍：单片机

申请地址：http://www.tairenfa.com/apply.htm

17、丹特公司

介绍：功率转换和电力存储系统

申请地址：http://www.dionics-usa.com/sample_req_form.htmhttp://www.mcu-memory.comcom/sample.asp

电容滤波电路 ★滤波原理 ◆当u2为正半周并且数值大于电容两端电压uC时，二极管D1和D3管导通，D2和D4管截止，电流一路流经负载电阻RL，另一路对电容C充电。当uC>u2，导致D1和D3管反向偏置而截止，电容通过负载电阻RL放电，uC按指数规律缓慢下降。 ◆当u2为负半周幅值变化到恰好大于uC时，D2和D4因加正向电压变为导通状态，u2再次对C充电，uC上升到u2的峰值后又开始下降；下降到一定数值时D2和D4变为截止，C对RL放电，uC按指数规律下降；放电到一定数值时D1和D3变为导通，重复上述过程。 RL、C对充放电的影响： 电容充电时间常数为rDC，充电速度快；RLC为放电时间常数，放电速度慢。电容C愈大，负载电阻RL愈大，滤波后输出电压愈平滑，并且其平均值愈大。 　　★输出电压平均值 ◆当负载开路，即 时， ； ◆当RLC=(3~5)T/2时，可取得较好的滤波效果， 。 考虑电网电压波动范围为±10％，电容的耐压值应大于 。 　　★脉动系数 ★整流二极管的导通角 ◆在未加滤波电容之前，整流电路中的二极管导通角θ为π。 ◆加滤波电容后，只有当电容充电时，二极管才导通，因此，每只二极管的导通角均小于π。 RLC的值愈大，滤波效果愈好，导通角θ将愈小。整流二极管承的冲击电流大。 ★电容滤波电路的输出特性和滤波特性 输出特性：当滤波电容C选定后，输出电压平均值UO(AV)和输出电流平均值IO(AV)的关系称为输出特性。 滤波特性：脉动系数S和输出电流平均值IO(AV)的关系称为滤波特性。如下图所示，曲线表明，C愈大电路带负载能力愈强，滤波效果愈好；IO(AV)愈大（即负载电阻RL愈小），UO(AV)愈低，S的值愈大。 小结：电容滤波电路简单，输出电压平均值高，适用于负载电流较小且其变化也较小的场合。 倍压整流电路 倍压整流电路：利用滤波电容的存储作用，由多个电容和二极管可以获得几倍于变压器副边电压的输出电压，称为倍压整流电路。 利用压整流电路可实现二倍压和多倍压。 其它形式的滤波电路 ★电感滤波电路 电感滤波后，不但负载电流及电压的脉动减小，波形变得平滑，而且整流二极管的导通角增大。L愈大，滤波效果愈好。另外，由于滤波电感电动势的作用，可以使二极管的导通角接近π，减小了二极管的冲击电流，平滑了流过二极管的电流，从而延长了整流二极管的寿命。 ★复式滤波电路 当单独使用电容或电感进行滤波时，效果仍不理想时，可采用复式滤波电路。 ★各种滤波电路的比较 各种滤波电路性能的比较 类型 性能 电容滤波 电感滤波 LC滤波 RC或LCπ型滤波 UL(AV)/U2 1.2 0.9 0.9 1.2 θ 小 大 大 小 适用场合 小电流负载 大电流负载 适应性较强 小电流负载

    一直因为工作太忙的缘故,没有把我的万年历程序修改,相信看过我博客的都清楚,原先的虽然有公历转农历的功能,但是不正确,经过热心网友帮助后,终于修改成功了,具有了日期查询的功能,现在把公历转换农历与星期的程序贴出来,给需要的人参考.

    /***************************************************
* 标题：公历与阴历、星期转换                    *
* 作者：Wujieflash                                      *
* 日期：2008年1月18日                              *
* 说明：阴历日期与星期随公历变化            *
***************************************************/
static unsigned char const year_code[]={
0x04,0xAe,0x53, //1901 0
0x0A,0x57,0x48, //1902 3
0x55,0x26,0xBd, //1903 6
0x0d,0x26,0x50, //1904 9
0x0d,0x95,0x44, //1905 12
0x46,0xAA,0xB9, //1906 15
0x05,0x6A,0x4d, //1907 18
0x09,0xAd,0x42, //1908 21
0x24,0xAe,0xB6, //1909
0x04,0xAe,0x4A, //1910
0x6A,0x4d,0xBe, //1911
0x0A,0x4d,0x52, //1912
0x0d,0x25,0x46, //1913
0x5d,0x52,0xBA, //1914
0x0B,0x54,0x4e, //1915
0x0d,0x6A,0x43, //1916
0x29,0x6d,0x37, //1917
0x09,0x5B,0x4B, //1918
0x74,0x9B,0xC1, //1919
0x04,0x97,0x54, //1920
0x0A,0x4B,0x48, //1921
0x5B,0x25,0xBC, //1922
0x06,0xA5,0x50, //1923
0x06,0xd4,0x45, //1924
0x4A,0xdA,0xB8, //1925
0x02,0xB6,0x4d, //1926
0x09,0x57,0x42, //1927
0x24,0x97,0xB7, //1928
0x04,0x97,0x4A, //1929
0x66,0x4B,0x3e, //1930
0x0d,0x4A,0x51, //1931
0x0e,0xA5,0x46, //1932
0x56,0xd4,0xBA, //1933
0x05,0xAd,0x4e, //1934
0x02,0xB6,0x44, //1935
0x39,0x37,0x38, //1936
0x09,0x2e,0x4B, //1937
0x7C,0x96,0xBf, //1938
0x0C,0x95,0x53, //1939
0x0d,0x4A,0x48, //1940
0x6d,0xA5,0x3B, //1941
0x0B,0x55,0x4f, //1942
0x05,0x6A,0x45, //1943
0x4A,0xAd,0xB9, //1944
0x02,0x5d,0x4d, //1945
0x09,0x2d,0x42, //1946
0x2C,0x95,0xB6, //1947
0x0A,0x95,0x4A, //1948
0x7B,0x4A,0xBd, //1949
0x06,0xCA,0x51, //1950
0x0B,0x55,0x46, //1951
0x55,0x5A,0xBB, //1952
0x04,0xdA,0x4e, //1953
0x0A,0x5B,0x43, //1954
0x35,0x2B,0xB8, //1955
0x05,0x2B,0x4C, //1956
0x8A,0x95,0x3f, //1957
0x0e,0x95,0x52, //1958
0x06,0xAA,0x48, //1959
0x7A,0xd5,0x3C, //1960
0x0A,0xB5,0x4f, //1961
0x04,0xB6,0x45, //1962
0x4A,0x57,0x39, //1963
0x0A,0x57,0x4d, //1964
0x05,0x26,0x42, //1965
0x3e,0x93,0x35, //1966
0x0d,0x95,0x49, //1967
0x75,0xAA,0xBe, //1968
0x05,0x6A,0x51, //1969
0x09,0x6d,0x46, //1970
0x54,0xAe,0xBB, //1971
0x04,0xAd,0x4f, //1972
0x0A,0x4d,0x43, //1973
0x4d,0x26,0xB7, //1974
0x0d,0x25,0x4B, //1975
0x8d,0x52,0xBf, //1976
0x0B,0x54,0x52, //1977
0x0B,0x6A,0x47, //1978
0x69,0x6d,0x3C, //1979
0x09,0x5B,0x50, //1980
0x04,0x9B,0x45, //1981
0x4A,0x4B,0xB9, //1982
0x0A,0x4B,0x4d, //1983
0xAB,0x25,0xC2, //1984
0x06,0xA5,0x54, //1985
0x06,0xd4,0x49, //1986
0x6A,0xdA,0x3d, //1987
0x0A,0xB6,0x51, //1988
0x09,0x37,0x46, //1989
0x54,0x97,0xBB, //1990
0x04,0x97,0x4f, //1991
0x06,0x4B,0x44, //1992
0x36,0xA5,0x37, //1993
0x0e,0xA5,0x4A, //1994
0x86,0xB2,0xBf, //1995
0x05,0xAC,0x53, //1996
0x0A,0xB6,0x47, //1997
0x59,0x36,0xBC, //1998
0x09,0x2e,0x50, //1999 294
0x0C,0x96,0x45, //2000 297
0x4d,0x4A,0xB8, //2001
0x0d,0x4A,0x4C, //2002
0x0d,0xA5,0x41, //2003
0x25,0xAA,0xB6, //2004
0x05,0x6A,0x49, //2005
0x7A,0xAd,0xBd, //2006
0x02,0x5d,0x52, //2007
0x09,0x2d,0x47, //2008
0x5C,0x95,0xBA, //2009
0x0A,0x95,0x4e, //2010
0x0B,0x4A,0x43, //2011
0x4B,0x55,0x37, //2012
0x0A,0xd5,0x4A, //2013
0x95,0x5A,0xBf, //2014
0x04,0xBA,0x53, //2015
0x0A,0x5B,0x48, //2016
0x65,0x2B,0xBC, //2017
0x05,0x2B,0x50, //2018
0x0A,0x93,0x45, //2019
0x47,0x4A,0xB9, //2020
0x06,0xAA,0x4C, //2021
0x0A,0xd5,0x41, //2022
0x24,0xdA,0xB6, //2023
0x04,0xB6,0x4A, //2024
0x69,0x57,0x3d, //2025
0x0A,0x4e,0x51, //2026
0x0d,0x26,0x46, //2027
0x5e,0x93,0x3A, //2028
0x0d,0x53,0x4d, //2029
0x05,0xAA,0x43, //2030
0x36,0xB5,0x37, //2031
0x09,0x6d,0x4B, //2032
0xB4,0xAe,0xBf, //2033
0x04,0xAd,0x53, //2034
0x0A,0x4d,0x48, //2035
0x6d,0x25,0xBC, //2036
0x0d,0x25,0x4f, //2037
0x0d,0x52,0x44, //2038
0x5d,0xAA,0x38, //2039
0x0B,0x5A,0x4C, //2040
0x05,0x6d,0x41, //2041
0x24,0xAd,0xB6, //2042
0x04,0x9B,0x4A, //2043
0x7A,0x4B,0xBe, //2044
0x0A,0x4B,0x51, //2045
0x0A,0xA5,0x46, //2046
0x5B,0x52,0xBA, //2047
0x06,0xd2,0x4e, //2048
0x0A,0xdA,0x42, //2049
0x35,0x5B,0x37, //2050
0x09,0x37,0x4B, //2051
0x84,0x97,0xC1, //2052
0x04,0x97,0x53, //2053
0x06,0x4B,0x48, //2054
0x66,0xA5,0x3C, //2055
0x0e,0xA5,0x4f, //2056
0x06,0xB2,0x44, //2057
0x4A,0xB6,0x38, //2058
0x0A,0xAe,0x4C, //2059
0x09,0x2e,0x42, //2060
0x3C,0x97,0x35, //2061
0x0C,0x96,0x49, //2062
0x7d,0x4A,0xBd, //2063
0x0d,0x4A,0x51, //2064
0x0d,0xA5,0x45, //2065
0x55,0xAA,0xBA, //2066
0x05,0x6A,0x4e, //2067
0x0A,0x6d,0x43, //2068
0x45,0x2e,0xB7, //2069
0x05,0x2d,0x4B, //2070
0x8A,0x95,0xBf, //2071
0x0A,0x95,0x53, //2072
0x0B,0x4A,0x47, //2073
0x6B,0x55,0x3B, //2074
0x0A,0xd5,0x4f, //2075
0x05,0x5A,0x45, //2076
0x4A,0x5d,0x38, //2077
0x0A,0x5B,0x4C, //2078
0x05,0x2B,0x42, //2079
0x3A,0x93,0xB6, //2080
0x06,0x93,0x49, //2081
0x77,0x29,0xBd, //2082
0x06,0xAA,0x51, //2083
0x0A,0xd5,0x46, //2084
0x54,0xdA,0xBA, //2085
0x04,0xB6,0x4e, //2086
0x0A,0x57,0x43, //2087
0x45,0x27,0x38, //2088
0x0d,0x26,0x4A, //2089
0x8e,0x93,0x3e, //2090
0x0d,0x52,0x52, //2091
0x0d,0xAA,0x47, //2092
0x66,0xB5,0x3B, //2093
0x05,0x6d,0x4f, //2094
0x04,0xAe,0x45, //2095
0x4A,0x4e,0xB9, //2096
0x0A,0x4d,0x4C, //2097
0x0d,0x15,0x41, //2098
0x2d,0x92,0xB5, //2099
};

//月份数据表
static unsigned char  const day_code1[9]={0x0,0x1f,0x3b,0x5a,0x78,0x97,0xb5,0xd4,0xf3};
static unsigned short const day_code2[3]={0x111,0x130,0x14e};
/****************************************************************************
* 子函数,用于读取数据表中农历月的大月或小月,如果该月为大返回1,为小返回0
****************************************************************************/
static unsigned char GetMoonDay(unsigned char month_p,unsigned short table_addr)
{
 switch (month_p)
 {
  case 1:
   if((year_code[table_addr]&0x08)==0) return(0);
   else         return(1);
  case 2:
   if((year_code[table_addr]&0x04)==0) return(0);
   else         return(1);
  case 3:
   if((year_code[table_addr]&0x02)==0) return(0);
   else         return(1);
  case 4:
   if((year_code[table_addr]&0x01)==0) return(0);
   else         return(1);
  case 5:
   if((year_code[table_addr+1]&0x80)==0) return(0);
   else          return(1);
  case 6:
   if((year_code[table_addr+1]&0x40)==0) return(0);
   else          return(1);
  case 7:
   if((year_code[table_addr+1]&0x20)==0) return(0);
   else          return(1);
  case 8:
   if((year_code[table_addr+1]&0x10)==0) return(0);
   else          return(1);
  case 9:
   if((year_code[table_addr+1]&0x08)==0) return(0);
   else          return(1);
  case 10:
   if((year_code[table_addr+1]&0x04)==0) return(0);
   else          return(1);
  case 11:
   if((year_code[table_addr+1]&0x02)==0) return(0);
   else          return(1);
  case 12:
   if((year_code[table_addr+1]&0x01)==0) return(0);
   else          return(1);
  case 13:
   if((year_code[table_addr+2]&0x80)==0) return(0);
   else          return(1);
 }
 return(0);
}

/*********************************************************************************************************
** 函数名称:GetChinaCalendar
** 功能描述:公农历转换(只允许1901-2099年)
** 输　入:  year        公历年
**          month       公历月
**          day         公历日
**          p           储存农历日期地址
** 输　出:  1           成功
**          0           失败
** 作　者:  Campo
** 修  改:  赖皮
** 日　期:  2007年02月06日
**-------------------------------------------------------------------------------------------------------
** 修改人:
** 日　期:
**------------------------------------------------------------------------------------------------------
********************************************************************************************************/
unsigned char GetChinaCalendar(
        unsigned int  year, 
        unsigned char month,
        unsigned char day,
        unsigned char *p)
{
 unsigned char temp1,temp2,temp3,month_p,yearH,yearL; 
 unsigned char flag_y;
 unsigned short temp4,table_addr;

 yearH=year/100; yearL=year%100;
 if((yearH!=19)&&(yearH!=20)) return(0);
 
 // 定位数据表地址
 if(yearH==20) table_addr=(yearL+100-1)*3;
 else     table_addr=(yearL-1)*3;

 // 取当年春节所在的公历月份/
 temp1=year_code[table_addr+2]&0x60; 
 temp1>>=5;

 // 取当年春节所在的公历日
 temp2=year_code[table_addr+2]&31;

 // 计算当年春年离当年元旦的天数,春节只会在公历1月或2月 */
 if(temp1==1)  temp3=temp2-1;
 else    temp3=temp2+31-1;

 // 计算公历日离当年元旦的天数
 if (month<10)  temp4=day_code1[month-1]+day-1;
 else     temp4=day_code2[month-10]+day-1;
 // 如果公历月大于2月并且该年的2月为闰月,天数加1
 if ((month>2)&&(yearL%4==0))  temp4++;

 // 判断公历日在春节前还是春节后 */
 if (temp4>=temp3)
 {       
  temp4-=temp3;
  month=1;
  month_p=1;
       
  flag_y=0;
  if(GetMoonDay(month_p,table_addr)==0) temp1=29; //小月29天
  else          temp1=30; //大小30天
  // 从数据表中取该年的闰月月份,如为0则该年无闰月 */
  temp2=year_code[table_addr]/16;  
  while(temp4>=temp1)
  {
   temp4-=temp1;
   month_p++;
   if(month==temp2)
   {
    flag_y=~flag_y;
    if(flag_y==0)month++;
   }
   else month++;
   if(GetMoonDay(month_p,table_addr)==0) temp1=29;
   else          temp1=30;
  }
  day=temp4+1;
 }
 // 公历日在春节前使用下面代码进行运算 */
 else
 {       
  temp3-=temp4;
  if (yearL==0)
  {
   yearL=100-1;
   yearH=19;
  }
  else yearL--;
  table_addr-=3;
  month=12;
  temp2=year_code[table_addr]/16;  
  if (temp2==0) month_p=12;
  else    month_p=13;

  flag_y=0;
  if(GetMoonDay(month_p,table_addr)==0) temp1=29;
  else          temp1=30;
  while(temp3>temp1)
  {
   temp3-=temp1;
   month_p--;
   if(flag_y==0)  month--;
   if(month==temp2) flag_y=~flag_y;
   if(GetMoonDay(month_p,table_addr)==0) temp1=29;
   else          temp1=30;
  }
  day=temp1-temp3+1;
 }

 *p++=yearH;
 *p++=yearL;
 *p++=month;
 *p=day; 
 return(1);
}

static unsigned char const table_week[12]={0,3,3,6,1,4,6,2,5,0,3,5}; //月修正数据表
/*********************************************************************************************************
** 函数名称:GetWeek
** 功能描述:输入公历日期得到星期(只允许1901-2099年)
** 输　入:  year        公历年
**          month       公历月
**          day         公历日
**          p           储存星期地址
** 输　出:  无
** 作　者:  Campo
** 修  改:  赖皮
** 日　期:  2007年02月06日
**-------------------------------------------------------------------------------------------------------
** 修改人:
** 日　期:
**------------------------------------------------------------------------------------------------------
********************************************************************************************************/
void GetWeek(
   unsigned int year,
   unsigned char month,
   unsigned char day,
   unsigned char *p)
{ 
 unsigned int temp2;
 unsigned char yearH,yearL;
 
 yearH=year/100; yearL=year%100;
 
 // 如果为21世纪,年份数加100 */
 if (yearH>19)   yearL+=100;
 // 所过闰年数只算1900年之后的 */
 temp2=yearL+yearL/4;
 temp2=temp2%7;
 temp2=temp2+day+table_week[month-1];
 if (yearL%4==0&&month<3) temp2--;
 *p=(temp2%7);
}

/*********************************************************************************************************

上面的程序已经得到过验证,是没有问题的,希望抛砖引玉.

       本来我一直以为只要学会了一种液晶控制器,就够了,所以我一直使用的是KS0108,但最近有网友让我写一个液晶串行驱动.我想了一下,的确有必要,因为他的最大优点在于他省了很多端口.所以,我找到SED1565系列(和ST7565差不多)尝试写了个驱动,以回馈网友,并用PROTEUS软件仿真通过,我想实际也基本可以用的.

一,原理图

芯片的接线很少,只使用了四个口,实际的液晶端口很多,但串行只用这四个就够了.

如液晶资料上说的,当P/S端接低电平时为串口模式.

串行传输时的时序如下所示:

所以CS2端口可以不用,一直接高电平.A0是指示输入的是数据或是命令,高电平为数据,低电平为命令.

在时钟上升沿时,数据输入.

二.程序(PICC8.05)

/***********************************************
* 标题：SED1565图形LCD模块驱动                 * 
* 作者：Flashbird                              *
* 日期：2008.03.16                             *
* 版本：ZHX1.0                                 *
* 说明：所用单片机为PIC16F877A                 *
***********************************************/
#include <pic.h>

#define NOP() asm("nop")
#define SI    RB0  
#define SCL   RB1  
#define A0    RB2  
#define CS1   RB3  
#define uch   unsigned char

/**********************************************
* 函数：SerialInputByte(uch dat)              *
* 描述：从SI口串行输入8位数据                 *
**********************************************/
void SerialInputByte(uch dat)
{
 uch i;
 for(i=0;i<8;i++)
 {
  if(dat&0x80)SI=1;
  else SI=0;
  SCL=0;            //上升沿有效
  NOP();
  SCL=1;
  dat=dat<<1;
 }
}

/**********************************************
* 函数：WriteData(uch dat)                    *
* 描述：从SI口串行输入要显示的数据            *
**********************************************/ 
void WriteData(uch dat)
{
 CS1=0;
 A0=1;                 //写数据
 SerialInputByte(dat);
 CS1=1;
}

/**********************************************
* 函数：WriteCommand(uch cmd)                 *
* 描述：从SI口串行输入命令                    *
**********************************************/ 
void WriteCommand(uch cmd)
{
 CS1=0;
 A0=0;                 //写命令
 SerialInputByte(cmd);
 CS1=1;
}

/**********************************************
* 函数：ClearScreen()                         *
* 描述：清屏                                  *
**********************************************/ 
void ClearScreen()
{
 uch i,j;
 for(i=0;i<8;i++)
 {
  WriteCommand(0xb0+i);
  WriteCommand(0x10);
  WriteCommand(0x0);
  for(j=0;j<132;j++)
  {
   WriteData(0x00);
  }
 }
}

/**********************************************
* 函数：SetLine(uch line)                     *
* 描述：设定页地址----X:0--7                  *
**********************************************/ 
void SetLine(uch line)
{
 line=line&0x07;               //0<=line<=7 
 line=line|0xb0;
 WriteCommand(line);
}

/**********************************************
* 函数：SetColumn(uch column)                 *
* 描述：设定列地址----Y:0--127                *
**********************************************/
void SetColumn(uch column)
{
 uch column_h,column_l;
 column=column&0x7f;          //0<=column<=127
 column_h=column&0x0f0;       //列地址高四位
 column_h=column>>4;
 column_l=column&0x0f;        //列地址低四位
 column_h=column_h|0x10;
 column_l=column_l|0x00;
 WriteCommand(column_h);
 WriteCommand(column_l);
}

/**********************************************
* 函数：SetOnOff(uch state)             *
* 描述：开关显示  1:开显示  0:关显示 *
**********************************************/
void SetOnOff(uch state)
{
 state=state|0xae;
 WriteCommand(state);
}

/*****************************************************
* 函数：Show16X16(uch line,uch comlon,const uch *pt) *
* 描述：显示一个16X16的汉字                                        *
*       line:显示的页（0--7）                                             *
*       column:显示的列（0--127）                                   *
*       *pt:显示字的首地址                                                 *
*****************************************************/
void Show16X16(uch line,uch column,const uch *pt)
{
 uch i,column_temp;
 WriteCommand(0xa1);                  //反向显示(即从左到右显示)
 column_temp=column;
 SetColumn(column);                   //设置起始列
 SetLine(line);                       //设置行
 for(i=0;i<16;i++)
 {  
  WriteData(*pt);                  //写数据
  *pt++;//
  column++;
 }
 SetLine(line+1);                    //设置汉字下半部分显示页
 column=column_temp;
 SetColumn(column);
 for(i=0;i<16;i++)
 { 
  WriteData(*pt);
  *pt++;
  column++;
 }
}
//以下为测试程序
/**********************************************
* 函数：Init()                                      *
* 描述：端口初始化                            *
**********************************************/ 
void init()
{
 TRISB=0;
 PORTB=0;
}

//字库
const uch huan[]=
{0x14,0x24,0x44,0x84,0x64,0x1C,0x20,0x18,0x0F,0xE8,0x08,0x08,0x28,0x18,0x08,0x00,
 0x20,0x10,0x4C,0x43,0x43,0x2C,0x20,0x10,0x0C,0x03,0x06,0x18,0x30,0x60,0x20,0x00};/*"欢",0*/
const uch ying[]=
{0x40,0x41,0xCE,0x04,0x00,0xFC,0x04,0x02,0x02,0xFC,0x04,0x04,0x04,0xFC,0x00,0x00,
 0x40,0x20,0x1F,0x20,0x40,0x47,0x42,0x41,0x40,0x5F,0x40,0x42,0x44,0x43,0x40,0x00};/*"迎",1*/
const uch fang[]=
{0x40,0x41,0x4E,0xC4,0x00,0x08,0x08,0x08,0x09,0xFE,0x4A,0x48,0x48,0xC8,0x08,0x00,
 0x00,0x00,0x00,0x3F,0x10,0x48,0x20,0x18,0x07,0x00,0x20,0x60,0x20,0x1F,0x00,0x00};/*"访",2*/
const uch wen[]=
{0x00,0x00,0xF8,0x01,0x06,0xE0,0x22,0x22,0x22,0x22,0xE2,0x02,0x02,0xFE,0x00,0x00,
 0x00,0x00,0xFF,0x00,0x00,0x03,0x02,0x02,0x02,0x02,0x03,0x40,0x80,0x7F,0x00,0x00};/*"问",3*/

//滚动显示“欢迎访问”
void test()
{
 int i;
 uch set=0;
 uch column=32;
 while(1)
 {
  Show16X16(3,column,huan);
  Show16X16(3,column+16,ying);
  Show16X16(3,column+32,fang);
  Show16X16(3,column+48,wen);
  for(i=0;i<4000;i++);
  if(set==0)column--;
  if(set==1)
  {
   column++;
   SetColumn(column-1);
   SetLine(3);
   WriteData(0);           //擦除前面显示的数据
   SetColumn(column-1);
   SetLine(4);
   WriteData(0);           //擦除前面显示的数据
  }
  if(column==0)set=1;         //如果到最左，就往右移
  if((column+48)==111)set=0;  //如果到最右，就往左移
 }
}

void main()
{
 init();
 while(1)
 {
  test(32);
 }
}
三.总结

由于前段时间太忙,让网友久等了,谢谢他对我的支持,如有不对的地方,请指出,共同探讨.    

       最近由于工作的调整,开始接触三菱PLC.但是我们公司只有一根编程电缆,但用的人很多,插来拔去实在很麻烦,买买又很贵,所以查了好多资料,决定自己用现有的RS232线改制,下面是接线图.

几点需要说明:

1.RS232,RS422均是全双工通讯,只是电平信号相反且电压不同,本图采用422单边驱动的方式,这样就和RS232基本相同了.

2.电阻的作用主要用来限制电流,防止电流过大烧坏通讯端口.我用的是3K的电阻,效果良好.

3.不要在两头都带电的情况下插拔电缆,以免烧坏通讯端口.

经一段时间用下来,没有出现任何异常情况,且适合FX1N,FX2N等多种机型.

这样经后学习PLC就方便多了,再不用和同事们抢电缆了.希望有兴趣的朋友和我多多讨论啊.

     马上要过年了,明天就要发工资了,我今天把这个实例贴出来,这一年的工作和学习就告一段落了,朋友们,我们明年再见了.

一.原理和功能介绍

1.PROTEUS模拟的效果图如下:

我简要介绍一下系统的组成及各部分的功能

本系统主要有五部分构成:

1.显示和键盘

显示采用的是最常用最便宜的1602液晶,内藏HD44780,且内含简单字库.指令简单,容易上手

键盘部分由7个按键和一个电位器旋钮组成系统的输入部分.(如图)

2.运算处理单元

本系统的所有操作都由PIC16F877A单片机完成(选择他的理由:端口多,不需扩展)

3.存储单元

主要由一片24C01的1K内存的EEPROM完成,此芯片与单片机通过I2C总线通信,具有占有端口少的优点.

4.输出控制单元

由一片光耦和一个双向晶闸管组成.单片机输出的脉冲通过控制光耦的通断控制双向晶闸管的通断,从而控制电灯的亮度.

5.时钟单元

这是一个附加单元,对本系统无关键作用,只是为了增加附加值.有一片DS1302时钟芯片和一个32768Hz的晶振组成

功能说明

1.一上电,系统显示"ADJUST"可调状态,此时旋钮调节光的亮度,即PWM波的占空比,如果此时按下"存储"键,则此时的亮度值被记录下来并保存,共可以记录下三个不同的亮度.

2.如你按下"模式"键,此时旋钮被屏蔽,只能调用你存储的三个亮度值,分别为"MODE 1","MODE 2","MODE 3"方便你的使用.

3.时间设置的两个按键可以实时调整时间.

二.程序(picc 8.05)

1.主程序

/***************************************************************
* 标题：PWM输出                                                   *
* 作者：Wujieflash                                                  *
* 日期：2008年1月25日                                          *
* 功能：使用PIC的CCP模块输出PWM波                 *
***************************************************************/
#include <pic.h>
#include "LCD1602_init.h"
#include "ds1302.h"
#include "i2c.h"

static volatile       bit GODONE  @ ((unsigned)&ADCON0*8)+2;
uch k,kb,kmem;
void PWMinit()
{
  TRISC=0xfb;//设置C口状态
 PORTC=0x00;
 PR2=0xff;      //设置PWM波的周期
 CCP1CON=0x0c;
 CCPR1L=0x1c;//设置占空比
 
 T2CON=0x01; //设置1:4预分频
 TMR2ON=1;   //开启定时器2
}
/*-------------------------------------------------------*/

void AD_convert_init()     //旋钮采样输出
{
 uch i;
 ADCON1=0x00;
 ADCON0=0x01;
 for(i=0;i<100;i++);
 GODONE=1;
}
/*-------------------------------------------------------*/

void ADScan()
{
 
 if(GODONE==0)
 {
  if(ADRESH>0xe3)ADRESH=0xe3;   //限制占空比的范围
  if(ADRESH<0x1c)ADRESH=0x1c;
  CCPR1L=ADRESH;
  GODONE=1;
  
 }
}
/*-------------------------------------------------------*/

void KeyScan()             //设置时间子程序
{
 int d;
 
 if(RC6==0)  //设置键按下
 {
  k++;    //选定入口值
  k=k%3;
 }
 while(1)
 {
  if(RC6==1)break;//等待按键松开
 }
 switch(k)//键盘服务入口
 {
  case 1://设置分
  {
   d=R1302(0x83);//读取分
   d=d/16*10+d%16;//转换为16进制
   minute=flag;   //设置秒的闪烁标志
   hour=1;      //其余变量不闪烁
 
   if(minute==0)  //闪烁
   {
    WriteCommand_1602(0xce);
    WriteData_1602(0x00);
    WriteData_1602(0x00);
   }
   if(RC7==0)     //分数值加1
   {
    d++;
    if(d>0x3b)d=0;//大于59就为0
    d=d/10*16+d%10;
    W1302(0x82,d);//写入DS1302
    while(1)
    {
     if(RC7==1)break;//等待键松开
    }
   }
   break;
  }
  case 2://设置时
  {
   d=R1302(0x85);//读取时
   d=d/16*10+d%16;//转换为16进制
   hour=flag;   //设置秒的闪烁标志
   minute=1;      //其余变量不闪烁
 
   if(hour==0)  //闪烁
   {
    WriteCommand_1602(0xcb);
    WriteData_1602(0x00);
    WriteData_1602(0x00);
   }
   if(RC7==0)     //时数值加1
   {
    d++;
    if(d>0x17)d=0;//大于59就为0
    d=d/10*16+d%10;
    W1302(0x84,d);//写入DS1302
    while(1)
    {
     if(RC7==1)break;//等待键松开
    }
   }
   break;
  }
  case 0://设置完毕，不闪烁
  {
   minute=1;
   hour=1;
   break;
  }
 }
}
/*-------------------------------------------------------*/

void KeyScan1()               //输出显示子程序
{
 if(RC0==0)              //模式键
 {
  kb++;
  kb=kb%2;
 }
 while(1)
 {
  if(RC0==1)break;
 }
 switch(kb)
 {
  case 0:                        //可调模式,
  {
   ADON=1;                    //旋钮有效
   WriteCommand_1602(0x80);
   WriteData_1602('A');
   WriteData_1602('D');
   WriteData_1602('J');
   WriteData_1602('U');
   WriteData_1602('S');
   WriteData_1602('T');
   WriteCommand_1602(0x8a);
   WriteData_1602(0x00);
   WriteData_1602(0x00);
   WriteData_1602(0x00);
   WriteData_1602(0x00);
   WriteData_1602(0x00);
   WriteData_1602(0x00);
   
   if(RC5==0)                //存储键
   {
    kmem++;
    kmem=kmem%3;
   while(1)
   {
    if(RC5==1)break;
   }
    switch(kmem)
    {
     case 1:
     {
      w_24cl01b(0x00,ADRESH);             //写入第一通道
      WriteCommand_1602(0x8a);
      WriteData_1602('C');
      WriteData_1602('H');
      WriteData_1602('1');
      WriteData_1602(0x00);
      WriteData_1602('O');
      WriteData_1602('K');
      break;
     }
     case 2:
     {
      w_24cl01b(0x01,ADRESH);        //写入第二通道
      WriteCommand_1602(0x8a);
      WriteData_1602('C');
      WriteData_1602('H');
      WriteData_1602('2');
      WriteData_1602(0x00);
      WriteData_1602('O');
      WriteData_1602('K');
      break;
     }
     case 0:
     {
      w_24cl01b(0x02,ADRESH);            //写入第三通道
      WriteCommand_1602(0x8a);
      WriteData_1602('C');
      WriteData_1602('H');
      WriteData_1602('3');
      WriteData_1602(0x00);
      WriteData_1602('O');
      WriteData_1602('K');
      break;
     }
    }
   }
   break;
  }
  case 1:                         //"MODE"模式
  {
   ADON=0;                    //屏蔽旋钮
   WriteCommand_1602(0x80);
   WriteData_1602('M');
   WriteData_1602('O');
   WriteData_1602('D');
   WriteData_1602('E');
   WriteData_1602(0x0);
   WriteData_1602(0x0);

   if(RC1==0)                             //模式一
   {
    CCPR1L=r_24cl01b(0x00);
    ADRESH=r_24cl01b(0x00);
    while(1)
       {
         if(RC1==1)break;
       }
       WriteCommand_1602(0x8a);
    WriteData_1602('C');
    WriteData_1602('H');
    WriteData_1602('1');
    WriteData_1602(0x00);
    WriteData_1602(0x00);
    WriteData_1602(0x00);
   }
   if(RC3==0)              //模式二
   {
    CCPR1L=r_24cl01b(0x01);
    ADRESH=r_24cl01b(0x01);
    while(1)
       {
         if(RC3==1)break;
       }
       WriteCommand_1602(0x8a);
    WriteData_1602('C');
    WriteData_1602('H');
    WriteData_1602('2');
    WriteData_1602(0x00);
    WriteData_1602(0x00);
    WriteData_1602(0x00);
   }
   if(RC4==0)            //模式三
   {
    CCPR1L=r_24cl01b(0x02);
    ADRESH=r_24cl01b(0x02);
    while(1)
       {
         if(RC4==1)break;
       }
       WriteCommand_1602(0x8a);
    WriteData_1602('C');
    WriteData_1602('H');
    WriteData_1602('3');
    WriteData_1602(0x00);
    WriteData_1602(0x00);
    WriteData_1602(0x00);
   }
   break;
  }
 }
}
/*-------------------------------------------------------*/

void DisplaySet(uch val)              //显示占空比子程序
{
 int pwm,pwm_shi,pwm_ge;
 if(val>0xe3)val=0xe3;
 if(val<0x1c)val=0x1c;
 pwm=val*100/255;
 pwm_shi=0x30+pwm/10;
 pwm_ge=0x30+pwm%10;
 WriteCommand_1602(0xc4);
 WriteData_1602(pwm_shi);
 WriteData_1602(pwm_ge);
 WriteData_1602('%');
}
/*-------------------------------------------------------*/

void main()
{
 init1602();
 i2c_init();
 AD_convert_init();
 TMR1init();
 PWMinit();
 while(1)
 {
  ADScan();                            
  DisplaySet(ADRESH);
  FlashMaohao();
  DisplayTime1602();
  KeyScan();
  KeyScan1();
 }
}
2.I2C子程序

/***************************************************************
* 标题：I2C协议                                            *
* 作者：Wujieflash                                             *
* 日期：2008年2月2日                                          *
* 功能：I2C通讯协议                                *
***************************************************************/
#define nop() asm("nop")
#define SCL   RD6
#define SDA   RD7

void i2c_init()
{
 TRISD6=0;
 TRISD7=0;
 RD6=0;
 RD7=0;
}
/*------------------------------------------------------------------*/
//start
void start_iic()
{
 SDA=1;
 nop();
 nop();
 SCL=1;
 nop();
 nop();
 nop();
 nop();
 SDA=0;
 nop();
 nop();
 SCL=0;//it is ready to send data
 nop();
}
/*------------------------------------------------------------------*/ 
//stop
void stop_iic(void)
{
 SDA=0;
 nop();
 nop();
 SCL=1;
 nop();
 nop();
 nop();
 nop();
 SDA=1;
 nop();
}
/*------------------------------------------------------------------*/
//send ack
void ack_iic()
{
 SDA=0;
 nop();
 nop();
 SCL=1;
 nop();
 nop();
 nop();
 nop();
 SCL=0;
 nop();
 nop();
}
/*------------------------------------------------------------------*/
//send nack
void nack_iic()
{
 SDA=1;
 nop();
 nop();
 SCL=1;
 nop();
 nop();
 nop();
 nop();
 SCL=0;
 nop();
 nop();
}
/*------------------------------------------------------------------*/
//send 1 byte
void send_iic(char c)
{
 uch i;
 for(i=0;i<8;i++)
 {
  SCL=0;
  if((c<<i)&0x80)
  {
   SDA=1;
  }
  else
  {
   SDA=0;
  }
  SCL=1;
  nop();
  nop();
  nop();
  nop();
  SCL=0;
  nop();
 }
  SDA=1;
  TRISD7=1;
  SCL=1;
  nop();
  nop();
  nop();
  nop();
  SCL=0;
  nop();
  TRISD7=0;
}
/*------------------------------------------------------------------*/
//receive 1 byte
uch receive_iic(void)
{
 uch rxbuf=0;
 uch i;
 //SDA=1;
 
 TRISD7=1;
 for(i=0;i<8;i++)
 {
  SCL=0;
  nop();
  nop();
  nop();
  nop();
  nop();
  SCL=1;
  nop();
  nop();
  rxbuf=rxbuf<<1;
  if(SDA==1)
  {
   rxbuf=rxbuf+1;
  }
  nop();
  nop();
 }
 
 SCL=0;
 nop();
 TRISD7=0;
 return(rxbuf);
}
/*------------------------------------------------------------------*/
//write 24cl01b subroutine
void w_24cl01b(unsigned char addr,unsigned char data)
{
 int i;
 start_iic();
 send_iic(0xa0);
 send_iic(addr);
 send_iic(data);
 stop_iic();
 for(i=0;i<500;i++);
}
/*------------------------------------------------------------------*/ 
//read 24cl01b subroutine
char r_24cl01b(unsigned char addr)
{
 int i;
 uch data;
 start_iic();
 send_iic(0xa0);
 send_iic(addr);
 
 start_iic();
 send_iic(0xa1);
 
 data=receive_iic();
    nack_iic();
 stop_iic();
 for(i=0;i<1000;i++);
 return(data);
 }

3.1602操作子程序

/***************************************************************
* 标题：LCD1602驱动                                            *
* 作者：Wujieflash                                             *
* 日期：2008年1月29日                                          *
* 功能：驱动1602液晶的驱动程序                                 *
***************************************************************/
#include <pic.h>

#define RS RD0
#define RW RD1
#define E  RD2

#define uch unsigned char

//延时子程序
void delay_1602(int time)
{
 while(time--);
}
/*-----------------------------------------------*/

//写命令子程序
void WriteCommand_1602(uch command)
{
 RS=0;
 RW=0;
 
 delay_1602(400);
 E=1;
 PORTB=command;
 E=0;
}
/*-----------------------------------------------*/

//写数据子程序
void WriteData_1602(uch data)
{
 RS=1;
 RW=0;
 
 delay_1602(400);
 E=1;
 PORTB=data;
 E=0;
}
/*-----------------------------------------------*/

//初始化LCD1602子程序
void init1602()
{
 TRISD0=0;
 TRISD1=0;
 TRISD2=0;
 RD0=0;
 RD1=0;
 RD2=0;
 TRISB=0;
 PORTB=0;
 WriteCommand_1602(0x01);
 WriteCommand_1602(0x38);
 WriteCommand_1602(0x0c);
 WriteCommand_1602(0x80);
 //WriteData_1602('M');
 //WriteData_1602('O');
 //WriteData_1602('D');
 //WriteData_1602('E');
 //WriteData_1602(':');
 WriteCommand_1602(0xc0);
 WriteData_1602('P');
 WriteData_1602('W');
 WriteData_1602('M');
 WriteData_1602(':');
}
4.时钟子程序

/***************************************************************
* 标题：DS1302数字时钟                                         *
* 作者：Wujieflash                                             *
* 日期：2008年1月29日                                          *
* 功能：显示日历与时间的程序                                   *
***************************************************************/
#define  RST  RD3
#define  SCLK RD4
#define  IO   RD5
uch flag=0;
uch minute=1,hour=1;
uch clock[]={0};
uch DisCash[]={0x00,0x30,0x09,0x16,0x01,0x03,0x09}; 
/////往1302写入1Byte数据////////////////////////
void RTInputByte(uch d)
{
    uch i;
    TRISD3=0;
    TRISD4=0;
    TRISD5=0;
    for(i=8; i>0; i--)
    {
      IO = d&0x01;      //取最低位
      SCLK = 1;         //上升沿发送
      SCLK = 0;         //恢复
      d = d >> 1;      
    }
}
///////从1302读取1Byte数据////////////////////////
uch RTOutputByte(void)
{
    uch i,val=0;
    TRISD5=1;            //设置为输入
    for(i=8; i>0; i--)
    {
      val = val >>1;        
      if(IO)val=val|0x80;// 从最低位开始接收
      SCLK = 1;          //下降沿接收
      SCLK = 0;
    }
     TRISD5=0;
     return(val);
}
///////先写地址，后写命令/数据//////////////////////////
void W1302(uch ucAddr, uch ucDa)
{
    RST = 0;
    SCLK = 0;
    RST = 1;                  //打开DS1302
    RTInputByte(ucAddr);      // /* 地址，命令 */
    RTInputByte(ucDa);        // /* 写1Byte数据*/
    SCLK = 1;
    RST = 0;                  //关闭DS1302
}
///////先写地址，后读命令/数据////////////////////////
uch R1302(uch ucAddr)
{
    uch ucData;
    RST = 0;
    SCLK = 0;
    RST = 1;
    RTInputByte(ucAddr);            // /* 地址，命令 */
    ucData = RTOutputByte();        // /* 读1Byte数据 */
    SCLK = 1;
    RST = 0;
    return(ucData);
}
/////////向1302写入 秒 分 时 日 月 星期 年 */////////////
void Set1302(uch *pClock)
{
    uch i;
    uch ucAddr = 0x80;          //起使地址
    W1302(0x8e,0x00);           ///* 控制命令,WP=0,允许写操作*/
    for(i =7; i>0; i--)
    {
      W1302(ucAddr,*pClock);    ///* 秒 分 时 日 月 星期 年 */
      pClock++;
      ucAddr +=2;               //写地址加2
    }
     W1302(0x8e,0x80);          // /* 控制命令,WP=1,写保护*/
}
////////从1302读出 秒 分 时 日 月 星期 年 *//////////////////
void v_Get1302(unsigned char  ucCurtime[])
{
unsigned char i;
unsigned char ucAddr = 0x81;
for(i=0;i<7;i++)
   {
      ucCurtime[i] = R1302(ucAddr);///*格式为: 秒 分 时 日 月 星期 年 */
      ucAddr += 2;
   }
}

//使用LCD1602显示
void DisplayTime1602()
{
 uch hour_shi,hour_ge,minute_shi,minute_ge;
 v_Get1302(clock);
 hour_shi=0x30+clock[2]/16;
 hour_ge=0x30+clock[2]%16;
 minute_shi=0x30+clock[1]/16;
 minute_ge=0x30+clock[1]%16;
 
 if(hour==1)
 {WriteCommand_1602(0x80+0x4b);
  WriteData_1602(hour_shi);
  WriteData_1602(hour_ge);
 }
 
 if(minute==1)
 {WriteCommand_1602(0x80+0x4e);
  WriteData_1602(minute_shi);
  WriteData_1602(minute_ge);
 }
}
//TRM1初始化子程序
void TMR1init()
{
 //TRM1 INITIAL
   T1CON=0X30;       //8分频
   TMR1IF=0;         //清中断标志
   TMR1IE=1;         //使能定时器1中断
   TMR1L=0XDB;       //初始值（定时0.5S）
   TMR1H=0X0B;
   TMR1ON=1;         //开定时器1
}

//冒号闪烁子程序
void FlashMaohao()
{
 if(TMR1IF==1)
 {
  TMR1ON=0;
  TMR1IF=0;
  TMR1L=0XDB;     //重新付初值
     TMR1H=0X0B;
     flag++;
     flag=flag%2;    //闪烁标志在0-1间翻转
     TMR1ON=1;
 }
 if(flag==0)
 {
  WriteCommand_1602(0xcd);
  WriteData_1602(':');
 }
 if(flag==1)
 {
  WriteCommand_1602(0xcd);
  WriteData_1602(0x00);
 }
}

三.总结

     虽然是完成了,但还有很多遗憾:

     1.并没有完全仿真出来,主要由于软件需要的数字和模拟器件太多,资源太多,运行不过来.

     2.有些实物已经验证的程序在PROTEUS上却失败,如24C01能写入,却读出来总为0,事实却可以的.

     3.程序逻辑性还是差了点,感觉很混乱.

大家如有兴趣,帮我改改I2C的程序,让他能仿真出来.

最后祝大家新年快乐,万事如意!

      为了把KS0108系列的液晶吃透,特别制作了这款万年历,感觉效果还是不错的.希望大家分享我的喜悦,毕竟有了更多志同道合的朋友支持,我才能更进一步提高.

一,原理介绍

说明:

1.单片机还是采用PIC中最经典的PIC16F877A,端口多,功能全,特别是他有8K的ROM,这是我选择的主要原因,因为储存液晶的字库需要很大的空间.

2.液晶显示还是用的KS0108系列,主要是他性价比高,指令简单,特别是公司也在用.

3.时钟/日历芯片用的DALLOS的DS1302芯片,他可以储存从2000-2099年的日历,及实时时钟,可以方便的读写.

4.温度测量还是用的DS18B20,这在我上一实例中已经用过,有兴趣可以查阅.

5.本万年历可以显示实时时钟,精确到秒,年,月,日,星期,阴历,温度,生肖等,显示的信息量大.

6,可以通过按键自由设定时钟及日历,按"设置"键可以在秒,分,时,日,月,星期,年之间来回切换,要设置的单元以闪烁提醒.通过"+"."-"按键可以把要设置的单元设定到预想状态.

二,程序说明:

本程序有许多小的模块,现分列如下:

1.主程序

/***************************************************
* 标题：万年历                                        *
* 作者：Wujieflash                                  *
* 日期：2008年1月13日                          *
* 说明：包含文件<ziku.h>,<lcd_init.h> 

                         <DS1302.H>,<DS18B20.H>

                         <KEYSCAN.H>,<YILI.H>  *                                 
***************************************************/
#include <pic.h>
#include "ziku.h"
#include "lcd_init.h"
#include "ds1302.h"
#include "ds18b20.h"
#include "keyscan.h"
#include "yinli.h"

//子程序
//LCD显示空白边框子程序
void LCDShowTable()
{
 uch i;
 SlectScreen(1);     //写左半屏
 SetLine(0);         //起使页
 SetColumn(0);       //起使列
 for(i=0;i<64;i++)
 {
  if((i==0)||(i==63))WriteData(0xff);//第1、63列竖线
  else WriteData(0x01);              //最上面一行线
 }
 for(i=1;i<7;i++)
 {
  SetLine(i);
  SetColumn(0);
  WriteData(0xff); //竖线
  SetColumn(63);
  WriteData(0xff); //竖线 
 }
 SetLine(7);
 SetColumn(0);
 for(i=0;i<64;i++)
 {
  if((i==0)||(i==63))WriteData(0xff);
  else WriteData(0x80);             //最下面的横线
 }
 
 SlectScreen(2);//写右半屏
 SetLine(0);
 SetColumn(0);
 for(i=0;i<64;i++)
 {
  if(i==63)WriteData(0xff);
  else WriteData(0x01);
 }
 SetLine(4);
 SetColumn(0);
 for(i=0;i<64;i++)
 {
  if(i==63)WriteData(0xff);
  else WriteData(0x01);
 }
 for(i=1;i<7;i++)
 {
  SetLine(i);
  SetColumn(63);
  WriteData(0xff); 
 }
 SetLine(7);
 SetColumn(0);
 for(i=0;i<64;i++)
 {
  if(i==63)WriteData(0xff);
  else WriteData(0x80);
 } 
}
/*----------------------------------------------------------*/

//显示固定字符子程序
void LCDShowGudingWord()
{
 Show8X16_2(0,24,s0);
 Show8X16_2(0,32,s0);
 Show8X16(2,1,s0);
 Show8X16(2,9,s0);
 Show16X16_3(6,40,ri);
 Show16X32(2,24,ss0);
 Show16X32(2,40,ss0);
 Show8X16_2(0,64,s0);
 Show8X16_2(0,72,s0);
 Show8X16_2(0,80,maohao);
 Show8X16_2(0,88,s0);
 Show8X16_2(0,96,s0);
 Show8X16_2(0,104,maohao);
 Show8X16_2(0,112,s0);
 Show8X16_2(0,119,s0);
 Show8X16(2,80,s0);
 Show8X16(2,88,s0);
 Show16X16_2(4,64,shiyi);
 Show16X16_2(4,80,yue);
 Show16X16_2(4,95,chu);
 Show16X16_2(4,111,yi);
 Show16X16_3(6,72,sheng);
 Show16X16_3(6,88,xiao);
 Show16X16_3(6,104,shu);
 
 Show16X16_2(0,40,nian);
 Show16X16(4,2,yue);
 Show16X16_3(6,8,xing);
 Show16X16_3(6,24,qi);
 Show16X16(2,96,danwei1);
 Show8X16_2(0,8,s2);
 Show8X16_2(0,16,s0);
}
/*----------------------------------------------------------*/

//TRM1初始化子程序
void TMR1init()
{
 //TRM1 INITIAL
   T1CON=0X30;       //8分频
   TMR1IF=0;         //清中断标志
   TMR1IE=1;         //使能定时器1中断
   TMR1L=0XDB;       //初始值（定时0.5S）
   TMR1H=0X0B;
   TMR1ON=1;         //开定时器1
}

//冒号闪烁子程序
void FlashMaohao()
{
 static uch timecount=0;
 if(TMR1IF==1)
 {
  TMR1ON=0;
  TMR1IF=0;
  TMR1L=0XDB;     //重新付初值
     TMR1H=0X0B;
     flag++;
     flag=flag%2;    //闪烁标志在0-1间翻转
     TMR1ON=1;
  timecount++;
  if(timecount==120)//1分钟采样一次温度
  {
   timecount=0;
   get_temp();   //温度转换子程序
  }
 }
 if(flag==0)
 {
  Show8X16_2(0,80,maohao);
  Show8X16_2(0,104,maohao);
 }
 if(flag==1)
 {
  Show8X16_2(0,80,noshu);//清除
  Show8X16_2(0,104,noshu);
 }
}

//主程序
void main()
{
 TMR1init();             //定时器1初始化
 keyinit();              //键盘初始化
 LCDinit();              //LCD操作初始化
 LCDShowTable();         //显示空白表格
 LCDShowGudingWord();    //显示固定字符
 //Set1302(DisCash);     //设置初始时间（默认写入我写程序的时间）
 get_temp();             //读取温度
 while(1)
 {
  v_Get1302(clock);   //读取时间、日历
  display();
  YangToYin(clock[6]/16*10+clock[6]&0x0f,clock[4]/16*10+clock[4]&0x0f,clock[3]/16*10+clock[3]&0x0f);
  FlashMaohao();      //冒号闪烁
  KeyScan();         //键盘扫描
 }
}

2.测温程序:

/***************************************************
* 标题：DS18B20测温                             *
* 作者：Wujieflash                                   *
* 日期：2008年1月13日                           *
* 说明：使用DS18B20芯片测温                *
***************************************************/
# define DQ RC3                                //定义18B20数据端口
# define DQ_DIR TRISC3                         //定义18B20D口方向寄存器
# define DQ_HIGH() DQ_DIR =1                   //设置数据口为输入
# define DQ_LOW() DQ = 0; DQ_DIR = 0           //设置数据口为输出
 unsigned char  TLV=0 ;                        //采集到的温度高8位
 unsigned char  THV=0;                         //采集到的温度低8位
 unsigned char TZ=0;                           //转换后的温度值整数部分
 
 //------------------------------------------------
//延时函数

//系统初始化函数
void init()
{
  ADCON1=0X07;                                //设置A口为普通数字口
  TRISA=0X00;                                 //设置A口方向为输出
  //TRISC3=0;                                 //设置D口方向为输出
}

//-----------------------------------------------
//复位DS18B20函数
reset(void)
{
  char presence=1;
  while(presence)
  {
    DQ_LOW() ;                                //主机拉至低电平
    delay(2,90);                              //延时503us
    DQ_HIGH();                                //释放总线等电阻拉高总线,并保持15~60us
    delay(2,8);                               //延时70us
    if(DQ==1) presence=1;                     //没有接收到应答信号，继续复位
    else presence=0;                          //接收到应答信号
    delay(2,70);                              //延时430us
   }
  }

//-----------------------------------------------
//写18b20写字节函数
void write_byte(uch val)
{
 uch i;
 uch temp;
 for(i=8;i>0;i--)
 {
   temp=val&0x01;                            //最低位移出
   DQ_LOW();
   NOP();
   NOP();
   NOP();
   NOP();
   NOP();                                    //从高拉至低电平,产生写时间隙
   if(temp==1)  DQ_HIGH();                   //如果写1,拉高电平
   delay(2,7);                               //延时63us
   DQ_HIGH();
   NOP();
   NOP();
   val=val>>1;                               //右移一位
  }
}

//------------------------------------------------
//18b20读字节函数
uch read_byte(void)
{
 uch i;
 uch value=0;                                //读出温度
 static bit j;
 for(i=8;i>0;i--)
 {
   value>>=1;
   DQ_LOW();
   NOP();
   NOP();
   NOP();
   NOP();                                   //6us
   DQ_HIGH();                               //拉至高电平
   NOP();
   NOP();
   NOP();                                //4us
   j=DQ;
   if(j) value|=0x80;
   delay(2,7);                             //63us
  }
  return(value);
}

//-------------------------------------------------
//启动温度转换函数
void get_temp()
{
int i;
DQ_HIGH();
reset();                                 //复位等待从机应答
write_byte(0XCC);                        //忽略ROM匹配
write_byte(0X44);                        //发送温度转化命令 
for(i=10;i>0;i--)
    {
       
        delay(201,132);                       //调用多次显示函数，确保温度转换完成所需要的时间
    }
reset();                                 //再次复位，等待从机应答
write_byte(0XCC);                        //忽略ROM匹配
write_byte(0XBE);                        //发送读温度命令
TLV=read_byte();                         //读出温度低8
THV=read_byte();                         //读出温度高8位
DQ_HIGH();                               //释放总线
TZ=(TLV>>4)|(THV<<4)&0X3f;               //温度整数部分
ChangeToLCD(2,80,TZ);
}

3.日历显示程序

/***************************************************
* 标题：DS1302读写                                *
* 作者：Wujieflash                                   *
* 日期：2008年1月14日                           *
* 说明：日历显示范围：2000年--2099年  *
***************************************************/
#define  RST  RC0
#define  SCLK RC1
#define  IO   RC2
uch flag=0;
uch second=1,minute=1,hour=1,year=1,month=1,date=1,day=1;
uch clock[]={0};
uch DisCash[]={0x00,0x30,0x09,0x16,0x01,0x03,0x09}; 
/////往1302写入1Byte数据////////////////////////
void RTInputByte(uch d)
{
    uch i;
    TRISC=0x00;
    for(i=8; i>0; i--)
    {
      IO = d&0x01;      //取最低位
      SCLK = 1;         //上升沿发送
      SCLK = 0;         //恢复
      d = d >> 1;      
    }
}
///////从1302读取1Byte数据////////////////////////
uch RTOutputByte(void)
{
    uch i,val=0;
    TRISC2=1;            //设置为输入
    for(i=8; i>0; i--)
    {
      val = val >>1;        
      if(IO)val=val|0x80;// 从最低位开始接收
      SCLK = 1;          //下降沿接收
      SCLK = 0;
    }
     return(val);
}
///////先写地址，后写命令/数据//////////////////////////
void W1302(uch ucAddr, uch ucDa)
{
    RST = 0;
    SCLK = 0;
    RST = 1;                  //打开DS1302
    RTInputByte(ucAddr);      // /* 地址，命令 */
    RTInputByte(ucDa);        // /* 写1Byte数据*/
    SCLK = 1;
    RST = 0;                  //关闭DS1302
}
///////先写地址，后读命令/数据////////////////////////
uch R1302(uch ucAddr)
{
    uch ucData;
    RST = 0;
    SCLK = 0;
    RST = 1;
    RTInputByte(ucAddr);            // /* 地址，命令 */
    ucData = RTOutputByte();        // /* 读1Byte数据 */
    SCLK = 1;
    RST = 0;
    return(ucData);
}
/////////向1302写入 秒 分 时 日 月 星期 年 */////////////
void Set1302(uch *pClock)
{
    uch i;
    uch ucAddr = 0x80;          //起使地址
    W1302(0x8e,0x00);           ///* 控制命令,WP=0,允许写操作*/
    for(i =7; i>0; i--)
    {
      W1302(ucAddr,*pClock);    ///* 秒 分 时 日 月 星期 年 */
      pClock++;
      ucAddr +=2;               //写地址加2
    }
     W1302(0x8e,0x80);          // /* 控制命令,WP=1,写保护*/
}
////////从1302读出 秒 分 时 日 月 星期 年 *//////////////////
void v_Get1302(unsigned char  ucCurtime[])
{
unsigned char i;
unsigned char ucAddr = 0x81;
for(i=0;i<7;i++)
   {
      ucCurtime[i] = R1302(ucAddr);///*格式为: 秒 分 时 日 月 星期 年 */
      ucAddr += 2;
   }
}

/////////与LCD的显示接口//////////////////////
void display()
{
 uch i;
 for(i=0;i<7;i++)
 {
  clock[i]=clock[i]/16*10+clock[i]%16;//转换为十六进制
 }
 if(second==1)ChangeToLCD2(0,111,clock[0]);//显示秒
    if(minute==1)ChangeToLCD2(0,88,clock[1]); //显示分
    if(hour==1)ChangeToLCD2(0,64,clock[2]);   //显示时
    if(year==1)ChangeToLCD2(0,24,clock[6]);   //显示年
 if(month==1)ChangeToLCD(2,2,clock[4]);    //显示月
 if(date==1)ChangeToLCD3(2,24,clock[3]);   //显示日
 if(day==1)ChangeToLCD4(6,40,clock[5]);   //显示星期
 ChangeToLCD5(6,104,clock[6]);             //显示生肖
 
} 

4.按键扫描与服务程序

/***************************************************
* 标题：按键扫描和服务                             *
* 作者：Wujieflash                                     *        
* 日期：2008年1月17日                             *
* 说明：当按键按下，选中的单元就会闪烁 *
***************************************************/
uch k=0;

//键盘初始化子程序
void keyinit()
{
 TRISD0=1;
 TRISD0=1;
 TRISD0=1;
}
/*----------------------------------------------------------*/

//键盘扫描子程序
void KeyScan()
{
 int d;
 if(RD0==0)  //设置键按下
 {
  k++;    //选定入口值
  k=k%8;
 }
 while(1)
 {
  if(RD0==1)break;//等待按键松开
 }
 switch(k)//键盘服务入口
 {
  case 1://设置秒
  {
   d=R1302(0x81);//读取秒
   d=d/16*10+d%16;//转换为16进制
   second=flag;   //设置秒的闪烁标志
   minute=1;      //其余变量不闪烁
   hour=1;
   year=1;
   month=1;
   date=1;
   day=1;
   if(second==0)  //闪烁
   {
    Show8X16_2(0,111,noshu);
    Show8X16_2(0,119,noshu);
   }
   if(RD1==0)     //秒数值加1
   {
    d++;
    if(d>0x3b)d=0;//大于59就为0
    d=d/10*16+d%10;
    W1302(0x80,d);//写入DS1302
    while(1)
    {
     if(RD1==1)break;//等待键松开
    }
   }
   if(RD2==0)//数值减1
   {
    d--;
    if(d<0)d=0x3b;//小于0就写59
    d=d/10*16+d%10;
    W1302(0x80,d);
    while(1)
    {
     if(RD2==1)break;
    }
   }
   break;
  }
  case 2://设置分
  {
   d=R1302(0x83);
   d=d/16*10+d%16;
   minute=flag;
   second=1;
   hour=1;
   year=1;
   month=1;
   date=1;
   day=1;
   if(minute==0)
   {
    Show8X16_2(0,96,noshu);
    Show8X16_2(0,88,noshu);
   }
   if(RD1==0)
   {
    d++;
    if(d>0x3b)d=0;
    d=d/10*16+d%10;
    W1302(0x82,d);
    while(1)
    {
     if(RD1==1)break;
    }
   }
   if(RD2==0)
   {
    d--;
    if(d<0)d=0x3b;
    d=d/10*16+d%10;
    W1302(0x82,d);
    while(1)
    {
     if(RD2==1)break;
    }
   }
   break;
  }
  case 3://设置时
  {
   d=R1302(0x85);
   d=d/16*10+d%16;
   hour=flag;
   second=1;
   minute=1;
   year=1;
   month=1;
   date=1;
   day=1;
   if(hour==0)
   {
    Show8X16_2(0,64,noshu);
    Show8X16_2(0,72,noshu);
   }
   if(RD1==0)
   {
    d++;
    if(d>0x17)d=0;
    d=d/10*16+d%10;
    W1302(0x84,d);
    while(1)
    {
     if(RD1==1)break;
    }
   }
   if(RD2==0)
   {
    d--;
    if(d<0)d=0x17;
    d=d/10*16+d%10;
    W1302(0x84,d);
    while(1)
    {
     if(RD2==1)break;
    }
   }
   break;
  }
  case 4://设置日期
  {
   d=R1302(0x87);
   d=d/16*10+d%16;
   date=flag;
   second=1;
   minute=1;
   year=1;
   month=1;
   hour=1;
   day=1;
   if(date==0)
   {
    Show16X32(2,24,noshu2);
    Show16X32(2,40,noshu2);
   }
   if(RD1==0)
   {
    d++;
    if(d>0x1f)d=1;
    d=d/10*16+d%10;
    W1302(0x86,d);
    while(1)
    {
     if(RD1==1)break;
    }
   }
   if(RD2==0)
   {
    d--;
    if(d<1)d=0x1f;
    d=d/10*16+d%10;
    W1302(0x86,d);
    while(1)
    {
     if(RD2==1)break;
    }
   }
   break;
  }
  case 5://设置月
  {
   d=R1302(0x89);
   d=d/16*10+d%16;
   month=flag;
   second=1;
   minute=1;
   year=1;
   hour=1;
   date=1;
   day=1;
   if(month==0)
   {
    Show8X16(2,2,noshu);
    Show8X16(2,10,noshu);
   }
   if(RD1==0)
   {
    d++;
    if(d>0x0c)d=1;
    d=d/10*16+d%10;
    W1302(0x88,d);
    while(1)
    {
     if(RD1==1)break;
    }
   }
   if(RD2==0)
   {
    d--;
    if(d<1)d=0x0c;
    d=d/10*16+d%10;
    W1302(0x88,d);
    while(1)
    {
     if(RD2==1)break;
    }
   }
   break;
  }
  case 6://设置星期
  {
   d=R1302(0x8b);
   d=d/16*10+d%16;
   day=flag;
   second=1;
   minute=1;
   year=1;
   hour=1;
   date=1;
   month=1;
   if(day==0)
   {
    Show16X16_3(6,40,noshu3);
   }
   if(RD1==0)
   {
    d++;
    if(d>0x07)d=1;
    d=d/10*16+d%10;
    W1302(0x8a,d);
    while(1)
    {
     if(RD1==1)break;
    }
   }
   if(RD2==0)
   {
    d--;
    if(d<1)d=0x07;
    d=d/10*16+d%10;
    W1302(0x8a,d);
    while(1)
    {
     if(RD2==1)break;
    }
   }
   break;
  }
  case 7://设置年
  {
   d=R1302(0x8d);
   d=d/16*10+d%16;
   year=flag;
   second=1;
   minute=1;
   month=1;
   hour=1;
   date=1;
   day=1;
   if(year==0)
   {
    Show8X16_2(0,24,noshu);
    Show8X16_2(0,32,noshu);
   }
   if(RD1==0)
   {
    d++;
    if(d>0x63)d=0;
    d=d/10*16+d%10;
    W1302(0x8c,d);
    while(1)
    {
     if(RD1==1)break;
    }
   }
   if(RD2==0)
   {
    d--;
    if(d<0)d=0x63;
    d=d/10*16+d%10;
    W1302(0x8c,d);
    while(1)
    {
     if(RD2==1)break;
    }
   }
   break;
  }
  case 0://设置完毕，不闪烁
  {
   second=1;
   minute=1;
   month=1;
   hour=1;
   date=1;
   day=1;
   year=1;
   break;
  }
 }
}

5.液晶显示程序

/***************************************************
* 标题：LCD操作                                    *
* 作者：Wujieflash                                  *
* 日期：2008年1月12日                          *
* 说明：KS0108系列液晶不带字库          *
***************************************************/
#include <pic.h>

#define E    RA0        //液晶使能端
#define RW   RA1        //读写控制端
#define DI   RA2        //数据/指令通道
#define CSA  RA5        //片选
#define CSB  RA3        //片选
#define nop() asm("nop")

////////////////////////基本子函数///////////////////////
//延时
void delay(char x,char y)
{
  char z;
  do{
      z=y;
      do{;}while(--z);
     }while(--x);
 }
//其指令时间为：7+（3*（Y-1）+7）*（X-1）如果再加上函数调用的call 指令、页面设定、传递参数花掉的7 个指令。
//则是：14+（3*（Y-1）+7）*（X-1）。

//--------------------------------------------------
void LCDdelay()
{
 unsigned int i=500;
 while(i--)
 {;}
}
/*----------------------------------------------------*/

//状态检查
void CheckState()
{
 unsigned int dat;
 RW=1;                             //读状态
 DI=0;
 TRISB=0xff;                       //设置口为输入
 while(1)
 {
  E=1;                          //高电平读数据
  dat=PORTB&0x90;               //当4、7位为0时为正常状态
  E=0;
  if(dat==0x00)break;
 }
 TRISB=0x00;                       //恢复口为输出
}
/*----------------------------------------------------*/

//写显示数据
//dat:显示数据
void WriteData(unsigned char dat)
{
 CheckState();
 DI=1;                            //写数据
 RW=0;
 PORTB=dat;
 E=1;
 E=0;
}
/*---------------------------------------------------*/

//写指令
//command:操作LCD的指令
void WriteCommand(unsigned char dat)
{
 CheckState();
 RW=0;                          //写指令
 PORTB=dat;
 E=1;
 E=0;
}
/*---------------------------------------------------*/

//设定页地址----X:0--7
void SetLine(unsigned char line)
{
 line=line&0x07;               //0<=line<=7 
 line=line|0xb8;
 WriteCommand(line);
}
/*---------------------------------------------------*/

//设定列地址----Y:0--63
void SetColumn(unsigned char column)
{
 column=column&0x3f;          //0<=column<=63
 column=column|0x40;
 WriteCommand(column);
}
/*--------------------------------------------------*/

//设定开始行
void SetStartLine(unsigned char startline)
{
 startline=startline&0x3f;   //0<=startline<=63
 startline=startline|0xc0;
 WriteCommand(startline);
}
/*--------------------------------------------------*/

//开关显示
//1:开显示  0:关显示
void SetOnOff(unsigned char state)
{
 state=state|0x3e;
 WriteCommand(state);
}
/*--------------------------------------------------*/

//选择屏幕
//screen: 1:左屏 2:右屏
void SlectScreen(unsigned char screen)
{
 switch(screen)
 {
  case 1: CSA=0;
     CSB=1;//左屏
     break;
  case 2: CSA=1;
    CSB=0;//右屏
    break;
 }
}
/*--------------------------------------------------*/

//清屏
//screen: 1:左屏 2:右屏
void ClearScreen(unsigned char screen)
{
 unsigned char i,j;
 SlectScreen(screen);
 for(i=0;i<8;i++)
 {
  SetLine(i);
  for(j=0;j<64;j++)
  {
   WriteData(0x00);
   WriteData(0x00);
  }
 }
}
/*---------------------------------------------------*/

//显示一个16X16的汉字
void Show16X16(unsigned char line,unsigned char column,const unsigned char *pt)
{
 unsigned char i,column_temp;
 column_temp=column;
 SlectScreen(1);                      //选通左屏
 SetColumn(column);                   //设置起始列
 SetLine(line);                       //设置行
 for(i=0;i<16;i++)
 {
  if(column>=64)                   //如果列>=64，则选通右屏
  {
   SlectScreen(2);
   column=column%64;            //设置右屏起始列
   SetColumn(column);
   SetLine(line);
  } 
  WriteData(*pt);                  //写数据
  *pt++;//
  column++;
 }
 SlectScreen(1);
 SetLine(line+1);                    //设置汉字下半部分显示页
 column=column_temp;
 SetColumn(column);
 for(i=0;i<16;i++)
 {
  if(column>=64)
  {
   SlectScreen(2);
   column=column%64;
   SetColumn(column);
   SetLine(line+1);
  } 
  WriteData(*pt);
  *pt++;
  column++;
 }
}
/*-------------------------------------------------------*/

//显示一个16X16的汉字带上划线
void Show16X16_2(unsigned char line,unsigned char column,const unsigned char *pt)
{
 unsigned char i,column_temp;
 column_temp=column;
 SlectScreen(1);                      //选通左屏
 SetColumn(column);                   //设置起始列
 SetLine(line);                       //设置行
 for(i=0;i<16;i++)
 {
  if(column>=64)                   //如果列>=64，则选通右屏
  {
   SlectScreen(2);
   column=column%64;            //设置右屏起始列
   SetColumn(column);
   SetLine(line);
  } 
  WriteData(*pt|0x01);                  //写数据
  *pt++;
  column++;
 }
 SlectScreen(1);
 SetLine(line+1);                    //设置汉字下半部分显示页
 column=column_temp;
 SetColumn(column);
 for(i=0;i<16;i++)
 {
  if(column>=64)
  {
   SlectScreen(2);
   column=column%64;
   SetColumn(column);
   SetLine(line+1);
  } 
  WriteData(*pt);
  *pt++;
  column++;
 }
}
/*-------------------------------------------------------*/

//显示一个16X16的汉字带下划线
void Show16X16_3(unsigned char line,unsigned char column,const unsigned char *pt)
{
 unsigned char i,column_temp;
 column_temp=column;
 SlectScreen(1);                      //选通左屏
 SetColumn(column);                   //设置起始列
 SetLine(line);                       //设置行
 for(i=0;i<16;i++)
 {
  if(column>=64)                   //如果列>=64，则选通右屏
  {
   SlectScreen(2);
   column=column%64;            //设置右屏起始列
   SetColumn(column);
   SetLine(line);
  } 
  WriteData(*pt);                  //写数据
  *pt++;
  column++;
 }
 SlectScreen(1);
 SetLine(line+1);                    //设置汉字下半部分显示页
 column=column_temp;
 SetColumn(column);
 for(i=0;i<16;i++)
 {
  if(column>=64)
  {
   SlectScreen(2);
   column=column%64;
   SetColumn(column);
   SetLine(line+1);
  } 
  WriteData(*pt|0x80);
  *pt++;
  column++;
 }
}
/*-------------------------------------------------------*/

//显示一个8X16的字符
void Show8X16(unsigned char line,unsigned char column,const unsigned char *pt)
{
 unsigned char i,column_temp;
 column_temp=column;
 SlectScreen(1);                          //选通左屏
 SetColumn(column);                       //设置起始列
 SetLine(line);                           //设置行
 for(i=0;i<8;i++)
 {
  if(column>=64)                       //如果列>=64，则选通右屏
  {
   SlectScreen(2);
   column=column%64;                //设置右屏起始列
   SetColumn(column);
   SetLine(line);
  } 
  WriteData(*pt);                      //写数据
  *pt++;
  column++;
 }
 SlectScreen(1);
 SetLine(line+1);                         //设置汉字下半部分显示页
 column=column_temp;
 SetColumn(column);
 for(i=0;i<8;i++)
 {
  if(column>=64)
  {
   SlectScreen(2);
   column=column%64;
   SetColumn(column);
   SetLine(line+1);
  } 
  WriteData(*pt);
  *pt++;
  column++;
 }
}
/*-------------------------------------------------------*/

//显示一个8X16的字符带上划线
void Show8X16_2(unsigned char line,unsigned char column,const unsigned char *pt)
{
 unsigned char i,column_temp;
 column_temp=column;
 SlectScreen(1);                          //选通左屏
 SetColumn(column);                       //设置起始列
 SetLine(line);                           //设置行
 for(i=0;i<8;i++)
 {
  if(column>=64)                       //如果列>=64，则选通右屏
  {
   SlectScreen(2);
   column=column%64;                //设置右屏起始列
   SetColumn(column);
   SetLine(line);
  } 
  WriteData(*pt|0x01);                      //写数据
  *pt++;
  column++;
 }
 SlectScreen(1);
 SetLine(line+1);                         //设置汉字下半部分显示页
 column=column_temp;
 SetColumn(column);
 for(i=0;i<8;i++)
 {
  if(column>=64)
  {
   SlectScreen(2);
   column=column%64;
   SetColumn(column);
   SetLine(line+1);
  } 
  WriteData(*pt);
  *pt++;
  column++;
 }
}
/*-------------------------------------------------------*/

//显示一个16X32的字符
void Show16X32(unsigned char line,unsigned char column,const unsigned char *pt)
{
 unsigned char i,column_temp1,column_temp2,column_temp3;
 column_temp1=column;
 column_temp2=column;
 column_temp3=column;
 SlectScreen(1);                         //选通左屏
 SetColumn(column);                      //设置起始列
 SetLine(line);                          //设置行
 for(i=0;i<16;i++)
 {
  if(column>=64)                      //如果列>=64，则选通右屏
  {
   SlectScreen(2);
   column=column%64;               //设置右屏起始列
   SetColumn(column);
   SetLine(line);
  } 
  WriteData(*pt);                     //写数据
  *pt++;
  column++;
 }
 SlectScreen(1);
 SetLine(line+1);
 column=column_temp1;
 SetColumn(column);
 for(i=0;i<16;i++)
 {
  if(column>=64)
  {
   SlectScreen(2);
   column=column%64;
   SetColumn(column);
   SetLine(line+1);
  } 
  WriteData(*pt);
  *pt++;
  column++;
 }
 SlectScreen(1);
 SetLine(line+2);
 column=column_temp2;
 SetColumn(column);
 for(i=0;i<16;i++)
 {
  if(column>=64)
  {
   SlectScreen(2);
   column=column%64;
   SetColumn(column);
   SetLine(line+2);
  } 
  WriteData(*pt);
  *pt++;
  column++;
 }
 SlectScreen(1);
 SetLine(line+3);
 column=column_temp3;
 SetColumn(column);
 for(i=0;i<16;i++)
 {
  if(column>=64)
  {
   SlectScreen(2);
   column=column%64;
   SetColumn(column);
   SetLine(line+3);
  } 
  WriteData(*pt);
  *pt++;
  column++;
 }
}
/*-------------------------------------------------------*/

//LCD初始化子程序
void LCDinit()
{
 ADCON1=0x06;
 TRISA=0x00;
 TRISB=0x00;
 PORTB=0x00;
 SetOnOff(1);
}
/*----------------------------------------------------------*/

//调用LCD显示子程序
void ChangeToLCD(uch line,uch column,uch data)
{
 int D_ge,D_shi;
 
 D_ge=data%10;                           //取个位
 D_shi=data%100/10;                      //取十位
 
 switch(D_ge)
 {
  case 0:{Show8X16(line,column+8,s0);break;}
  case 1:{Show8X16(line,column+8,s1);break;}
  case 2:{Show8X16(line,column+8,s2);break;}
  case 3:{Show8X16(line,column+8,s3);break;}
  case 4:{Show8X16(line,column+8,s4);break;}
  case 5:{Show8X16(line,column+8,s5);break;}
  case 6:{Show8X16(line,column+8,s6);break;}
  case 7:{Show8X16(line,column+8,s7);break;}
  case 8:{Show8X16(line,column+8,s8);break;}
  case 9:{Show8X16(line,column+8,s9);break;}
 }
 switch(D_shi)
 {
  case 0:{Show8X16(line,column,s0);break;}
  case 1:{Show8X16(line,column,s1);break;}
  case 2:{Show8X16(line,column,s2);break;}
  case 3:{Show8X16(line,column,s3);break;}
  case 4:{Show8X16(line,column,s4);break;}
  case 5:{Show8X16(line,column,s5);break;}
  case 6:{Show8X16(line,column,s6);break;}
  case 7:{Show8X16(line,column,s7);break;}
  case 8:{Show8X16(line,column,s8);break;}
  case 9:{Show8X16(line,column,s9);break;}
 } 
}
/*-----------------------------------------------------------------*/

void ChangeToLCD2(uch line,uch column,uch data)//带上划线
{
 int D_ge,D_shi;
 
 D_ge=data%10;                           //取个位
 D_shi=data%100/10;                      //取十位
 
 switch(D_ge)
 {
  case 0:{Show8X16_2(line,column+8,s0);break;}
  case 1:{Show8X16_2(line,column+8,s1);break;}
  case 2:{Show8X16_2(line,column+8,s2);break;}
  case 3:{Show8X16_2(line,column+8,s3);break;}
  case 4:{Show8X16_2(line,column+8,s4);break;}
  case 5:{Show8X16_2(line,column+8,s5);break;}
  case 6:{Show8X16_2(line,column+8,s6);break;}
  case 7:{Show8X16_2(line,column+8,s7);break;}
  case 8:{Show8X16_2(line,column+8,s8);break;}
  case 9:{Show8X16_2(line,column+8,s9);break;}
 }
 switch(D_shi)
 {
  case 0:{Show8X16_2(line,column,s0);break;}
  case 1:{Show8X16_2(line,column,s1);break;}
  case 2:{Show8X16_2(line,column,s2);break;}
  case 3:{Show8X16_2(line,column,s3);break;}
  case 4:{Show8X16_2(line,column,s4);break;}
  case 5:{Show8X16_2(line,column,s5);break;}
  case 6:{Show8X16_2(line,column,s6);break;}
  case 7:{Show8X16_2(line,column,s7);break;}
  case 8:{Show8X16_2(line,column,s8);break;}
  case 9:{Show8X16_2(line,column,s9);break;}
 } 
}
/*-----------------------------------------------------------------*/
void ChangeToLCD3(uch line,uch column,uch data)//带下划线
{
 int D_ge,D_shi;
 
 D_ge=data%10;                           //取个位
 D_shi=data%100/10;                      //取十位
 
 switch(D_ge)
 {
  case 0:{Show16X32(line,column+16,ss0);break;}
  case 1:{Show16X32(line,column+16,ss1);break;}
  case 2:{Show16X32(line,column+16,ss2);break;}
  case 3:{Show16X32(line,column+16,ss3);break;}
  case 4:{Show16X32(line,column+16,ss4);break;}
  case 5:{Show16X32(line,column+16,ss5);break;}
  case 6:{Show16X32(line,column+16,ss6);break;}
  case 7:{Show16X32(line,column+16,ss7);break;}
  case 8:{Show16X32(line,column+16,ss8);break;}
  case 9:{Show16X32(line,column+16,ss9);break;}
 }
 switch(D_shi)
 {
  case 0:{Show16X32(line,column,ss0);break;}
  case 1:{Show16X32(line,column,ss1);break;}
  case 2:{Show16X32(line,column,ss2);break;}
  case 3:{Show16X32(line,column,ss3);break;}
  case 4:{Show16X32(line,column,ss4);break;}
  case 5:{Show16X32(line,column,ss5);break;}
  case 6:{Show16X32(line,column,ss6);break;}
  case 7:{Show16X32(line,column,ss7);break;}
  case 8:{Show16X32(line,column,ss8);break;}
  case 9:{Show16X32(line,column,ss9);break;}
 } 
}
/*-----------------------------------------------------------------*/

void ChangeToLCD4(uch line,uch column,uch data)//星期转换
{                    
 switch(data)
 {
  case 1:{Show16X16_3(line,column,ri);break;}
  case 2:{Show16X16_3(line,column,yi);break;}
  case 3:{Show16X16_3(line,column,er);break;}
  case 4:{Show16X16_3(line,column,san);break;}
  case 5:{Show16X16_3(line,column,si);break;}
  case 6:{Show16X16_3(line,column,wu);break;}
  case 7:{Show16X16_3(line,column,liu);break;}
 } 
}
/*-----------------------------------------------------------------*/

void ChangeToLCD5(uch line,uch column,uch data)//生肖转换
{  
 data=data%12;                 
 switch(data)
 {
  case 0:{Show16X16_3(line,column,llong);break;}
  case 1:{Show16X16_3(line,column,she);break;}
  case 2:{Show16X16_3(line,column,ma);break;}
  case 3:{Show16X16_3(line,column,yang);break;}
  case 4:{Show16X16_3(line,column,hou);break;}
  case 5:{Show16X16_3(line,column,ji);break;}
  case 6:{Show16X16_3(line,column,gou);break;}
  case 7:{Show16X16_3(line,column,zhu);break;}
  case 8:{Show16X16_3(line,column,shu);break;}
  case 9:{Show16X16_3(line,column,niu);break;}
  case 10:{Show16X16_3(line,column,hu);break;}
  case 11:{Show16X16_3(line,column,tu);break;}
 } 
}
/*-----------------------------------------------------------------*/

void ChangeToLCD6(uch line,uch column,uch data)//阴历月转换
{  
 data=data%12;                 
 switch(data)
 {
  case 0:{Show16X16_2(line,column,zheng);break;}
  case 1:{Show16X16_2(line,column,er);break;}
  case 2:{Show16X16_2(line,column,san);break;}
  case 3:{Show16X16_2(line,column,si);break;}
  case 4:{Show16X16_2(line,column,wu);break;}
  case 5:{Show16X16_2(line,column,liu);break;}
  case 6:{Show16X16_2(line,column,qqi);break;}
  case 7:{Show16X16_2(line,column,ba);break;}
  case 8:{Show16X16_2(line,column,jiu);break;}
  case 9:{Show16X16_2(line,column,shi);break;}
  case 10:{Show16X16_2(line,column,shiyi);break;}
  case 11:{Show16X16_2(line,column,la);break;}
 } 
}
/*-----------------------------------------------------------------*/

void ChangeToLCD7(uch line,uch column,uch data)//阴历日
{  
 data=data%12;                 
 switch(data)
 {
  case 0:{Show16X16_2(line,column,yi);break;}
  case 1:{Show16X16_2(line,column,er);break;}
  case 2:{Show16X16_2(line,column,san);break;}
  case 3:{Show16X16_2(line,column,si);break;}
  case 4:{Show16X16_2(line,column,wu);break;}
  case 5:{Show16X16_2(line,column,liu);break;}
  case 6:{Show16X16_2(line,column,qqi);break;}
  case 7:{Show16X16_2(line,column,ba);break;}
  case 8:{Show16X16_2(line,column,jiu);break;}
  case 9:{Show16X16_2(line,column,shi);break;}
 } 
}
/*-----------------------------------------------------------------*/

void ChangeToLCD8(uch line,uch column,uch data)//阴历日十位
{  
 data=data%3;                 
 switch(data)
 {
  case 0:{Show16X16_2(line,column,chu);break;}
  case 1:{Show16X16_2(line,column,er);break;}
  case 2:{Show16X16_2(line,column,san);break;}
 } 
}
/*-----------------------------------------------------------------*/

程序结束

三,总结

           到现在为止,我对KS0108系列液晶的操作已经基本掌握了,并可以熟练应用.

但是本程序中阳历转阴历的程序还是不对,我想不出更好的转换办法,希望大家能提供方法完善.

由于篇幅原因,没有将阳历转阴历的程序,和液晶字库的程序附载上面,如有需要的可以联系我.

偶尔看到网上有张八路数字抢答器的图,但是没有完善,不过我觉得思路满好的,所以做了点修改,并用PROTEUS模拟了出来,供大家学习与讨论.

一.原理图

二.原理说明

            本电路的核心主要是74HC374这块芯片,他叫八路上升沿D触发器,OE为低电平时,工作正常,当CLK端有上升沿时,输出随输入变化。左边部分是有CD40106组成的振荡器，R4和R5两电阻为10K，电容为0.1uF，产生的频率大约为1KHz，他主要提供上升沿。

            在没人按抢答开关时，74HC374的输入端都为低电平，输出端也都是低电平，通过CD4078或非门反向，输出高电平，经过R1\10K和R3\1K分压后，CD4011与非门的一输入端为高电平，使能4011。当有人按抢答器时，即相应的一路74HC374的输入为高电平，随着上升沿到来，相应的一路输出也为高电平，指示灯亮，那么CD4078的输出为低电平，从而把4011的一端输入也拉低，4011的输出总是为高，即封锁了74HC374，那么后面的人再按抢答器就没有用了。当按下复位按键时，给4011的一输入端一个高电平，74HC374的输出跟随输入都为低电平，4078重新输出高电平，抢答器又等待按下。。。

三.总结

           原理很简单，但却很实用，可靠性很高，值得推荐！

引言 

       网上有很多一线总线的产品,我觉得这项技术的前景不错,自己用C也写了一个测温的程序.

并通过PROTEUS进行了仿真.

       搞了很多天,终于搞出来了,心里高兴的很,拿出来晒一下!

一.   原理介绍

说明:

1.单片机采用PIC16F877A,主要是由于液晶显示需要自己写字库,所以需要大容量的EEPROM,而他有8K字节.

2.液晶使用的是KS0108控制器系列,他的指令比较简单,性价比较高.

3.温度传感器采用的是1-WIRE总线技术的DS18B20,测的温度分辨率高.

附另外两张效果图

二.   器件介绍

       DS18B20的相关资料

       读写时序复位时序操作ROM的指令内部框图读出数据说明

KS0108控制器相关资料:

三.   程序

/*************************************************************
        * 标题：温度测量系统                                         *
        * 作者：Wujieflash                                              *
        * 日期：2008年1月8日                                        *
        * 版本：V1.0                                                       *
        * 说明：①单片机：PIC16F877A                         *               
        *            ②液晶；  KS0108控制器                       *
        *            ③传感器：DS18B20                              *
*******************************************************************/
#include <pic.h>

__CONFIG(0x1832);       
//芯片配置字，看门狗关，上电延时开，掉电检测关，低压编程关，加密，4M晶体HS振荡

#define E    RC0        //液晶使能端
#define RW   RC1        //读写控制端
#define DI   RC2        //数据/指令通道
#define CSA  RC3        //片选
#define CSB  RC4        //片选
#define nop() asm("nop")
#define  uch unsigned char                      //给unsigned char起别名 uch
# define DQ RA0                                 //定义18B20数据端口
# define DQ_DIR TRISA0                          //定义18B20D口方向寄存器
# define DQ_HIGH() DQ_DIR =1                    //设置数据口为输入
# define DQ_LOW() DQ = 0; DQ_DIR = 0            //设置数据口为输出
uch TLV=0 ;                            //采集到的温度高8位
uch THV=0;                             //采集到的温度低8位
uch TZ=0;                                 //转换后的温度值整数部分                    
int val1=35,val2=10;

//字库
/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
const unsigned char wen[]={0x10,0x21,0x86,0x70,0x00,0x7E,0x4A,0x4A,0x4A,0x4A,0x4A,0x7E,0x00,0x00,0x00,0x00,0x02,0xFE,0x01,0x40,0x7F,0x41,0x41,0x7F,0x41,0x41,0x7F,0x41,0x41,0x7F,0x40,0x00};//温
const unsigned char du[]={0x00,0x00,0xFC,0x04,0x24,0x24,0xFC,0xA5,0xA6,0xA4,0xFC,0x24,0x24,0x24,0x04,0x00,0x80,0x60,0x1F,0x80,0x80,0x42,0x46,0x2A,0x12,0x12,0x2A,0x26,0x42,0xC0,0x40,0x00};/*"度"*/
const unsigned char ce[]={0x08,0x31,0x86,0x60,0x00,0xFE,0x02,0xF2,0x02,0xFE,0x00,0xF8,0x00,0x00,0xFF,0x00,0x04,0xFC,0x03,0x00,0x80,0x47,0x30,0x0F,0x10,0x67,0x00,0x07,0x40,0x80,0x7F,0x00};/*"测"*/
const unsigned char liang[]={0x40,0x40,0x40,0xDF,0x55,0x55,0x55,0xD5,0x55,0x55,0x55,0xDF,0x40,0x40,0x40,0x00,0x40,0x40,0x40,0x57,0x55,0x55,0x55,0x7F,0x55,0x55,0x55,0x57,0x50,0x40,0x40,0x00};/*"量"*/
const unsigned char xi[]={0x00,0x00,0x02,0x22,0xB2,0xAA,0x66,0x62,0x22,0x11,0x4D,0x81,0x01,0x01,0x00,0x00,0x00,0x40,0x21,0x13,0x09,0x05,0x41,0x81,0x7F,0x01,0x05,0x09,0x13,0x62,0x00,0x00};/*"系"*/
const unsigned char tong[]={0x20,0x30,0x2C,0xA3,0x60,0x10,0x84,0xC4,0xA4,0x9D,0x86,0x84,0xA4,0xC4,0x84,0x00,0x20,0x22,0x23,0x12,0x12,0x92,0x40,0x30,0x0F,0x00,0x00,0x3F,0x40,0x41,0x70,0x00};/*"统"*/
const unsigned char zuo[]={0x80,0x40,0x20,0xF8,0x07,0x22,0x18,0x0C,0xFB,0x48,0x48,0x48,0x68,0x48,0x08,0x00,0x00,0x00,0x00,0xFF,0x00,0x00,0x00,0x00,0xFF,0x04,0x04,0x04,0x04,0x06,0x04,0x00};//作
const unsigned char zhe[]={0x00,0x20,0x24,0x24,0x24,0x24,0xA4,0xBF,0x64,0x24,0x34,0x28,0x26,0x24,0x20,0x00,0x04,0x04,0x04,0x02,0x02,0xFF,0x49,0x49,0x49,0x49,0x49,0x49,0xFF,0x00,0x00,0x00};//者
const unsigned char ban[]={0x00,0xFE,0x90,0x90,0x9E,0x10,0x10,0xFE,0xE2,0x22,0x22,0x21,0xE1,0x21,0x00,0x00,0x40,0x3F,0x00,0x00,0x5F,0x20,0x98,0x47,0x20,0x13,0x0C,0x1B,0x60,0xC0,0x40,0x00};//版
const unsigned char ben[]={0x08,0x08,0x08,0x08,0x08,0xC8,0x38,0xFF,0x18,0x68,0x88,0x08,0x08,0x08,0x08,0x00,0x08,0x08,0x04,0x02,0x05,0x04,0x04,0x7F,0x04,0x04,0x04,0x03,0x06,0x0C,0x04,0x00};//本
const unsigned char zheng[]={0x00,0x02,0x02,0xC2,0x02,0x02,0x02,0x02,0xFE,0x82,0x82,0x82,0x82,0x82,0x02,0x00,0x20,0x20,0x20,0x3F,0x20,0x20,0x20,0x20,0x3F,0x20,0x20,0x20,0x20,0x20,0x20,0x00};//正
const unsigned char zai[]={0x00,0x04,0x04,0xC4,0x64,0x9C,0x87,0x84,0x84,0xE4,0x84,0x84,0x84,0x84,0x04,0x00,0x04,0x02,0x01,0x7F,0x00,0x20,0x20,0x20,0x20,0x3F,0x20,0x20,0x20,0x20,0x20,0x00};//在
const unsigned char chu[]={0x00,0x08,0x88,0xC9,0x2E,0x98,0x48,0x00,0x08,0x08,0xF8,0x08,0x08,0xFC,0x08,0x00,0x02,0x01,0x00,0x7F,0x01,0x02,0x44,0x20,0x10,0x0C,0x03,0x20,0x40,0x3F,0x00,0x00};//初
const unsigned char shi[]={0x10,0x90,0x70,0x1F,0x12,0xF0,0x00,0x20,0x70,0x28,0x27,0x22,0x28,0x70,0x20,0x00,0x40,0x21,0x12,0x0C,0x06,0x09,0x30,0x00,0x7F,0x21,0x21,0x21,0x21,0x7F,0x00,0x00};//使
const unsigned char hua[]={0x80,0x40,0x20,0xF8,0x07,0x02,0x00,0x00,0xFF,0xC0,0x60,0x30,0x1C,0x08,0x00,0x00,0x00,0x00,0x00,0x7F,0x00,0x04,0x02,0x01,0x3F,0x40,0x40,0x40,0x40,0x78,0x00,0x00};//化
const unsigned char shang[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x40,0x40,0x40,0x40,0x40,0x00,0x00,0x00,0x00,0x40,0x40,0x40,0x40,0x40,0x40,0x7F,0x40,0x40,0x40,0x40,0x40,0x60,0x40,0x00};//上
const unsigned char xia[]={0x00,0x02,0x02,0x02,0x02,0x02,0x02,0xFE,0x22,0x62,0xC2,0x82,0x02,0x03,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00};//下
const unsigned char xian[]={0xFE,0x02,0x32,0x4E,0x82,0x00,0xFE,0x4A,0xCA,0x4A,0x4A,0x4A,0x7E,0x00,0x00,0x00,0xFF,0x00,0x02,0x04,0x03,0x00,0xFF,0x40,0x20,0x03,0x0C,0x12,0x21,0x60,0x20,0x00};//限
const unsigned char zhu[]={0x10,0x60,0x01,0x86,0x60,0x08,0x08,0x08,0x09,0xFE,0x08,0x08,0x08,0x08,0x08,0x00,0x04,0x04,0xFE,0x01,0x40,0x40,0x41,0x41,0x41,0x7F,0x41,0x41,0x41,0x41,0x40,0x00};//注
const unsigned char yi[]={0x10,0x10,0x12,0xD2,0x56,0x5A,0xD2,0x53,0x52,0x5A,0x56,0xD2,0x12,0x12,0x10,0x00,0x00,0x20,0x38,0x03,0x3A,0x42,0x42,0x4B,0x52,0x42,0x42,0x63,0x08,0x30,0x00,0x00};//意
const unsigned char she[]={0x40,0x41,0xCE,0x04,0x00,0x80,0x40,0xBE,0x82,0x82,0x82,0xBE,0xC0,0x40,0x40,0x00,0x00,0x00,0x7F,0x20,0x90,0x80,0x40,0x43,0x2C,0x10,0x10,0x2C,0x43,0xC0,0x40,0x00};//设
const unsigned char zhi[]={0x00,0x20,0x2F,0xA9,0xA9,0xAF,0xE9,0xB9,0xA9,0xAF,0xA9,0xA9,0x2F,0x20,0x00,0x00,0x80,0x80,0x80,0xFF,0xAA,0xAA,0xAA,0xAA,0xAA,0xAA,0xAA,0xFF,0x80,0x80,0x80,0x00};//置
const unsigned char dang[]={0x00,0x00,0x40,0x42,0x5C,0x48,0x40,0x40,0x7F,0x40,0x50,0x4E,0x44,0xC0,0x00,0x00,0x00,0x00,0x20,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x7F,0x00,0x00};//当
const unsigned char qian[]={0x08,0x08,0xE8,0xA8,0xA9,0xAE,0xEA,0x08,0x08,0xC8,0x0C,0x0B,0xEA,0x08,0x08,0x00,0x00,0x00,0x7F,0x04,0x24,0x44,0x3F,0x00,0x00,0x1F,0x40,0x80,0x7F,0x00,0x00,0x00};//前 
const unsigned char fang[]={0x00,0xFE,0x22,0x5A,0x86,0x02,0x08,0x08,0xF9,0x8E,0x88,0x88,0x88,0x08,0x08,0x00,0x00,0xFF,0x04,0x08,0x47,0x20,0x18,0x07,0x00,0x00,0x40,0x80,0x7F,0x00,0x00,0x00};//防
const unsigned char shu[]={0x00,0x00,0x40,0x5F,0x55,0x55,0xF5,0x55,0x55,0x55,0xD5,0x5F,0x40,0x00,0x00,0x00,0x11,0x11,0x09,0x09,0xFD,0x55,0x57,0x57,0x55,0x55,0x55,0xFD,0x01,0x01,0x01,0x00};//暑
const unsigned char bao[]={0x40,0x20,0xF8,0x17,0x82,0x80,0xBE,0xA2,0xA2,0xE2,0xA2,0xA2,0xBE,0x80,0x80,0x00,0x00,0x00,0x7F,0x00,0x20,0x10,0x08,0x06,0x01,0x7F,0x03,0x0C,0x18,0x30,0x10,0x00};//保
const unsigned char nuan[]={0x00,0xFC,0x44,0x44,0xFC,0x80,0xA6,0xAA,0xE2,0xA6,0xAA,0xA1,0xA9,0xA5,0x80,0x00,0x00,0x0F,0x04,0x04,0x4F,0x20,0x58,0x46,0x27,0x2A,0x12,0x1A,0x26,0x62,0x20,0x00};//暖
const unsigned char nononono[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};//
const unsigned char danwei_c[]={0x00,0x02,0x05,0xE2,0x18,0x04,0x02,0x02,0x02,0x02,0x02,0x02,0x04,0x1E,0x00,0x00,0x00,0x00,0x00,0x07,0x18,0x20,0x40,0x40,0x40,0x40,0x40,0x40,0x20,0x18,0x00,0x00};//单位
const unsigned char maohao[]={0x00,0x00,0x00,0xC0,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x30,0x00,0x00,0x00};//':'
const unsigned char dian[]={0x00,0x00,0x00,0x80,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x03,0x00,0x00,0x00};//'.'
const unsigned char dw[]={0xF8,0x08,0x00,0xF8,0x00,0x08,0xF8,0x00,0x03,0x3C,0x07,0x00,0x07,0x3C,0x03,0x00};//‘W'
const unsigned char uu[]={0x80,0x80,0x00,0x00,0x00,0x80,0x80,0x00,0x00,0x1F,0x20,0x20,0x20,0x10,0x3F,0x20};//'u'
const unsigned char jj[]={0x00,0x00,0x00,0x80,0x98,0x98,0x00,0x00,0x00,0xC0,0x80,0x80,0x80,0x7F,0x00,0x00};//'j'
const unsigned char ii[]={0x00,0x80,0x98,0x98,0x00,0x00,0x00,0x00,0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00};//'i'
const unsigned char ee[]={0x00,0x00,0x80,0x80,0x80,0x80,0x00,0x00,0x00,0x1F,0x22,0x22,0x22,0x22,0x13,0x00};//'e'
const unsigned char ff[]={0x00,0x80,0x80,0xF0,0x88,0x88,0x88,0x18,0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00};//'f'
const unsigned char ll[]={0x00,0x08,0x08,0xF8,0x00,0x00,0x00,0x00,0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00};//'l'
const unsigned char aa[]={0x00,0x00,0x80,0x80,0x80,0x80,0x00,0x00,0x00,0x19,0x24,0x22,0x22,0x22,0x3F,0x20};//'a'
const unsigned char ss[]={0x00,0x00,0x80,0x80,0x80,0x80,0x80,0x00,0x00,0x33,0x24,0x24,0x24,0x24,0x19,0x00};//'s'
const unsigned char hh[]={0x08,0xF8,0x00,0x80,0x80,0x80,0x00,0x00,0x20,0x3F,0x21,0x00,0x00,0x20,0x3F,0x20};//'h'
const unsigned char vv[]={0x80,0x80,0x80,0x00,0x00,0x80,0x80,0x80,0x00,0x01,0x0E,0x30,0x08,0x06,0x01,0x00};//'v'
const unsigned char zhenghao1[]={0x00,0x00,0x00,0xF0,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x1F,0x01,0x01,0x01,0x00};//'+'
const unsigned char fuhao1[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01};//'-'
const unsigned char xinghao[]={0x40,0x40,0x80,0xF0,0x80,0x40,0x40,0x00,0x02,0x02,0x01,0x0F,0x01,0x02,0x02,0x00};//"*'
const unsigned char s1[]={0x00,0x10,0x10,0xF8,0x00,0x00,0x00,0x00,0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00};//'1'
const unsigned char s0[]={0x00,0xE0,0x10,0x08,0x08,0x10,0xE0,0x00,0x00,0x0F,0x10,0x20,0x20,0x10,0x0F,0x00};//'0' 
const unsigned char s2[]={0x00,0x70,0x08,0x08,0x08,0x88,0x70,0x00,0x00,0x30,0x28,0x24,0x22,0x21,0x30,0x00};/*"2",0*/
const unsigned char s3[]={0x00,0x30,0x08,0x88,0x88,0x48,0x30,0x00,0x00,0x18,0x20,0x20,0x20,0x11,0x0E,0x00};/*"3",1*/
const unsigned char s4[]={0x00,0x00,0xC0,0x20,0x10,0xF8,0x00,0x00,0x00,0x07,0x04,0x24,0x24,0x3F,0x24,0x00};/*"4",2*/
const unsigned char s5[]={0x00,0xF8,0x08,0x88,0x88,0x08,0x08,0x00,0x00,0x19,0x21,0x20,0x20,0x11,0x0E,0x00};/*"5",3*/
const unsigned char s6[]={0x00,0xE0,0x10,0x88,0x88,0x18,0x00,0x00,0x00,0x0F,0x11,0x20,0x20,0x11,0x0E,0x00};/*"6",4*/
const unsigned char s7[]={0x00,0x38,0x08,0x08,0xC8,0x38,0x08,0x00,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x00};/*"7",5*/
const unsigned char s8[]={0x00,0x70,0x88,0x08,0x08,0x88,0x70,0x00,0x00,0x1C,0x22,0x21,0x21,0x22,0x1C,0x00};/*"8",6*/
const unsigned char s9[]={0x00,0xE0,0x10,0x08,0x08,0x10,0xE0,0x00,0x00,0x00,0x31,0x22,0x22,0x11,0x0F,0x00};/*"9",7*/ 
const unsigned char nono[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};//空的
const unsigned char juhao[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x30,0x00,0x00,0x00,0x00,0x00};//'.'
const unsigned char zhenghao[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};//'+'
const unsigned char fuhao[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};//'-'
const unsigned char ss0[]={0x00,0x00,0x00,0x00,0x00,0x80,0xC0,0x40,0x40,0x40,0xC0,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0xFE,0x0F,0x01,0x00,0x00,0x00,0x00,0x00,0x01,0x07,0xFE,0xF0,0x00,0x00,0x00,0x1F,0xFF,0xE0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0xFF,0x1F,0x00,0x00,0x00,0x00,0x00,0x01,0x03,0x06,0x04,0x04,0x04,0x06,0x03,0x01,0x00,0x00,0x00};//0
const unsigned char ss1[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x01,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x04,0x04,0x06,0x07,0x07,0x06,0x04,0x04,0x04,0x00,0x00,0x00};//1
const unsigned char ss2[]={0x00,0x00,0x00,0x00,0x80,0x40,0x40,0x40,0x40,0x40,0xC0,0x80,0x80,0x00,0x00,0x00,0x00,0x00,0x1E,0x19,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC1,0x7F,0x3E,0x00,0x00,0x00,0x00,0x00,0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01,0x00,0x00,0xE0,0x00,0x00,0x00,0x00,0x07,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x07,0x01,0x00,0x00};//2
const unsigned char ss3[]={0x00,0x00,0x00,0x80,0x80,0x40,0x40,0x40,0x40,0xC0,0x80,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x0F,0x0F,0x00,0x00,0x80,0x80,0x80,0xC0,0x61,0x3F,0x1E,0x00,0x00,0x00,0x00,0x00,0xE0,0xE0,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x03,0xFE,0x78,0x00,0x00,0x00,0x00,0x01,0x03,0x02,0x04,0x04,0x04,0x04,0x04,0x02,0x03,0x01,0x00,0x00,0x00};//3
const unsigned char ss4[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xC0,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x60,0x30,0x0C,0x02,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x10,0x1C,0x12,0x11,0x10,0x10,0x10,0x10,0xFF,0xFF,0xFF,0x10,0x10,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x08,0x08,0x0F,0x0F,0x0F,0x08,0x08,0x08,0x00};//4
const unsigned char ss5[]={0x00,0x00,0x00,0x00,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0x00,0x00,0x00,0x00,0x00,0xF8,0x87,0x40,0x20,0x20,0x20,0x20,0x60,0xC0,0x80,0x00,0x00,0x00,0x00,0x00,0xE0,0x61,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xFF,0x7E,0x00,0x00,0x00,0x00,0x01,0x02,0x04,0x04,0x04,0x04,0x04,0x04,0x02,0x03,0x01,0x00,0x00,0x00};//5
const unsigned char ss6[]={0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xC0,0x40,0x40,0x40,0x40,0x80,0x00,0x00,0x00,0x00,0x00,0xE0,0xFC,0x0E,0x81,0x80,0x40,0x40,0x40,0x40,0xC0,0x83,0x03,0x00,0x00,0x00,0x00,0x3F,0xFF,0xC3,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0xFF,0x7E,0x00,0x00,0x00,0x00,0x00,0x01,0x03,0x06,0x04,0x04,0x04,0x04,0x02,0x03,0x01,0x00,0x00};//6
const unsigned char ss7[]={0x00,0x00,0x00,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0x00,0x00,0x00,0x00,0x0F,0x03,0x01,0x00,0x00,0x00,0x80,0x60,0x18,0x06,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFC,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x07,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};//7
const unsigned char ss8[]={0x00,0x00,0x00,0x00,0x80,0xC0,0x40,0x40,0x40,0x40,0xC0,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x1E,0x3F,0x71,0xE0,0xC0,0x80,0x80,0x80,0x80,0x61,0x3F,0x1E,0x00,0x00,0x00,0xF8,0xFC,0x06,0x03,0x01,0x00,0x01,0x01,0x03,0x07,0x0E,0xFC,0xF8,0x00,0x00,0x00,0x00,0x01,0x03,0x02,0x04,0x04,0x04,0x04,0x04,0x02,0x03,0x01,0x00,0x00,0x00};//8
const unsigned char ss9[]={0x00,0x00,0x00,0x80,0x80,0x40,0x40,0x40,0x40,0x40,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0xFC,0xFF,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x83,0xFE,0xF8,0x00,0x00,0x00,0x00,0x81,0x83,0x06,0x04,0x04,0x04,0x04,0x02,0x83,0xF1,0x7F,0x0F,0x00,0x00,0x00,0x00,0x03,0x03,0x04,0x04,0x04,0x04,0x06,0x03,0x01,0x00,0x00,0x00,0x00,0x00};//9
const unsigned char nonono[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};//9
const unsigned char danwei_c1[]={0x00,0x00,0x00,0x00,0x00,0xE0,0x10,0x10,0x10,0xF0,0x00,0x00,0x00,0x80,0xc0,0x60,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x01,0x01,0x00,0xfC,0xff,0x07,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1f,0x7f,0xf0,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x03,0x03};//℃
const unsigned char danwei_c2[]={0x30,0x30,0x10,0x10,0x10,0x20,0x20,0x20,0x40,0x80,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x40,0x00,0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00,0x06,0x06,0x06,0x06,0x06,0x06,0x02,0x03,0x01,0x00,0x00,0x00,0x00,0x00,0x00};
/*------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/

////////////////////////基本子函数///////////////////////
//延时
void delay(char x,char y)
{
  char z;
  do{
      z=y;
      do{;}while(--z);
     }while(--x);
 }
//其指令时间为：7+（3*（Y-1）+7）*（X-1）如果再加上函数调用的call 指令、页面设定、传递参数花掉的7 个指令。
//则是：14+（3*（Y-1）+7）*（X-1）。

//--------------------------------------------------

//系统初始化函数
void init()
{
  ADCON1=0X07;                                //设置A口为普通数字口
  TRISA=0X00;                                 //设置A口方向为输出
  TRISD=0X00;                                 //设置D口方向为输出
}

//-----------------------------------------------
//复位DS18B20函数(*一定要注意延时，我曾经在这上差点搞晕*）
reset(void)           
{
  char presence=1;
  while(presence)
  {
    DQ_LOW() ;                                //主机拉至低电平
    delay(2,90);                              //延时>480503us
    DQ_HIGH();                                //释放总线等电阻拉高总线,并保持15~60us
    delay(2,8);                               //延时>60us
    if(DQ==1) presence=1;                     //没有接收到应答信号，继续复位
    else presence=0;                          //接收到应答信号
    delay(2,70);                              //延时>240us
   }
  }

//-----------------------------------------------
//写18b20写字节函数
void write_byte(uch val)
{
 uch i;
 uch temp;
 for(i=8;i>0;i--)
 {
   temp=val&0x01;                            //最低位移出
   DQ_LOW();
   NOP();
   NOP();
   NOP();
   NOP();
   NOP();                                    //从高拉至低电平,产生写时间隙
   if(temp==1)  DQ_HIGH();                   //如果写1,拉高电平
   delay(2,7);                               //延时>60us
   DQ_HIGH();
   NOP();
   NOP();
   val=val>>1;                               //右移一位
  }
}

//------------------------------------------------
//18b20读字节函数
uch read_byte(void)
{
 uch i;
 uch value=0;                                //读出温度
 static bit j;
 for(i=8;i>0;i--)
 {
   value>>=1;
   DQ_LOW();
   NOP();
   NOP();
   NOP();
   NOP();                                   //6us
   DQ_HIGH();                               //拉至高电平
   NOP();
   NOP();
   NOP();                                //4us
   j=DQ;
   if(j) value|=0x80;
   delay(2,7);                             //63us
  }
  return(value);
}

//-------------------------------------------------
//启动温度转换函数
void get_temp()
{
int i;
DQ_HIGH();
reset();                                 //复位等待从机应答
write_byte(0XCC);                        //忽略ROM匹配
write_byte(0X44);                        //发送温度转化命令 
for(i=10;i>0;i--)
    {
       
        delay(201,132);                      
    }
reset();                                 //再次复位，等待从机应答
write_byte(0XCC);                        //忽略ROM匹配
write_byte(0XBE);                        //发送读温度命令
TLV=read_byte();                         //读出温度低8
THV=read_byte();                         //读出温度高8位
DQ_HIGH();                               //释放总线
TZ=(TLV>>4)|(THV<<4);                   //温度整数部分

}

//--------------------------------------------------
void LCDdelay()
{
 unsigned int i=500;
 while(i--)
 {;}
}
/*----------------------------------------------------*/

//状态检查
void CheckState()
{
 unsigned int dat;
 RW=1;                             //读状态
 DI=0;
 TRISB=0xff;                       //设置口为输入
 while(1)
 {
  E=1;                          //高电平读数据
  dat=PORTB&0x90;               //当4、7位为0时为正常状态
  E=0;
  if(dat==0x00)break;
 }
 TRISB=0x00;                       //恢复口为输出
}
/*----------------------------------------------------*/

//写显示数据
//dat:显示数据
void WriteData(unsigned char dat)
{
 CheckState();
 DI=1;                            //写数据
 RW=0;
 PORTB=dat;
 E=1;
 E=0;
}
/*---------------------------------------------------*/

//写指令
//command:操作LCD的指令
void WriteCommand(unsigned char dat)
{
 CheckState();
 RW=0;                          //写指令
 PORTB=dat;
 E=1;
 E=0;
}
/*---------------------------------------------------*/

//设定页地址----X:0--7
void SetLine(unsigned char line)
{
 line=line&0x07;               //0<=line<=7 
 line=line|0xb8;
 WriteCommand(line);
}
/*---------------------------------------------------*/

//设定列地址----Y:0--63
void SetColumn(unsigned char column)
{
 column=column&0x3f;          //0<=column<=63
 column=column|0x40;
 WriteCommand(column);
}
/*--------------------------------------------------*/

//设定开始行
void SetStartLine(unsigned char startline)
{
 startline=startline&0x3f;   //0<=startline<=63
 startline=startline|0xc0;
 WriteCommand(startline);
}
/*--------------------------------------------------*/

//开关显示
//1:开显示  0:关显示
void SetOnOff(unsigned char state)
{
 state=state|0x3e;
 WriteCommand(state);
}
/*--------------------------------------------------*/

//选择屏幕
//screen: 1:左屏 2:右屏
void SlectScreen(unsigned char screen)
{
 switch(screen)
 {
  case 1: CSA=0;
     CSB=1;//左屏
     break;
  case 2: CSA=1;
    CSB=0;//右屏
    break;
 }
}
/*--------------------------------------------------*/

//清屏
//screen: 1:左屏 2:右屏
void ClearScreen(unsigned char screen)
{
 unsigned char i,j;
 SlectScreen(screen);
 for(i=0;i<8;i++)
 {
  SetLine(i);
  for(j=0;j<64;j++)
  {
   WriteData(0x00);
   WriteData(0x00);
  }
 }
}
/*---------------------------------------------------*/

//显示一个16X16的汉字
void Show16X16(unsigned char line,unsigned char column,const unsigned char *pt)
{
 unsigned char i,column_temp;
 column_temp=column;
 SlectScreen(1);                      //选通左屏
 SetColumn(column);                   //设置起始列
 SetLine(line);                       //设置行
 for(i=0;i<16;i++)
 {
  if(column>=64)                   //如果列>=64，则选通右屏
  {
   SlectScreen(2);
   column=column%64;            //设置右屏起始列
   SetColumn(column);
   SetLine(line);
  } 
  WriteData(*pt);                  //写数据
  *pt++;
  column++;
 }
 SlectScreen(1);
 SetLine(line+1);                    //设置汉字下半部分显示页
 column=column_temp;
 SetColumn(column);
 for(i=0;i<16;i++)
 {
  if(column>=64)
  {
   SlectScreen(2);
   column=column%64;
   SetColumn(column);
   SetLine(line+1);
  } 
  WriteData(*pt);
  *pt++;
  column++;
 }
}
/*-------------------------------------------------------*/

//显示一个8X16的字符
void Show8X16(unsigned char line,unsigned char column,const unsigned char *pt)
{
 unsigned char i,column_temp;
 column_temp=column;
 SlectScreen(1);                          //选通左屏
 SetColumn(column);                       //设置起始列
 SetLine(line);                           //设置行
 for(i=0;i<8;i++)
 {
  if(column>=64)                       //如果列>=64，则选通右屏
  {
   SlectScreen(2);
   column=column%64;                //设置右屏起始列
   SetColumn(column);
   SetLine(line);
  } 
  WriteData(*pt);                      //写数据
  *pt++;
  column++;
 }
 SlectScreen(1);
 SetLine(line+1);                         //设置汉字下半部分显示页
 column=column_temp;
 SetColumn(column);
 for(i=0;i<8;i++)
 {
  if(column>=64)
  {
   SlectScreen(2);
   column=column%64;
   SetColumn(column);
   SetLine(line+1);
  } 
  WriteData(*pt);
  *pt++;
  column++;
 }
}
/*-------------------------------------------------------*/

//显示一个16X32的字符
void Show16X32(unsigned char line,unsigned char column,const unsigned char *pt)
{
 unsigned char i,column_temp1,column_temp2,column_temp3;
 column_temp1=column;
 column_temp2=column;
 column_temp3=column;
 SlectScreen(1);                         //选通左屏
 SetColumn(column);                      //设置起始列
 SetLine(line);                          //设置行
 for(i=0;i<16;i++)
 {
  if(column>=64)                      //如果列>=64，则选通右屏
  {
   SlectScreen(2);
   column=column%64;               //设置右屏起始列
   SetColumn(column);
   SetLine(line);
  } 
  WriteData(*pt);                     //写数据
  *pt++;
  column++;
 }
 SlectScreen(1);
 SetLine(line+1);
 column=column_temp1;
 SetColumn(column);
 for(i=0;i<16;i++)
 {
  if(column>=64)
  {
   SlectScreen(2);
   column=column%64;
   SetColumn(column);
   SetLine(line+1);
  } 
  WriteData(*pt);
  *pt++;
  column++;
 }
 SlectScreen(1);
 SetLine(line+2);
 column=column_temp2;
 SetColumn(column);
 for(i=0;i<16;i++)
 {
  if(column>=64)
  {
   SlectScreen(2);
   column=column%64;
   SetColumn(column);
   SetLine(line+2);
  } 
  WriteData(*pt);
  *pt++;
  column++;
 }
 SlectScreen(1);
 SetLine(line+3);
 column=column_temp3;
 SetColumn(column);
 for(i=0;i<16;i++)
 {
  if(column>=64)
  {
   SlectScreen(2);
   column=column%64;
   SetColumn(column);
   SetLine(line+3);
  } 
  WriteData(*pt);
  *pt++;
  column++;
 }
}
/*-------------------------------------------------------*/

//写入变化的参数子程序
void ChangeTemp1(int val)
{
 int D_ge,D_shi,D_bai;
 if(val>0)
 {
  Show8X16(2,72,zhenghao1);          //如果大于0，显示正号
 }
 if(val<0)
 {
  val=0-val;//去除负号
  Show8X16(2,72,fuhao1);             //如果小于0，显示负号
 }
 if(val==0)
 {
  Show8X16(2,72,nono);               //等于0不显示符号
 }
 D_ge=val%10;                           //取个位
 D_shi=val%100/10;                      //取十位
 D_bai=val/100;                         //取百位
 
 switch(D_ge)
 {
  case 0:{Show8X16(2,96,s0);break;}
  case 1:{Show8X16(2,96,s1);break;}
  case 2:{Show8X16(2,96,s2);break;}
  case 3:{Show8X16(2,96,s3);break;}
  case 4:{Show8X16(2,96,s4);break;}
  case 5:{Show8X16(2,96,s5);break;}
  case 6:{Show8X16(2,96,s6);break;}
  case 7:{Show8X16(2,96,s7);break;}
  case 8:{Show8X16(2,96,s8);break;}
  case 9:{Show8X16(2,96,s9);break;}
 }
 switch(D_shi)
 {
  case 0:{Show8X16(2,88,s0);break;}
  case 1:{Show8X16(2,88,s1);break;}
  case 2:{Show8X16(2,88,s2);break;}
  case 3:{Show8X16(2,88,s3);break;}
  case 4:{Show8X16(2,88,s4);break;}
  case 5:{Show8X16(2,88,s5);break;}
  case 6:{Show8X16(2,88,s6);break;}
  case 7:{Show8X16(2,88,s7);break;}
  case 8:{Show8X16(2,88,s8);break;}
  case 9:{Show8X16(2,88,s9);break;}
 }
 switch(D_bai)
 {
  case 0:{Show8X16(2,80,s0);break;}
  case 1:{Show8X16(2,80,s1);break;}
  case 2:{Show8X16(2,80,s2);break;}
  case 3:{Show8X16(2,80,s3);break;}
  case 4:{Show8X16(2,80,s4);break;}
  case 5:{Show8X16(2,80,s5);break;}
  case 6:{Show8X16(2,80,s6);break;}
  case 7:{Show8X16(2,80,s7);break;}
  case 8:{Show8X16(2,80,s8);break;}
  case 9:{Show8X16(2,80,s9);break;}
 }
} 
/*-------------------------------------------------------*/

void ChangeTemp2(int val)
{
 int D_ge,D_shi,D_bai;
 if(val>0)
 {
  Show8X16(4,72,zhenghao1);
 }
 if(val<0)
 {
  val=0-val;
  Show8X16(4,72,fuhao1);
 }
 if(val==0)
 {
  Show8X16(4,72,nono);
 }
 D_ge=val%10;
 D_shi=val%100/10;
 D_bai=val/100;
 
 switch(D_ge)
 {
  case 0:{Show8X16(4,96,s0);break;}
  case 1:{Show8X16(4,96,s1);break;}
  case 2:{Show8X16(4,96,s2);break;}
  case 3:{Show8X16(4,96,s3);break;}
  case 4:{Show8X16(4,96,s4);break;}
  case 5:{Show8X16(4,96,s5);break;}
  case 6:{Show8X16(4,96,s6);break;}
  case 7:{Show8X16(4,96,s7);break;}
  case 8:{Show8X16(4,96,s8);break;}
  case 9:{Show8X16(4,96,s9);break;}
 }
 switch(D_shi)
 {
  case 0:{Show8X16(4,88,s0);break;}
  case 1:{Show8X16(4,88,s1);break;}
  case 2:{Show8X16(4,88,s2);break;}
  case 3:{Show8X16(4,88,s3);break;}
  case 4:{Show8X16(4,88,s4);break;}
  case 5:{Show8X16(4,88,s5);break;}
  case 6:{Show8X16(4,88,s6);break;}
  case 7:{Show8X16(4,88,s7);break;}
  case 8:{Show8X16(4,88,s8);break;}
  case 9:{Show8X16(4,88,s9);break;}
 }
 switch(D_bai)
 {
  case 0:{Show8X16(4,80,s0);break;}
  case 1:{Show8X16(4,80,s1);break;}
  case 2:{Show8X16(4,80,s2);break;}
  case 3:{Show8X16(4,80,s3);break;}
  case 4:{Show8X16(4,80,s4);break;}
  case 5:{Show8X16(4,80,s5);break;}
  case 6:{Show8X16(4,80,s6);break;}
  case 7:{Show8X16(4,80,s7);break;}
  case 8:{Show8X16(4,80,s8);break;}
  case 9:{Show8X16(4,80,s9);break;}
 }
}
/*-------------------------------------------------------*/

void ChangeTemp3(int val)
{
 int D_ge,D_shi,D_bai,sign;

 sign=val&0x80;
 val=val&0x7f;
 
 if(sign==0)
 {
  Show16X32(2,20,zhenghao);
 }
 if(sign)
 {
  val=(~val+1)&0x7f;
  Show16X32(2,20,fuhao);
 }
 if(val==0)
 {
  Show16X32(2,20,nonono);
 }
 D_ge=val%10;
 D_shi=val%100/10;
 D_bai=val/100;
 
 switch(D_ge)
 {
  case 0:{Show16X32(2,68,ss0);break;}
  case 1:{Show16X32(2,68,ss1);break;}
  case 2:{Show16X32(2,68,ss2);break;}
  case 3:{Show16X32(2,68,ss3);break;}
  case 4:{Show16X32(2,68,ss4);break;}
  case 5:{Show16X32(2,68,ss5);break;}
  case 6:{Show16X32(2,68,ss6);break;}
  case 7:{Show16X32(2,68,ss7);break;}
  case 8:{Show16X32(2,68,ss8);break;}
  case 9:{Show16X32(2,68,ss9);break;}
 }
 switch(D_shi)
 {
  case 0:{Show16X32(2,52,ss0);break;}
  case 1:{Show16X32(2,52,ss1);break;}
  case 2:{Show16X32(2,52,ss2);break;}
  case 3:{Show16X32(2,52,ss3);break;}
  case 4:{Show16X32(2,52,ss4);break;}
  case 5:{Show16X32(2,52,ss5);break;}
  case 6:{Show16X32(2,52,ss6);break;}
  case 7:{Show16X32(2,52,ss7);break;}
  case 8:{Show16X32(2,52,ss8);break;}
  case 9:{Show16X32(2,52,ss9);break;}
 }
 switch(D_bai)
 {
  case 0:{Show16X32(2,36,ss0);break;}
  case 1:{Show16X32(2,36,ss1);break;}
  case 2:{Show16X32(2,36,ss2);break;}
  case 3:{Show16X32(2,36,ss3);break;}
  case 4:{Show16X32(2,36,ss4);break;}
  case 5:{Show16X32(2,36,ss5);break;}
  case 6:{Show16X32(2,36,ss6);break;}
  case 7:{Show16X32(2,36,ss7);break;}
  case 8:{Show16X32(2,36,ss8);break;}
  case 9:{Show16X32(2,36,ss9);break;}
 }
 if(val>=val1)
 {
  Show16X16(6,32,zhu);
  Show16X16(6,48,yi);
  Show16X16(6,64,fang);
  Show16X16(6,80,shu);
 }
 if(val<=val2)
 {
  Show16X16(6,32,zhu);
  Show16X16(6,48,yi);
  Show16X16(6,64,bao);
  Show16X16(6,80,nuan);
 }
 if((val>val2)&&(val<val1))
 {
  Show16X16(6,32,nononono);
  Show16X16(6,48,nononono);
  Show16X16(6,64,nononono);
  Show16X16(6,80,nononono);
 }
}
/*-------------------------------------------------------*/

//显示第一页的内容
void LCDShow1()
{
 Show16X16(0,16,wen);//温
 Show16X16(0,32,du);//度
 Show16X16(0,48,ce);//测
 Show16X16(0,64,liang);//量
 Show16X16(0,80,xi);//系
 Show16X16(0,96,tong);//统
 Show16X16(2,1,zuo);//作
 Show16X16(2,17,zhe);//者
 Show8X16(2,33,maohao);//’：‘
 Show8X16(2,41,dw);//'w'
 Show8X16(2,49,uu);//'u'
 Show8X16(2,57,jj);//'j'
 Show8X16(2,65,ii);//'i'
 Show8X16(2,73,ee);//'e'
 Show8X16(2,81,ff);//'f'
 Show8X16(2,89,ll);//'l'
 Show8X16(2,97,aa);//'a'
 Show8X16(2,105,ss);//'s'
 Show8X16(2,113,hh);//'h'
 Show16X16(4,1,ban);//版
 Show16X16(4,17,ben);//本
 Show8X16(4,33,maohao);//'：’
 Show8X16(4,41,vv);//‘v'
 Show8X16(4,49,s1);//'1'
 Show8X16(4,57,juhao);//'.'
 Show8X16(4,65,s0);//'0'
 Show16X16(6,20,zheng);//正
 Show16X16(6,36,zai);//在
 Show16X16(6,52,chu);//初
 Show16X16(6,68,shi);//使
 Show16X16(6,84,hua);//化
 Show8X16(6,100,dian);//’。‘
 Show8X16(6,108,dian);//’。‘
 Show8X16(6,116,dian);//’。‘
}
/*----------------------------------------------------------*/

//显示第二页子程序
void LCDShow2()
{
 Show16X16(0,32,dang);//当
 Show16X16(0,48,qian);//前
 Show16X16(0,64,wen);//温
 Show16X16(0,80,du);//度
 //Show16X32(2,20,zhenghao);
 //Show16X32(2,52,ss0);
 //Show16X32(2,68,ss0);
 Show16X32(2,84,danwei_c1);//单位
 Show16X32(2,100,danwei_c2);
}
/*----------------------------------------------------------*/

//显示第三页子程序
void LCDShow3()
{
 Show16X16(0,48,she);//设 
 Show16X16(0,64,zhi);//置
 Show16X16(2,0,shang);//上
 Show16X16(2,16,xian);//限
 Show16X16(2,32,wen);//温
 Show16X16(2,48,du);//度
 Show8X16(2,64,maohao);//“：”
 ChangeTemp1(val1);//参数
 Show16X16(2,104,danwei_c);//单位
 Show16X16(4,0,xia);//下
 Show16X16(4,16,xian);//限
 Show16X16(4,32,wen);//温
 Show16X16(4,48,du);//度
 Show8X16(4,64,maohao);//“：”
 ChangeTemp2(val2);//参数
 Show16X16(4,104,danwei_c);//单位
}
/*---------------------------------------------------------*/

//LCD初始化子程序
void LCDinit()
{
 int i;
 PORTD=0x00;
 TRISB=0x00;
 PORTB=0x00;
 TRISC=0x80;
 PORTC=0x00;
 TRISC5=1;
 TRISC6=1;
 
 SetOnOff(1);//开显示
 LCDShow1();//初始画面
 for(i=30;i>0;i--)//延时
    {
        delay(201,132);                      
    }
}
/*----------------------------------------------------------*/
//主函数
void main()
{
    init();                              //调用系统初始化函数
    LCDinit();
 ClearScreen(1);//清屏
 ClearScreen(2);
 LCDShow2();//显示第二页
   while(1)
     {
       get_temp();                  //调用温度转换函数
       PORTD=TZ;
       ChangeTemp3(TZ);
       if(RC5==0)
       {
        while(1)
        {
         ClearScreen(1);
       ClearScreen(2);
       LCDShow3();
       while(1)//等待RC5键松开
    {
    if(RC5==1)break;
    }
    Show8X16(4,120,nono);
    Show8X16(2,120,xinghao);//显示星号，作指示
    while(1)
    {
     if(RC6==0)
     {
      val1++;
      if(val1>=128)
      {
       val1=128;
      }
    
       ChangeTemp1(val1);
     }
     if(RC7==0)
     {
      val1--;
      if(val1<=-55)
      {
       val1=-55;
      }
     ChangeTemp1(val1);
     }
     while(1)
     {
      if((RC6==1)&&(RC7==1))break;//等待键松开
     }
     if(RC5==0)break;
    }
    while(1)
    {
     if(RC5==1)break;
    }
     Show8X16(2,120,nono);
     Show8X16(4,120,xinghao);
    while(1)
    {
     if(RC6==0)
     {
      val2++;
      if(val2>=128)
      {
       val2=128;
      }
      ChangeTemp2(val2);
     }
     if(RC7==0)
     {
      val2--;
      if(val2<-55)
      {
       val2=-55;
      }
      ChangeTemp2(val2);
     }
     while(1)
     {
      if((RC6==1)&&(RC7==1))break;
     }
      if(RC5==0)break;
    }
    ClearScreen(1);
    ClearScreen(2);
    LCDShow2();
    break;
     }
    }                  
     }  
}

四.   总结

曾经因为一线总线检测存在脉冲的子程序的延时不对,低电平持续不到480uS,所以程序一直没有进展,且找不到问题原因,耽搁了好多天,昨天偶然中发现了这个原因,一下就成功了,看来还是不够仔细.

通过这个例子,我掌握了KS0108系列液晶的编程及DS18B20温度传感器的使用.但还是有很多不够完善的地方,如1.程序按键不是很灵敏,2.还可以多加些功能,3.有些子程序写得很烦.但不管怎么样,总算写出来了,有兴趣的朋友可以看一下.

  公司的数控面板和控制板的连线是25芯的,但没有既细又长的配套线,所以一向都是自己用细线做的,但问题也就多了,乘着这几天正学串口通信,用PIC单片机改装了两块板,实现了双机之间的异步通信,并用PROTEUS模拟了出来,跟有兴趣的朋友共享.

一.原理图

功能介绍:

(1).U1单片机控制4X5的矩阵键盘和十个指示灯,名称按图所示.

(2).U2单片机控制18个继电器.

(3).按键”选择枪1”,”选择枪2”,”选择枪3”,”选择枪4”,”PREHEAT”,”CUTTING”,”HEIGHT”,”RETRACE”,”PLASMA”这9个按键是一键控制相对应的继电器的开关.就是说按一下为开,送开保持原先状态,再按一下为关,送开保持,即实现一个D触发器的电平翻转功能.

(4).按键”1 UP”,”1 DOWN”,”2 UP”,”2 DOWN”,”3 UP”,”3 DOWN”,”4 UP”,”4 DOWN”,”ALL UP”,”ALL DOWN”,”IGNITION”为点动按键,即按下为开,继电器吸合,送开为关,继电器放开.

(5).所用单片机为P16F873A

二.程序

为观察方便,特把图分为发送部分和接收部分,并分别编程.

1.       发送部分

 原理图如下所示

/***********************************************************************

*   文件标题：CNC-USART-1                                            *

*   编制日期：2007.12.19                                                  *

*   编制人：  wujieflash                                                      *

*   程序用途：用于数控切割机上的面板通信（发送部分） *

*   配套图纸：CNC-02                                                       *

*   版本号：  V1.0                                                             *

***********************************************************************/

#include <pic.h>

//函数声明

void initial();

void delay();

void key_scan();

void key_serve();

void send_usart();

//定义变量

unsigned int i,j,k1,k2,k3,k4,k5,k6,k7,k8,k9,k10;

//子程序

//初始化子程序

void initial()

{

       ADCON1=0x06;//设置为普通数字引脚

       TRISC0=0;//键盘四根行线设置为输出

       TRISC1=0;

       TRISC2=0;

       TRISC3=0;

       TRISC4=1;//键盘五根列线设置为输入

       TRISC5=1;

       TRISA2=1;

       TRISA3=1;

       TRISA4=1;

       TRISB=0;

       PORTB=0;

       TRISA0=0;

       RA0=0;

       TRISA1=0;

       RA1=0;

       RC0=0;//四根行线先送低电平

       RC1=0;

       RC2=0;

       RC3=0;

       //USART部件初始化

       SPBRG=0x19;//设置波特率为9600bps

       TXSTA=0x04;//选择异步高速8位数据传输模式

       RCSTA=0x80;//允许串行端口工作

       TRISC6=1;//设置为高阻态，防止干扰

       TRISC7=1;

}

//延时子程序

void delay()

{

       for(i=2000;i--;)

       continue;

}

//键盘扫描子程序

void key_scan()

{

       while(1)

       {

              if((RC4==0)||(RC5==0)||(RA2==0)||(RA3==0)||(RA4==0))//是否有键按下

              {

                     break;

              }

       }

       delay();

       if((RC4==0)||(RC5==0)||(RA2==0)||(RA3==0)||(RA4==0))//确认有键按下

       {

              key_serve();

       }

       else

       {

              j=0x00;

              send_usart();

       }

}

//按键服务子程序

void key_serve()

{

       RC1=1;//先置RC0为低电平，剩余三根行线为高电平

       RC2=1;

       RC3=1;

       RC0=0;

       if(RC4==0)//按键1 “select 1"

       {

              k1++;

              k1=k1%2;

              if(k1==1)//奇数次为开

              {

                     j=0x01;

                     send_usart();

                  RB0=1;//指示灯亮

           }

           if(k1==0)//偶数次为关

           {

                  j=0x15;

                  send_usart();

                  RB0=0;//指示灯灭

              }

       }

       if(RC5==0)//按键2 "1 up"

       {

              j=0x02;

              send_usart();

       }

       if(RA2==0)//按键3 "1 down"

       {

              j=0x03;

              send_usart();

       }

       if(RA3==0)//按键4 "select 2"

       {

              k2++;

              k2=k2%2;

              if(k2==1)//奇数次为开

              {

                     j=0x04;

                     send_usart();

                     RB1=1;

              }

              if(k2==0)//偶数次为关

              {

                     j=0x16;

                     send_usart();

                     RB1=0;

              }

       }

       if(RA4==0)//按键5 “2 up"

       {

              j=0x05;

              send_usart();

       }

       RC0=1;//置RC1为低电平，剩余行线为高

       RC2=1;

       RC3=1;

       RC1=0;

       if(RC4==0)//按键6 "2 down"

       {

              j=0x06;

              send_usart();

       }

       if(RC5==0)//按键7 "select 3"

       {

              k3++;

              k3=k3%2;

              if(k3==1)

              {

                     j=0x07;

                     send_usart();

                     RB2=1;

              }

              if(k3==0)

              {

                     j=0x17;

                     send_usart();

                     RB2=0;

              }

       }

       if(RA2==0)//按键8 "3 up"

       {

              j=0x08;

              send_usart();

       }

       if(RA3==0)//按键9 "3 down"

       {

              j=0x09;

              send_usart();

       }

       if(RA4==0)//按键10 "select 4"

       {

              k4++;

              k4=k4%2;

              if(k4==1)

              {

                     j=0x0a;

                     send_usart();

                     RB3=1;

              }

              if(k4==0)

              {

                     j=0x18;

                     send_usart();

                     RB3=0;

              }

       }

       RC0=1;//置RC2为低电平，剩余为高

       RC1=1;

       RC3=1;

       RC2=0;

       if(RC4==0)//按键11 "4 up"

       {

              j=0x0b;

              send_usart();

       }

       if(RC5==0)//按键12 "4 down"

       {

              j=0x0c;

              send_usart();

       }

       if(RA2==0)//按键13 "all up"

       {

              j=0x0d;

              send_usart();

       }

       if(RA3==0)//按键14 "all down"

       {

              j=0x0e;

              send_usart();

       }

       if(RA4==0)//按键15 "preheat"

       {

              k5++;

              k5=k5%2;

              if(k5==1)

              {

                     j=0x0f;

                     send_usart();

                     RB4=1;

              }

              if(k5==0)

              {

                     j=0x19;

                     send_usart();

                     RB4=0;

              }

       }

       RC0=1;//置RC3为低，剩余为高

       RC1=1;

       RC2=1;

       RC3=0;

       if(RC4==0)//按键16 "cutting"

       {

              k6++;

              k6=k6%2;

              if(k6==1)

              {

                     j=0x10;

                     send_usart();

                     RB5=1;

              }

              if(k6==0)

              {

                     j=0x1a;

                     send_usart();

                     RB5=0;

              }

       }

       if(RC5==0)//按键17 "height"

       {

              k7++;

              k7=k7%2;

              if(k7==1)

              {

                     j=0x11;

                     send_usart();

                     RB6=1;

              }

              if(k7==0)

              {

                     j=0x1b;

                     send_usart();

                     RB6=0;

              }

       }

       if(RA2==0)//按键18 "ignition"

       {

                     j=0x12;

                     send_usart();

                     RB7=1;

       }

       if(RA3==0)//按键19 "retrace"

       {

              k9++;

              k9=k9%2;

              if(k9==1)

              {

                     j=0x13;

                     send_usart();

                     RA0=1;

              }

              if(k9==0)

              {

                     j=0x1d;

                     send_usart();

                     RA0=0;

              }

       }

       if(RA4==0)//按键20 "oxy/plasma"

       {

              k10++;

              k10=k10%2;

              if(k10==1)

              {

                     j=0x14;

                     send_usart();

                     RA1=1;

              }

              if(k10==0)

              {

                     j=0x1e;

                     send_usart();

                     RA1=0;

              }

       }

       RC0=0;//置四根行线为低电平

       RC1=0;

       RC2=0;

       RC3=0;

       while(1)

       {

              if((RC4==1)&&(RC5==1)&&(RA2==1)&&(RA3==1)&&(RA4==1))//等键松开

              break;

       }

       RB7=0;//关“IGNITION”指示灯

       j=0x00;

       send_usart();

}

//命令发送子程序

void send_usart()

{

       TXEN=1;//发送允许

       CREN=1;//接收允许

       TXREG=j;

       while(1)

       {

              if(TXIF==1)break;//等待发送完成

       }

       while(1)

       {

              if(RCIF==1)break;//等待接收完成

       }

       RCREG=RCREG;//读响应字节，清RCIF

}

//主程序

void main(void)

{

       initial();

       while(1)

       {

              key_scan();

       }

}

2.接收部分

原理图如下所示

/***********************************************************************

*   文件标题:CNC-USART-2                                              *

*   编制日期:2007.12.19                                                   *

*   编制人:  吴杰                                                                *

*   程序用途:用于数控切割机上的面板通信（接收部分）   *

*   配套图纸:CNC-01                                                         *

*   版本号:  V1.0                                                               *

***********************************************************************/

#include <pic.h>

//函数声明

void initial();

void recevie_usart();

void rece_serve();

//定义变量

unsigned int rece;

//子程序

//初始化子程序

void initial()

{

       ADCON1=0x06;//设置RA口为普通数字端口

       TRISA=0;

       PORTA=0;

       TRISB=0;

       PORTB=0;

       TRISC=0;

       PORTC=0;

       //USART部件初始化

       SPBRG=0x19;//设置波特率为9600bps

       TXSTA=0x04;//选择异步高速8位数据传输模式

       RCSTA=0x80;//允许串行端口工作

       TRISC6=1;//设置为高阻态，防止干扰

       TRISC7=1;

}

//接收子程序

void recevie_usart()

{

       CREN=1;

       TXEN=1;

       while(1)

       {

              if(RCIF==1)break;//接收完毕

       }

       rece=RCREG;//读取接收到的数据，并清RCIF

       TXREG=rece;//待发送的数据

       while(1)

       {

              if(TXIF==1)break;//发送完毕

       }

}

//接收服务子程序

void rece_serve()

{

       switch(rece)

       {

              case 0x00:{

                            RC2=0;//继电器“1 up"关

                            RC3=0;//继电器"1 down"关

                            RC4=0;//继电器”2 up"关

                            RC5=0;//继电器“2 down"关

                            RA0=0;//继电器”3 up"关

                            RA1=0;//继电器“3 down"关

                            RA2=0;//继电器”4 up"关

                            RA3=0;//继电器“4 down"关

                            RB7=0;//继电器“ignition"关

                            break;

                       }

              case 0x01:{

                            RB0=1;//继电器”1 select"开

                            break;

                      }

              case 0x15:{

                            RB0=0;//继电器“1 select"关

                            break;

                      }          

              case 0x02:{

                            RC2=1;//继电器”1 up"开

                            break;

                            }

              case 0x03:{

                            RC3=1;//继电器”1 down"开

                            break;

                            }

              case 0x04:{

                            RB1=1;//继电器”2 select"开

                            break;

                            }

              case 0x16:{

                            RB1=0;//继电器”2 select"关

                            break;

                            }

              case 0x05:{

                            RC4=1;//继电器”2 up"开

                            break;

                            }

              case 0x06:{

                            RC5=1;//继电器”2 down"开

                            break;

                            }

              case 0x07:{

                            RB2=1;//继电器”3 select"开

                            break;

                            }

              case 0x17:{

                            RB2=0;//继电器”3 select"关

                            break;

                            }

              case 0x08:{

                            RA0=1;//继电器”3 up"开

                            break;

                            }

              case 0x09:{

                            RA1=1;//继电器”3 down"关

                            break;

                            }

              case 0x0a:{

                            RB3=1;//继电器”4 select"开

                            break;

                            }

              case 0x18:{

                            RB3=0;//继电器”4 select"关

                            break;

                            }

              case 0x0b:{

                            RA2=1;//继电器”4 up"开

                            break;

                            }

              case 0x0c:{

                            RA3=1;//继电器”4 down"开

                            break;

                            }

              case 0x0d:{

                            RC6=1;//继电器”all up"开

                            RC4=1;

                            RC2=1;

                            RA0=1;

                            break;

                            }

              case 0x0e:{

                            RA1=1;//继电器”all down"开

                            RC3=1;

                            RC5=1;

                            RC7=1;

                            break;

                            }

              case 0x0f:{

                            RB4=1;//继电器”preheat"开

                            break;

                            }

              case 0x19:{

                            RB4=0;//继电器”preheat"关

                            break;

                            }

              case 0x10:{

                            RB5=1;////继电器”cutting"开

                            break;

                            }

              case 0x1a:{

                            RB5=0;//继电器”cutting"关

                            break;

                            }

              case 0x11:{

                            RB6=1;////继电器”height"开

                            break;

                            }

              case 0x1b:{

                            RB6=0;//继电器”height"关

                            break;

                            }

              case 0x12:{

                            RB7=1;//继电器”ignition"开

                            break;

                            }

              /*case 0x1c:{

                            RB7=0;//继电器”ignition"关

                            break;

                            }*/

              case 0x13:{

                            RC0=1;//继电器”retrace"开

                            break;

                            }

              case 0x1d:{

                            RC0=0;//继电器”retrace"关

                            break;

                            }

              case 0x14:{

                            RC1=1;//继电器”plasma"开

                            break;

                            }

              case 0x1e:{

                            RC1=0;//继电器”plasma"关

                            break;

                            }    

       }

}

//主程序

void main()

{

       initial();

       while(1)

       {

              recevie_usart();

              rece_serve(); 

       }

}

三,总结

    虽然板子用用也没啥问题,但程序毕竟考虑的简单了一些,如:没有考虑故障处理的问题,我打算写进一段自动提示故障的程序,在两板之间通信线出现问题不通的时候,闪烁指示灯提示.还有什么欠考虑的地方请大家一起帮忙!

从国外媒体处获悉：美联社15日引述摩尔定律发明人摩尔的话说，摩尔定律可能还能延续十年时间，此后在技术上将会变得十分困难。

长久以来，半导体行业一直在力图把更多数量的晶体管集成到一个面积极为微小的芯片上。1965年，英特尔公司的联合创始人摩尔预言，未来每两年，同一面积芯片上可以集成的晶体管数量将翻番，这就是后人所称的“摩尔定律”。

美联社说，随着集成度的提高，更多晶体管的集成正在成为“物理上不可能完成的任务”。美联社评论称，由此，曾经驱动了数字技术革命——甚至是现代经济——的半导体技术引擎将“刹车”停车。

摩尔对美联社说：“我认为摩尔定律将会延续另外一个十年左右。此后，事情将变得困难。不过在历史上，我们已经好几次面临这样的情景。”

面对摩尔定律的寿命即将到来，半导体厂商已经投入了几十亿美元资金，研发其他更加高效地利用晶体管的技术，他们需要让晶体管以更加强大的方式工作。

全世界最大的半导体公司英特尔认为，目前已经有了多项很有前途的替代技术，比如量子计算、光切换等，依靠这些技术，摩尔定律可能被延寿到2020年之后。

美联社引述英特尔公司首席技术官贾斯汀·拉特纳的话说：“现在，技术的发展演进比过去要快得多。变化之所以加速的原因，是因为半导体行业同时面临多个物理上的极限，我们正在加班加点，保证摩尔定律继续有效。”

这是今天花一天时间写的,拿出来给像我一样的菜鸟参考,希望大家一起提高.

一.原理图

实现功能:四个数码管分为两组,四个按键也对应分为两组,每组控制对应数码管显示数据的加减,数据在0--99间循环显示,并具有掉电保护功能,通过24LC01B保存掉电前的数据.程序简单易读,是初学者的福音(因为我也是菜鸟)!

二.器件介绍

1．概述
    SAA1064是Philips公司生产的4位LED驱动器，为双极型电路，具有I2C接口。该电路是特别为驱动4位带有小数点的七段显示器而设计的，通过多路开关可对两个2位显示器进行切换显示。该器件内部带有I2C总线从发送接收器，可以通过地址引脚ADR的输入电平编程为4个不同的从器件地址。内部的模式控制器可以控制LED的各个位以使其能够工作于静态模式、动态模式、熄灭模式及段测试模式。
2．引脚功能及封装形式
    SAA1064采用24脚DIP和SOT两种封装形式，图1所示为24脚DIP封装的引脚排列。各主要引脚的功能如下：
    ADR（1）：地址输入线；
    CEXT（2）：内部振荡器电容输入端，典型值为2.7nF；
    P8～P1(3～10)：段数据输出口1；
    P9～P16(15～22)：段数据输出口2；
    MX1（11）：多路选择开关输出1；
    MX2（14）：多路选择开关输出2：
    VEE（12）：地；
    VCC（13）：电源；
    SDA（23）：I2C总线串行数据线；
    SCL（24）：I2C总线串行时钟线；
3．功能说明
3．1 通讯规约
    主器件CPU通过I2C总线对SAA1064进行读或写，读/写方式中I2C总线上的信息传送格式如图2所示，图中：S为启动信号；P为结束信号；A为响应位；X为任意值；A1A0由ADR输入电位确定2位地址位；SC SB SA为单元地址位；C6～C0为控制位;PR为上电复位标志。
3.2 SAA1064的从地址
    SAA1064的从地址是由引脚ADR上的输入电平决定的。ADR引脚在接VEE、3/8VCC、5/8VCC和VCC时分别对应于4个不同的从地址（A1A0=00、01、10、11）。在写方式时，它们对应的从地址字节值为70H、72H、74H、76H，而在读方式时，它们对应的从地址字节值为71H、73H、75H、77H。其他的地址不为该器件所响应。
3．3 状态字节
    SAA1064的状态字节中只用1位：即上电复位标志位PR，它为逻辑“1”时，表示从上次读状态以后出现过掉电和加电，而在读状态字节操作完成以后，该标志清0。
3.4 单元地址
    用位SC、SB、SA形成1个指针以确定指令字节以后的数据字节写入哪个寄存器，而其它的数据依次写入后继单元中，这种特性称为单元地址增量。单元地址指针范围为0～7。单元地址分配如表1所列。
3．5 控制字节
    控制字节各位（C0～C6）的含义如下：
    C0=0 静态显示，数字位1和2可以连续显示；
    C0=1动态显示，数字位1、3和2、4交替显示；
    C1=0/1数字位1、3暗/亮选择位；
    C2=0/1数字位2、4暗/亮选择位；
    C3=1 所有段导通以便段测试，其电流由C4、C5、C6所决定；
    C4=1 段输出电流增加3mA；
    C5=1 段输出电流增加6mA；
    C6=1 段输出电流增加12mA；
3．6 数据字节
    数据字节中数据为1时为对应的段导通（亮），数据字节D17～D10、D27～D20、D37～D30、D47～D40分别对应于位1、2、3和4的显示器，高位对应于输出端P8或P16，低位对应于输出端P1或P9，显示器1～4显示的数据对应于单元地址1～4的内容。
3．7 SDA、SCL
    SDA、SCL分别为总线的数据线和时钟线。为防止这些引脚上出现过压脉冲，应接一个稳压管（5.5V）至，即正常的线电压不应超过5.5V。正常情况下，数据在响应位的时钟上跳变锁存。
3．8 上电复位
    上电复位信号是在SAA1064芯片的内部产生的，该信号能使内部各位清0而显示全暗，此时只有掉电标志置位。
3．9 外部定时控制电容
    在SAA1064的引脚（2脚）上接一个定时电容到地可使内部多路转换的振荡器工作。在静态工作方式中，因为不需要振荡器工作，因此，该引脚可接或浮空。
3.10 段数据输出端
    P1～P16是吸收电流可控的段数据输出端，可用相应的数字位控制其导通，并由C4、C5、C6控制位控制其电流的大小。
3．11 多路输出端
    SAA1064的多路输出端MX1和MX2在动态显示方式中交替导通，它们均由内部时钟的分频信号驱动。
    在静态方式中，MX1总是导通，其输出由内部射极跟随器组成，可直接驱动2位显示器的公共极，如果超过了电路的总功耗，应当用晶体管把11脚和14脚相连在一起。
三,程序(PICC调通)

//Use for DN-100 Cotroller
//Date:from 2007.12.7 to
//Author:wujie
//Company:Wuxi Zhouxiang complete set of welding equipment CO.LTD

//Introduce:
//MCU:p16f73
//display IC:SAA1064       addr:0x70   

//START
#include <pic.h>

__CONFIG(XT&WDTDIS&BORDIS);

//程序声明

void initial(void);
void display(char cur_hex,char time_hex);
void button_test(void);
void start_iic();
void stop_iic(void);
void ack_iic();
void nack_iic();
void send_iic(char c);
char receive_iic(void);
 
//预定义
#define nop() asm("nop")
#define SDA   RC4
#define SCL   RC3

unsigned int i,rxbuf;
char cur,time;
 
//初始化
void initial(void)
{
 TRISA=0X3F;                //ALL PORTS ARE INPUT
 PORTA=0X00;
 TRISB=0X03;               //RB0,RB1 ARE INPUTS
 PORTB=0X00;
 TRISC=0XE7;              // RC3,RC4, ARE outPUTS
 PORTC=0X18;             //RC3,RC4 ARE IN HIGH
 
 cur=0;
 time=0;
  }
 
//显示子程序
void display(char cur_hex,char time_hex)
{
 char d1buf,d2buf,d3buf,d4buf;

//数组存储显示7段码
 char bit_dis[]={0xfc,0x60,0xda,0xf2,0x66,0xb6,0xbe,0xe0,0xfe,0xf6,0xee,0x3e,0x9c,0x7a,0x9e,0x8e,0x00};
 
 d2buf=bit_dis[cur_hex%10];//CUR的个位
 d1buf=bit_dis[cur_hex%100/10];//CUR的十位
 d4buf=bit_dis[time_hex%10];//TIME的个位
 d3buf=bit_dis[time_hex%100/10];//TIME的十位
 nop();
 start_iic();
 nop();
 send_iic(0x70);//SAA1064的地址
 send_iic(0x00);
 send_iic(0x37);//查上面资料
 send_iic(d1buf);
 send_iic(d2buf);
 send_iic(d3buf);
 send_iic(d4buf);
 nop();
 stop_iic();
} 

 //write 24cl01b subroutine
void w_24cl01b(unsigned char cur_tmp,unsigned char time_tmp)
{
 start_iic();
 send_iic(0xa0);
 send_iic(0x10);
 send_iic(cur_tmp);
 send_iic(time_tmp);
 stop_iic();
 for(i=0;i<500;i++);
}
 
//read 24cl01b subroutine
char r_24cl01b()
{
 start_iic();
 send_iic(0xa0);
 send_iic(0x10);
 start_iic();
 send_iic(0xa1);
 cur=receive_iic();
 ack_iic();
 time=receive_iic();
     nack_iic();
 stop_iic();
 display(cur,time);
 for(i=0;i<10000;i++);
 }
//按键检测
void button_test(void)
{
 if(RC1==1)
 {
  for(i=0;i<=2000;i++);//延时 20mS
  if(RC1==1)
  {
   cur++;
   cur=cur%100;//让CUR<100,因为只能显示2位

   w_24cl01b(cur,time);
  }
 }
 if(RC2==1)
 {
  for(i=0;i<=2000;i++);
  if(RC2==1)
  {
   cur--;
   if(cur<=0)

   w_24cl01b(cur,time);//写入24LC01B保存
   {
    cur=cur+100;//让CUR>0,因为只能显示2位
   }
      }
 }
 if(RC5==1)
 {
  for(i=0;i<=2000;i++);
  if(RC5==1)
  {
   time++;
   time=time%100;//让TIME<100,因为只能显示2位

   w_24cl01b(cur,time);
  }
 }
 if(RC6==1)
 {
  for(i=0;i<=2000;i++);
  if(RC6==1)
  {
   time--;

   if(time<=0)
   {
    time=time+100;//让TIME>0,因为只能显示2位
   }

    w_24cl01b(cur,time);
  }
 }
 display(cur,time);
 for(i=0;i<10000;i++);
}
 
//I2C协议

//开始信号

void start_iic()
{
 SDA=1;
 SCL=1;
 nop();
 nop();
 nop();
 nop();
 SDA=0;
 nop();
 nop();
 SCL=0;//it is ready to send data
 nop();
}
 
//停止信号
void stop_iic(void)
{
 SDA=0;
 SCL=1;
 nop();
 nop();
 nop();
 nop();
 SDA=1;
 nop();
}

//发送应答

void ack_iic()
{
 SDA=0;
 nop();
 nop();
 SCL=1;
 nop();
 nop();
 nop();
 nop();
 SCL=0;
 nop();
 nop();
}

//发送一个字节

void send_iic(char c)
{
 for(i=0;i<8;i++)
 {
  SCL=0;
  if((c<<i)&0x80)
  {
   SDA=1;
  }
  else
  {
   SDA=0;
  }
  SCL=1;
  nop();
  nop();
  nop();
  nop();
  SCL=0;
  nop();
 }
  SDA=1;
  TRISC4=1;//置输入状态,等待应答
  SCL=1;//认为应答一直有
  nop();
  nop();
  nop();
  nop();
  SCL=0;
  nop();
  TRISC4=0;//恢复为输出
}

//接受一个字节

char receive_iic(void)
{
 SDA=1;
 rxbuf=0;
 TRISC4=1;//注意:一定要置输入
 for(i=0;i<8;i++)
 {
  SCL=0;
  nop();
  nop();
  nop();
  nop();
  SCL=1;
  nop();
  rxbuf=rxbuf<<1;
  if(SDA==1)
  {
   rxbuf=rxbuf+1;
  }
 }
 nop();
 nop();
 SCL=0;
 nop();
 TRISC4=0;//恢复为输出
 return (rxbuf);
}

//主程序

void main(void)
{
 initial();

r_24cl01b();//读出掉电前保存在24LC01B内的数据

 while(1)
 {
  button_test();
  }
}

四.总结

           上面程序中紫色标注的地方一定要注意,我曾经吃过他的亏,而网上的所谓调通的程序恰恰在这些地方没有注意,这就导致程序不能正常的按设想运行.

           由于我也是刚刚在学PICC,所以如有不对的地方请大家告之.如有更好的思路也欢迎交流.

1 引言
       目前，人们对生活的质量要求越来越高，人们在忙于工作之余，豆浆机是一种新型的家用饮料机，以黄豆为原料，直接加工成熟的热豆浆。若在黄豆中配以芝麻、花生、杏仁等佐料，可以做出各种风味的鲜美饮料。 豆浆机由粉碎黄豆的搅拌机、豆浆加热器和控制电路三大部分组成。用单片机研制的全自动豆浆机的控制电路，只要按下启动按键，豆浆机就开始工作，一会儿就能喝到美味又营养的豆浆。整个过程由单片机全自动控制，让您用起来更加地方便、更加的安全。特用PROTEUS模拟,体验单片机的乐趣.
2 豆浆机的功能
单独加热：具有单独加热功能，当达到规定温度时停止加热。
自动工作：流程如下：在有水的情况下，电热管开始加热，当水温上升到82℃时，停止加热，电机开始工作。电机每工作30S然后停止5S为一个周期，持续工作5个周期．当豆浆产生的泡沫碰到防溢电极时，电机停转，等泡沫降下，电机继续工作，当泡沫碰到防溢电极１０次后电机持续工作５个周期后，结束并报警。
全过程处于无水报警，停止工作状态：在单独加热、自动工作期间，任何时刻提起豆浆机，都会停止工作并报警。当重新将豆浆机放入水中后，回复以前工作状态。
3 系统总体方案介绍
硬件组成如图所示，3个传感器分别测量水位、溢出、温度，２个按键，1个蜂鸣器输出口，2种加热方式选择。

其中,RB1口通过继电器触点接的应是电热丝,但PROTEUS库里没有,只好用一个LED代替一下,只要灯亮说明电热丝正在加热.另外,三个传感器均用开关表示,欠水检测传感器的开关闭后说明有水可以工作,否则不能正常开启;温度传感器开关闭合说明加热到指定温度;溢水检测传感器开关闭合说明豆浆泡沫溢出.上述三个开关均只能手工开启闭合模拟.选用单片机为PIC16F877A.

4.程序(C语言)

#include <pic.h>

unsigned int i=1,j=1,k=1,l,m,n=1,x,y,z;//定义程序用到的变量

void sound(void)//警报声频率子程序
{
 for(z=1;z<=10;z++)
 {
 for(x=1;x<=100;x++)
 {
   RB2=0;
 }
 for(y=1;y<=100;y++)
 {
   RB2=1;
 }
 }
}
  
void main(void)//主程序
{//初始化
    TRISB=0X00;
    TRISC=0XFF;
    PORTB=0X20;//电源指示开

while(1)
{ 
 if(RC0==0)//检测是否欠水 {
  if(RC4==0)//检测加热按钮是否按下
  {
     while(RC1==1&&RC2==1)//检测温度是否达到规定,是否有溢出

    {
       RB6=1;//加热指示
       RB1=1;//加热
      }
      sound();//加热完毕报警
     }
    else
      {
      RB6=0;//关闭加热指示
      RB1=0;//关闭电热丝
      }

 if(RC3==0)//全自动模式
 {//定时器1初始化
   T1CON=0X30;
   TMR1IF=0;
   TMR1IE=1;
   TMR1L=0X2B;
   TMR1H=0XCF;
  
   while(RC1==1&&i<=6000)//加热10分钟
   {
    TMR1ON=1;
    RB6=1;//加热
    RB1=1;
    if(TMR1IF==1)
    {
     TMR1ON=0;
     TMR1IF=0;
     TMR1L=0X2B;//重新给初值
           TMR1H=0XCF;
           i++;

    }
    }
    RB6=0;//停止加热
    RB1=0;
    sound();//加热结束报警
    for(m=1;m<=5&&n<=10;m++)//电机循环5个周期

    {
    while(j<=300&&n<=10)//电机一周期工作30S
    {
    TMR1ON=1;
    if(RC2==0)
    {
     n++;
     }
    while(RC2==0)
    {
     RB0=0;
     RB7=0;
     }
    RB0=1;//MOTOR IS ON
       RB7=1;
      if(TMR1IF==1)
    {
     TMR1ON=0;
     TMR1IF=0;
     TMR1L=0X2B;
           TMR1H=0XCF;
           j++;
    }
        }
        while(m==5)//5周期结束,报警5声"滴"
        {
         sound();
         for(l=1;l<=15000;l++)
      {;}
      sound();
      for(l=1;l<=20000;l++)
      {;}
         sound();
         for(l=1;l<=15000;l++)
      {;}
         sound();
         for(l=1;l<=20000;l++)
      {;}
         sound();
         m++;
         }
       
      sound();//每周期结束报警一声      
        while(k<=50&&n<=10)//电机每周期停止5S
        {
       TMR1ON=1;
          RB0=0;
          RB7=0;
          if(TMR1IF==1)
    {
     TMR1ON=0;
     TMR1IF=0;
     TMR1L=0X2B;
           TMR1H=0XCF;
          k++;
    }
  }
  j=0;
  k=0;
     }
     RB0=0;
     RB7=0;
     n=0;
     }
  }
 }
} (由PROTEUS仿真通过)

结束,还有什么想的不周到的地方,请大家指教.

自从开始学习单片机起,就觉得I2C是个很有用的东西,它能大大节省我们的端口,现把软件模拟的I2C程序写出来,既是给大家分享,也是为自己做一下备份.下面的程序是用I2C存储24C02:

   INCLUDE <P16F5X.INC>;同样可用于其他型号

;*************************定义变量************************
                        STATUS   EQU 3H
                        PORTB    EQU 6H
                        PORTC    EQU 7H
                        EEPROM   EQU 08H
                        ADDR     EQU 09H
                        BUFIN    EQU 0AH
                        BUFOUT   EQU 0BH
                        SLAVE    EQU   0CH
                        TXBUF    EQU   0DH
                         BIT       EQU    0EH
                        DLY1     EQU   0FH
                        DLY2     EQU   10H
                         DI       EQU      7
                         DO       EQU     6
                         SDA      EQU    7
                         SCL      EQU    6
                         ACKF     EQU   0
;**********************程序开始***************************
       ORG    7FFH
       GOTO   MAIN
       ORG    000H
;**********************启动信号***************************************
BSTART
       BSF    PORTB,SDA
       BSF    PORTB,SCL
       MOVLW  B'00111111'
       TRIS   PORTB
       NOP
       NOP
       NOP
       NOP
       NOP
       NOP
       BCF    PORTB,SDA
       NOP
       NOP
       NOP
       NOP
       NOP
       BCF    PORTB,SCL
       NOP
       NOP
       RETLW  0
;***********************停止信号********************************
BSTOP
       BCF    PORTB,SDA
       MOVLW  B'00111111'
       TRIS   PORTB
       BCF    PORTB,SDA
       NOP
       NOP
       NOP
       BSF    PORTB,SCL
       NOP
       NOP
       NOP
       BSF    PORTB,SDA
       NOP
       NOP
       BCF    PORTB,SCL
       NOP
       NOP
       RETLW  0
;**********************发送一个字节**************************
TX    
       MOVLW  D'8'
       MOVWF  BIT
TXLP   BCF    EEPROM,DO
       BTFSC  TXBUF,7
       BSF    EEPROM,DO
       CALL   BITOUT
       RLF    TXBUF
       DECFSZ BIT
       GOTO   TXLP
       CALL   BITIN
       BTFSC  EEPROM,DI
       BSF    PORTC,ACKF
       RETLW  0
;************************接收一个字节*****************************
RX
       CLRF   BUFIN
       MOVLW  D'8'
       MOVWF  BIT
       BCF    STATUS,0
RXLP   RLF    BUFIN
       BCF    BUFIN,0
       CALL   BITIN
       BTFSC  EEPROM,DI
       BSF    BUFIN,0
       DECFSZ BIT
       GOTO   RXLP
       BSF    EEPROM,DO
       CALL   BITOUT
       RETLW  0
;**********************发送********************************
BITOUT
       MOVLW   B'00111111'
       tris    PORTB
       BTFSS   EEPROM,DO
       GOTO    BITLOW
       BSF     PORTB,SDA
       GOTO    CLKOUT
BITLOW BCF     PORTB,SDA
CLKOUT BSF     PORTB,SCL
       NOP
       NOP
       NOP
       NOP
       BCF     PORTB,SCL
       RETLW   0
;**********************接收****************************
BITIN
       BSF     EEPROM,DI
       MOVLW   B'10111111'
       TRIS    PORTB
       BSF     PORTB,SCL
       NOP
       NOP
       NOP
       NOP
       NOP
       BTFSS   PORTB,SDA
       BCF     EEPROM,DI
       BCF     PORTB,SCL
       RETLW   0
;***********************主程序**********************
MAIN
       MOVLW  B'00000000'
       TRIS   PORTC
       CLRF   PORTC
WRITE                                 ;写存储器
       CLRF   PORTC
       MOVLW  B'10100000'
       MOVWF  SLAVE
       MOVLW  B'10101010'
       MOVWF  BUFOUT
       CLRF   ADDR
LOOP0  CALL   BSTART
       MOVF   SLAVE,0
       MOVWF  TXBUF
       CALL   TX
       MOVF   ADDR,0
       MOVWF  TXBUF
       CALL   TX
       MOVF   BUFOUT,0
       MOVWF  TXBUF
       CALL   TX
       CALL   BSTOP
DELAY10MS
       MOVLW  D'13'
       MOVLW  DLY1
       MOVLW  0FFH
       MOVWF  DLY2
LP0    DECFSZ DLY2
       GOTO   $-1
       DECFSZ DLY1
       GOTO   $-5
READ                                ;读存储器
       CLRF   PORTC
       MOVLW  B'10100000'
       MOVWF  SLAVE
       CLRF   ADDR
LOOP1  CALL   BSTART
       MOVF   SLAVE,0
       MOVWF  TXBUF
       CALL   TX
       MOVF   ADDR,0
       MOVWF  TXBUF
       CALL   TX
       CALL   BSTART
       MOVLW  B'10100001'
       MOVWF  TXBUF
       CALL   TX
       CALL   RX
       CALL   BSTOP
       NOP
       NOP
       NOP
       NOP
       NOP
       NOP
       MOVF   BUFIN,0
       MOVWF  PORTC
LOOP2  NOP
       GOTO   $-1
;************************
       END

希望大家相互交流,如有不对,请及时指正!

单片机的显示输出常用来显示系统参数、运行结果及人机对话窗口。常用的显示器主要有LED（数码管）和LCD（液晶）。因LED应用简单、价格低廉得到广泛应用，下面主要对其应用进行介绍。

数码管有共阴和共阳之分，常见的结构形式有单个和四位一体，一般由8字段构成，显示方式有静态显示和动态显示两种方式。

静态显示：

       在静态显示方式下，共阴极或共阳极点连接在一起接地或接高电平。每位的段选项线与一个8位并行口相连。只要在该位的段选线上保持段选码电平，该位就能保持相应的显示字符。8位并行口可以是单片机的I/O口或者采用串行输入/并行输出的移位寄存器（常用为74HC164、74HC595）

下面是试验板LED动态显示的电路图：

如果要显示某字符，首先要把这个字符转换为相应的字形码，然后通过单片机的串行口，将编码数据发送到74HC595，74HC595再将接受到的数据以并行的方式加到数码管上，并通过RCK将输出数据锁存。

下面是其应用实例：

;**********************************************************

;* display.ASM

;**********************************************************

;*  利用SPI口实现4位数码管显示，在demo40板上通过调试

;*  调试时硬件设置：SW2的1,2断开

;**********************************************************

;*  显示数据存放在disp1~disp4(20~23),disp1为右边第一位

;**********************************************************

list p=16f877

; Include file, change directory if needed

include "p16f877.inc"

; Start at the reset vector

DISP1 EQU 20H

DISP2 EQU DISP1+1

DISP3 EQU DISP2+1

DISP4 EQU DISP3+1

count EQU DISP4+1

T1 EQU count+1

ORG 0x000

nop

goto  start

;****************************************************************************

;以下为显示模块

CONVERT 

ADDWF  PCL,1    ;不带小数点的共阴极码表

RETLW  0X3F     ;0

RETLW  0X06     ;1

RETLW  0X5B     ;2

RETLW  0X4F     ;3

RETLW  0X66     ;4

RETLW  0X6D     ;5

RETLW  0X7D     ;6

RETLW  0X07     ;7

RETLW  0X7F     ;8

RETLW  0X6F     ;9

RETLW  0X00     ;DARK

RETLW  0X71     ;F

RETLW  0X37     ;N

;******************************************************************************

init

banksel TRISC

movlw B'00010000' ;RC4作为SDI

movwf TRISC

movlw 0xc0

movwf SSPSTAT

banksel SSPCON

clrf   PORTC

movlw B'00110010' ;

movwf SSPCON

return

disp movlw 05h

movwf count

movlw 20h

movwf FSR

bcf PORTC,6

dsnext decfsz count,1

goto dbtran

goto dsend

dbtran movf INDF,0

CALL CONVERT   ;赋1位数据显示码

call out_in

incf FSR,1

goto dsnext

dsend bsf PORTC,6

return

out_in movwf SSPBUF

loop1

banksel SSPSTAT

btfss SSPSTAT,BF

goto  loop1

bcf STATUS,RP0

movf SSPBUF,w

return

start call  init

movlw 01h

movwf DISP1

movlw 02h

movwf DISP2

movlw 03h

movwf DISP3

movlw 04h

movwf DISP4

agdisp call  disp

goto agdisp

end

       静态显示电路在位数较多时，字符更新速度慢，硬件成本高，在实际设计中，动态显示应用较多。下面介绍的是数码管的动态显示

动态显示：

         动态显示是通过分时轮流选通数码管的公共端，使得各个数码管轮流导通，即各数码管是由脉冲电流导电的（导通时间一般为1ms）。当所有数码管依次显示一遍后，软件控制循环，使每位显示器分时点亮。这种方法不但能提高数码管的发光效率，并且由于各个数码管的字段线是并联使用的，因而大大简化了硬件线路。

下面是试验板的数码管动态显示电路图：

从图中可以看出RB口用作字形输出，RA口用作位扫描输出。由于PIC的I/O口最大输出电流为25ma，因此在字形输出回路要串电阻（一般为保证亮度，电流在10～15ma），而在扫描输出口电流为字形线电流的8倍，远超容许范围，因此加三极管驱动。另外可用8路三态反向缓冲器74HC240用作字形驱动，用6路反向门电路7406驱动位选。

动态显示最重要的是解决好亮度和字符闪烁问题。由于数码管具有余辉特性及人眼具有视觉暂留效应，所以适当选取循环扫描频率时，看上去所有数码管是同时点亮的，察觉不出有闪烁现象。不过这种方式数码管不宜太多（不超过8个），否则每个数码管分配到的实际导通时间会太少，使得亮度不足。另外要求扫描频率不能小于100Hz，否则就会出现闪烁现象。

下面是试验板数码管动态显示的实例：

;**********************************************************

;* display.ASM

;**********************************************************

;*  利用PORTB口实现4位数码管动态显示，在demo18板上通过调试

;**********************************************************

;*  显示数据存放在disp1~disp4(20~23),disp1为右边第一位

;**********************************************************

list p=16f628

; Include file, change directory if needed

include "p16f628.inc"

; Start at the reset vector

DISP1 EQU 20H

DISP2 EQU DISP1+1

DISP3 EQU DISP2+1

DISP4 EQU DISP3+1   ;以上为四位显示数据存放位

count EQU DISP4+1   ;动态显示位

T1 EQU count+1   ;延时数据存放位

ctrl EQU T1+1   ;动态显示控制位

ORG 0x000

nop

goto  start

;****************************************************************************

;以下为显示模块

CONVERT 

ADDWF  PCL,1    ;不带小数点的共阴极码表

RETLW  0X3F     ;0

RETLW  0X06     ;1

RETLW  0X5B     ;2

RETLW  0X4F     ;3

RETLW  0X66     ;4

RETLW  0X6D     ;5

RETLW  0X7D     ;6

RETLW  0X07     ;7

RETLW  0X7F     ;8

RETLW  0X6F     ;9

RETLW  0X00     ;DARK

RETLW  0X71     ;F

RETLW  0X37     ;N

;******************************************************************************

init

banksel TRISB

movlw B'00000000'  ;A、B口为输出，初始数据为0

movwf TRISB

movwf TRISA

banksel PORTA

movwf PORTB

movwf PORTA

movlw 20h

movwf FSR   ;显示数据存放首地址

movlw 01h

movwf ctrl   ;动态显示控制初值

return

disp movlw 05h

movwf count   ;动态显示为4位

disp1 decfsz count,1   ;动态显示一次完否？

goto dbtran   ;否，继续显示

goto  dsend   ;是，结束显示

dbtran movf ctrl,0

movwf PORTA   ;控制位赋A口

movf  INDF,0

call CONVERT   ;取显示数据

movwf PORTB   ;显示数据赋B口

bcf STATUS,0  ;清进位标志

rlf ctrl,1   ;动态控制位左移

incf FSR,1   ;显示数据地址加1

call delay   ;延时

CLRF PORTB

goto disp1   ;到下一位显示

dsend movlw 20h   ;动态显示一周期完，恢复初始数据

movwf FSR

movlw 01h

movwf ctrl

return

delay movlw 0xff

movwf T1

delay1 decfsz T1,1

goto  delay1

return

start call  init

movlw 01h

movwf DISP1

movlw 02h

movwf DISP2

movlw 03h

movwf DISP3

movlw 04h

movwf DISP4

agdisp call  disp

goto agdisp

end

        动态扫描显示虽然硬件简单，但因必须反复循环显示，降低了单片机的工作效率，在一些实时性要求高的场合应用受到限制。

图1：开发板原理图(键盘部分）

（注：如果看不清，请用鼠标滚轮放大或保存后看）

键盘是人机对话的桥梁，通过它可以实现应用系统的参数查询、修改。单片机应用系统的键盘一般用按钮或薄膜开关，可以利用RB口组成4*4=16个矩阵键盘（图1），PIC单片机的RB口一般具有有高、低电平中断功能，内部还有弱上拉电阻，可以简化键盘的外围硬件，一般RB口作为键盘的专用接口。

键盘的软件处理主要有查询和中断两种方式，一般用中断编程效率高。软件编程还要处理好键盘的除抖问题，一般采用延时后查询的处理方式，对于单一功能键，延时20ms足够，对于多功能键要延时100ms左右，否则，不键值会紊乱。

下面是我对键盘编程的演示程序，供大家参考。

;************************************************************************************************************

;*程序通过PORTB的"电平变化中断"进行键盘的输入,并将键值显示到数码管上。由于用ICD调试时要占用RB6,RB7口，本例只演

;*示S1，S2，S5，S6四个键，即按下S1键时数码管上显示1,按下S2键时数码管上显示2,依此类推…………

;************************************************************************************************************

LIST 　P=16F877

INCLUDE 　"P16F877.INC"

;所用的寄存器

DISP1 　EQU 　20H

DISP2 　EQU 　DISP1+1

DISP3 　EQU 　DISP2+1

DISP4 　EQU 　DISP3+1

count 　EQU 　DISP4+1

T1 　　EQU 　count+1

JIANR 　EQU 　T1+1

FLAG 　EQU 　JIANR+1 ;标志寄存器

DEYH 　EQU 　JIANR+2

DEYL 　EQU 　JIANR+3

ORG 　0X00

nop

GOTO 　MAIN

ORG 　0X04

GOTO 　INTSERVE

ORG 　0X10

;************以下为码值转换表**************

CONVERT

ADDWF 　PCL,　1 　;不带小数点的共阴极码表

RETLW 　0X3F 　;　0

RETLW 　0X06 　;　1

RETLW 　0X5B 　;　2

RETLW 　0X4F 　;　3

RETLW 　0X66 　;　4

RETLW 　0X6D 　;　5

RETLW 　0X7D 　;　6

RETLW 　0X07 　;　7

RETLW 　0X7F 　;　8

RETLW 　0X6F 　;　9

RETLW 　0X00 　;DARK

RETURN

;***************初始化子程序***************

INITIAL

CLRF 　INTCON 　;禁止总中断和外围中断

BSF 　INTCON,　RBIE 　;B口变位中断允许

BANKSEL 　TRISC 　;选择存储体1

BCF 　TRISC,　6 　;置RC6为输出方式,以输出锁存信号

MOVLW 0XF0

MOVWF TRISB 　　　;设置与键盘有关的各口的输入输出方式

BCF OPTION_REG,7 　;使弱上拉有效

BCF TRISC,5

BCF TRISC,3 　　　　　;设置SCK与SDO为输出方式

BCF INTCON,GIE　　　　 ;关闭所有中断

MOVLW 0XC0

MOVWF SSPSTAT　　　 ;设置SSPSTAT寄存器

BANKSEL SSPCON

MOVLW 0X30

MOVWF SSPCON 　　　;设置SPI的控制方式,允许SSP方式,并在时钟下降

;沿发送数据,与"74HC595,当其SCLK从低到高电平

;跳变时,串行输入数据(DI)移入寄存器"的特点相对应。

MOVLW 0X00

MOVWF JIANR 　　　　;显示值寄存器赋初值

CLRF FLAG 　　　　　;标志寄存器清0

MOVLW 0X00

MOVWF PORTB 　　　;送低电平至B0~B3,为电平变化中断的产生创

;造初始条件

MOVF PORTB,W　　　 ;读PORTB端口,建立变位中断的初始

;条件(由高到低时中断)

RETURN ;返回

;*************中断服务子程序*****************

INTSERVE

BCF INTCON,RBIF 　　;中断标志清0

CALL KEYDELAY　　　 ;调用100ms的软件延时子程序,以消除抖动

MOVF PORTB,W 　　　;读PORTB的值,并同时改变中断发生的条件,可屏蔽

;一次按键松开时产生的无效中断,又可以防止按键

;时间过长发生连续中断

ANDLW 0X30

SUBLW 0X30

BTFSC STATUS,Z

RETFIE ;判断为干扰,则返回,并可以屏蔽一次无用的中断

CALL KEYSERVE 　　　;调用键服务子程序,确定键值

MOVLW 0X00

MOVWF PORTB 　　　;送低电平至B0~B3,以防止键扫描时改变

;B0~B3的电平,从而改变中断条件

BCF INTCON,RBIF 　　;键扫描时可能会产生"电平变化"而使RBIF

;置1,再清除一次RBIF以求避免额外中断

MOVF JIANR,W　　　　 ;把需要显示的值送给W寄存器

MOVWF DISP1

MOVLW 0X0A

MOVWF DISP2

MOVWF DISP3

MOVWF DISP4

CALL DISPLAY　　　　 ;调用显示子程序

RETFIE ;中断返回

;***************显示子程序******************

DISPLAY movlw 05h

movwf count

movlw 20h

movwf FSR

bcf PORTC,6

dsnext decfsz count,1

goto dbtran

goto dsend

dbtran movf INDF,0

CALL CONVERT　　　　 ;赋1位数据显示码

call out_in

incf FSR,1

goto dsnext

dsend bsf PORTC,6

return

out_in movwf SSPBUF

loop1

banksel SSPSTAT

btfss SSPSTAT,BF

goto loop1

bcf STATUS,RP0

movf SSPBUF,w

return

;****************************************

;**********键盘去抖子程序(约23ms的延时)** ***************

KEYDELAY

MOVLW 0X1E

MOVWF DEYH

AGAIN2 MOVLW 0XFF

MOVWF DEYL

AGAIN1 DECFSZ DEYL,1

GOTO AGAIN1

DECFSZ DEYH,1

GOTO AGAIN2

RETURN

;***************键服务子程序******************

KEYSERVE ;确定键值的子程序

MOVLW 0XF8 ;B2置低电平

MOVWF PORTB

BTFSS PORTB,4 ;若RB4为"0",则S5键按下

GOTO S5

BTFSS PORTB,5 ;若RB5为"0",则S6键按下

GOTO S6

MOVLW 0XF4 ;B3置低电平

MOVWF PORTB

BTFSS PORTB,4 ;若RB4为"0",则S1键按下

GOTO S1

BTFSS PORTB,5

GOTO S2 ;若RB5为"0",则S2键按下。以上对键盘进行扫描,

;以确定是哪一个键按下

S1 MOVLW 0X01

MOVWF JIANR

GOTO JIANW

S2 MOVLW 0X02

MOVWF JIANR

GOTO JIANW

S5 MOVLW 0X05

MOVWF JIANR

GOTO JIANW

S6 MOVLW 0X06

MOVWF JIANR ;以上根据按下的键把相应的值送给JIANR

JIANW NOP

RETURN

;****************************************

MAIN

CALL INITIAL ;调用初始化子程序

BSF INTCON,GIE ;总中断允许

HERE GOTO HERE ;等待中断发生

END