设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › AVR单片机 › atmega16单片机设计电子考试系统Proteus仿真及源程序
返回列表 发新帖
查看: 3403|回复: 0
打印 上一主题 下一主题
收起左侧

atmega16单片机设计电子考试系统Proteus仿真及源程序

[复制链接]
跳转到指定楼层
楼主
ID:507486 发表于 2020-4-4 17:49 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
  •      功能用途：采用两个单片机系统实现四则运算考试及判卷功能，具体内容包括：
⑴两个单片机系统分别作为服务器和答题终端。服务器负责验证考生个人信息，发送试题到终端，定时收卷及判分功能。答题终端负责输入考生个人信息，答题，修改答案及传送答案到服务器。
⑵服务器验证考生个人信息，若信息不正确则向终端发出提示信息。信息验证正确后将试题发送到答题终端，同时开始计时。无论答题是否完成，考试时间到则强制收题。也可在考试时间尚有剩余时接收答题终端发送过来的答案。收题后进行判分工作并给出最终得分及答题情况统计信息。对回答错误的题目则给出原题及正确答案。
⑶答题终端在收到试题后向考生显示试题内容（可逐道显示）并接受考生输入的答案。试题显示应具备翻页功能以允许考生反复浏览试题或检查所作答案。当考生检查完毕且考试时间尚有剩余，允许考生向服务器发送最终答案。
⑷实现服务器和答题终端的两个单片机系统均应包含键盘和LCD液晶显示模块。两个单片机系统通过串口进行通信。
机系统通过串口进行通信。
  • 验收要求及说明：
⑴给出使用说明，包括按键的定义，操作方法等。
⑵所有功能用途均可实现且各功能转换正常（模拟5道题即可）。
⑶考生个人信息包括考生姓名（可用拼音表示）和6位的学号。
⑷验收时需要演示考生个人信息不正确时的处理情况；
⑸服务器和终端都应实时显示考试剩余时间；
⑹四则运算应覆盖加减乘除四种运算；
⑺终端答题时，在未提交答案前应允许反复浏览或修改答案
  • 整体设计电路图展示


  • 模块展示
  • 终端部分展示
终端的atmega16单片机电路连接如图所示。复位端口连一个上拉电阻，下接一个按键，按键按下时，终端单片机复位，能使终端的显示屏回到初始的界面。在引脚XTAL1和XTAL2上外接石英晶体和电容组成的谐振回路，配合片内的OSC振荡电路构成振荡源。
终端的显示屏设计如图所示，里面有预置的姓名和学号，只有当服务器输入的和终端预置的一致时才能进入系统。
终端的初始页面
通过验证进入系统后终端会开始计时并  答题结束之后，终端会显示正确和错误的题目个数
显示剩余时间，如果验证失败则保持初  在时间规定内，考生可自己提交答案。超出时间的
始页面不变。                        话，则系统强制收卷
  • 客户段部分展示
客户端单片机与终端单片机有相似的地方的这里不做赘述。
客户端键盘展示
键盘完成输入姓名学号、答题功能。旁边还有四个按键，可以实现在答题的时候，上下翻查看题目，答题有误的情况下清除原有答案，和作答完毕时提交答案的功能。
客户端功能展示
初始页面如图所示，要求输入姓名学号，输入有误则会显示“有一个错误，请重新输入”
输入正确则会进入考试系统
显示考试开始，计时并显示剩余的时间。这里我们准备了5道题目，按上下键可以翻动题目清除可以清除答案
考试结束服务端会显示正确和错误的题目个数。
此时按上下键可以查看所有题目和答案
。
  • 程序代码展示


单片机源程序如下:

用户端
  1. #include <mega16.h>
  2. #include <delay.h>

  4. #define BAUD    9600    // 波特率采用9600bps
  5. #define CRYSTAL 4000000 // 系统时钟8MHz

  7. #define BIT0 0X01
  8. #define BIT1 0X02
  9. #define BIT2 0X04
  10. #define BIT3 0X08
  11. #define BIT4 0X10
  12. #define BIT5 0X20
  13. #define BIT6 0X40
  14. #define BIT7 0X80

  16. unsigned char const BIT[]={BIT0,BIT1,BIT2,BIT3,BIT4,BIT5,BIT6,BIT7};

  18. //计算和定义波特率设置参数
  19. #define BAUD_SETTING (unsigned int)((unsigned long)CRYSTAL/(16*(unsigned long)BAUD)-1) // 波特率计算
  20. #define BAUD_H (unsigned char)(BAUD_SETTING>>8) // 高8位
  21. #define BAUD_L (unsigned char)(BAUD_SETTING) // 低8位

  23. unsigned char const num_str[]={"0123456789"};
  24. void USART_INIT(void);
  25. void USART_SEND(unsigned char data); // USART发送子程序
  26. interrupt [USART_RXC] void USART_RCV_INT(void); // USART接收中断服务
  27. void lcd_gpio_init(void);
  28. void LcdInitiate(void);
  29. void LCD1602_string(unsigned char hang,unsigned char lie,unsigned char const *p);
  30. void LCD1602_char(unsigned char hang,unsigned char lie,unsigned char sign);
  31. void KEY_INIT(void);
  32. void KEY_CHECK(void);
  33. void key(void);
  34. unsigned char input_buf[16],input_cnt = 0;
  35. unsigned char timu_buf[5][16],daan_buf[5][2];
  36. unsigned char flag_steep = 0,rx_buf[16],rx_cnt=0,rx_cnt_r=0;
  37. unsigned char timu_pos = 0;
  38. unsigned char lcd_buf[16],lcd_cnt=0;
  39. void main( void )
  40. {
  41.     unsigned char dat=0,i,lcd_buf[16],lcd_cnt;
  42.     unsigned int  tim_cnt = 0,t = 0;
  43.     KEY_INIT();
  44.     USART_INIT();
  45.     lcd_gpio_init();
  46.     LcdInitiate();
  47.     LCD1602_string(1,1,"Your Name:");
  48.     LCD1602_string(2,1,"Your Num:");
  49.     #asm("sei") // 开中断
  50.     flag_steep = 0;
  51.     while(1)
  52.     {   
  53.         delay_ms(1);
  54.         key();
  55.         KEY_CHECK();  
  56.         if(flag_steep==0)//输入考生信息
  57.         {   
  58.             if(input_cnt<=3)
  59.             {
  60.                 lcd_cnt = 0;
  61.                 for(i=0;i<input_cnt;i++)
  62.                 {
  63.                     lcd_buf[lcd_cnt++] = input_buf[i];
  64.                 }
  65.                 lcd_buf[lcd_cnt++] = 0;
  66.                 //LCD1602_string(1,11,"      \0");
  67.                 LCD1602_string(1,11,lcd_buf);
  68.             }
  69.             else if(input_cnt>3&&input_cnt<=9)
  70.             {
  71.                 lcd_cnt = 0;
  72.                 for(i=0;i<(input_cnt-3);i++)
  73.                 {
  74.                     lcd_buf[lcd_cnt++] = input_buf[i+3]+'0';  
  75.                 }
  76.                 lcd_buf[lcd_cnt++] = 0;
  77.                 LCD1602_string(2,10,lcd_buf);
  78.                 if(input_cnt==9)
  79.                 {   
  80.                     input_cnt = 0;
  81.                     lcd_cnt = 0;
  82.                     lcd_buf[lcd_cnt++] = 0x00;//发送考生信息
  83.                     for(i=0;i<9;i++)lcd_buf[lcd_cnt++] = input_buf[i];
  84.                     for(i=0;i<10;i++)USART_SEND(lcd_buf[i]);   
  85.                 }
  86.             }           
  87.         }
  88.         else if(flag_steep==1)
  89.         {
  90.             if(t<1000)t++;
  91.             else
  92.             {
  93.                 t= 0;
  94.                 tim_cnt--;
  95.                 lcd_cnt = 0;
  96.                 lcd_buf[lcd_cnt++] = 0x01;//发送剩余时间
  97.                 lcd_buf[lcd_cnt++] = tim_cnt/60;//发送剩余分钟
  98.                 lcd_buf[lcd_cnt++] = tim_cnt%60;//发送剩余秒钟   
  99.                 for(i=0;i<3;i++)USART_SEND(lcd_buf[i]);
  100.                 LCD1602_string(1,1,"Time left:");
  101.                 lcd_cnt = 0;
  102.                 lcd_buf[lcd_cnt++] = tim_cnt/60/10%10+'0';
  103.                 lcd_buf[lcd_cnt++] = tim_cnt/60%10+'0';
  104.                 lcd_buf[lcd_cnt++] = ':';
  105.                 lcd_buf[lcd_cnt++] = tim_cnt%60/10%10+'0';
  106.                 lcd_buf[lcd_cnt++] = tim_cnt%60%10+'0';
  107.                 lcd_buf[lcd_cnt++] = 0;
  108.                 LCD1602_string(1,11,lcd_buf);
  109.                 if(tim_cnt==0)
  110.                 {
  111.                     flag_steep = 2;
  112.                     LCD1602_string(2,1,"The exam is over\0");
  113.                 }
  114.             }
  115.         }
  116.         if(rx_cnt)
  117.         {
  118.             if(rx_cnt == rx_cnt_r)
  119.             {   
  120.                 if(rx_cnt==16)
  121.                 {
  122.                     for(i=0;i<15;i++)
  123.                     {
  124.                         timu_buf[rx_buf[0]-2][i] = rx_buf[i+1];
  125.                     }
  126.                     LCD1602_string(2,1,"                \0");
  127.                     for(i=0;i<13;i++)lcd_buf[i] = timu_buf[0][i];
  128.                     lcd_buf[i] = 0;
  129.                     LCD1602_string(2,1,lcd_buf);        
  130.                 }
  131.                 else if(rx_buf[0]==0x00&&rx_buf[1]==0x01&&rx_cnt==2)
  132.                 {
  133.                     LCD1602_string(1,1,"                \0");
  134.                     LCD1602_string(2,1,"                \0");
  135.                     LCD1602_string(1,1,"There is an Err!\0");
  136.                     LCD1602_string(2,1,"Please Again !  \0");
  137.                     delay_ms(1000);
  138.                     LCD1602_string(1,1,"                \0");
  139.                     LCD1602_string(2,1,"                \0");
  140.                     LCD1602_string(1,1,"Your Name:");
  141.                     LCD1602_string(2,1,"Your Num:");
  142.                     input_cnt = 0;        
  143.                 }
  144.                 else if(rx_buf[0]==0x01&&rx_cnt==3)//收到开始考试指令
  145.                 {
  146.                     tim_cnt =  rx_buf[1];
  147.                     tim_cnt =  tim_cnt*60 + rx_buf[2];
  148.                     flag_steep = 1;
  149.                     t = 0;
  150.                     LCD1602_string(1,1," lets start              \0");
  151.                     LCD1602_string(2,1," the exam              \0");
  152.                 }
  153.                 rx_cnt = 0;
  154.             }
  155.             rx_cnt_r = rx_cnt;
  156.         }
  157.     }
  158. }


  161. void input_dat(unsigned char dat)
  162. {
  163.     unsigned char i;
  164.     if(flag_steep==0&&input_cnt<3&&(dat>='A'&&dat<='F'))
  165.     {
  166.         input_buf[input_cnt++] = dat;         
  167.     }
  168.     else if(flag_steep==0&&input_cnt>=3&&input_cnt<9&&(dat>=0&&dat<=9))
  169.     {
  170.         input_buf[input_cnt++] = dat;         
  171.     }
  172.     else if(flag_steep==1&&input_cnt<2&&(dat>=0&&dat<=9))
  173.     {   
  174.         if(input_cnt==0)
  175.         {
  176.             for(i=0;i<2;i++)daan_buf[timu_pos][i]=' ';
  177.         }
  178.         daan_buf[timu_pos][input_cnt++] = dat+'0';
  179.         if(input_cnt==2)input_cnt = 0;
  180.         LCD1602_string(2,14,"   \0");
  181.         for(i=0;i<2;i++)lcd_buf[i] = daan_buf[timu_pos][i];
  182.         lcd_buf[i] = 0;
  183.         LCD1602_string(2,14,lcd_buf);
  184.     }
  185. }
  186. interrupt [USART_RXC] void USART_RCV_INT(void) // USART接收中断服务
  187. {
  188.     unsigned char data;
  189.     data = UDR; // 接收数据
  190.     if(rx_cnt<16)
  191.     {
  192.         rx_buf[rx_cnt++] = data;
  193.     }
  194. }
  195. /**************KEY*************************/
  196. void KEY_INIT(void)
  197. {
  198.     PORTC = 0xF0; //输出
  199.     DDRC  = 0x0F; //输入,上拉有效
  200.     PORTB |= 0x0F;
  201.     DDRB  &= 0xF0;
  202. }
  203. void KEY_CHECK(void)
  204. {   
  205.     unsigned char i,j,k;
  206.     if((PINB&0x01)==0) //+
  207.     {
  208.         if(timu_pos<4)timu_pos++;
  209.         else timu_pos = 0;
  210.         if(flag_steep==1)
  211.         {
  212.             LCD1602_string(2,1,"                \0");
  213.             for(i=0;i<13;i++)lcd_buf[i] = timu_buf[timu_pos][i];
  214.             lcd_buf[i] = 0;
  215.             LCD1602_string(2,1,lcd_buf);
  216.             LCD1602_string(2,14,"   \0");
  217.             for(i=0;i<2;i++)lcd_buf[i] = daan_buf[timu_pos][i];
  218.             lcd_buf[i] = 0;
  219.             LCD1602_string(2,14,lcd_buf);   
  220.         }
  221.         else if(flag_steep==2)
  222.         {
  223.             LCD1602_string(2,1,"                \0");
  224.             for(i=0;i<15;i++)lcd_buf[i] = timu_buf[timu_pos][i];
  225.             lcd_buf[i] = 0;
  226.             LCD1602_string(2,1,lcd_buf);        
  227.         }
  228.         while((PINB&0x01)==0);
  229.     }
  230.     else if((PINB&0x02)==0) //-
  231.     {
  232.         if(timu_pos>0)timu_pos--;
  233.         else timu_pos = 4;
  234.         if(flag_steep==1)
  235.         {
  236.             LCD1602_string(2,1,"                \0");
  237.             for(i=0;i<13;i++)lcd_buf[i] = timu_buf[timu_pos][i];
  238.             lcd_buf[i] = 0;
  239.             LCD1602_string(2,1,lcd_buf);
  240.             LCD1602_string(2,14,"   \0");
  241.             for(i=0;i<2;i++)lcd_buf[i] = daan_buf[timu_pos][i];
  242.             lcd_buf[i] = 0;
  243.             LCD1602_string(2,14,lcd_buf);   
  244.         }
  245.         else if(flag_steep==2)
  246.         {
  247.             LCD1602_string(2,1,"                \0");
  248.             for(i=0;i<15;i++)lcd_buf[i] = timu_buf[timu_pos][i];
  249.             lcd_buf[i] = 0;
  250.             LCD1602_string(2,1,lcd_buf);        
  251.         }
  252.         while((PINB&0x02)==0);
  253.     }
  254.     else if((PINB&0x04)==0) //clr
  255.     {
  256.         if(flag_steep==1)
  257.         {   
  258.             for(i=0;i<2;i++)daan_buf[timu_pos][i]=' ';
  259.             input_cnt = 0;
  260.             LCD1602_string(2,14,"   \0");
  261.             while((PINB&0x04)==0);   
  262.         }
  263.     }
  264.     else if((PINB&0x08)==0) //OK
  265.     {
  266.         flag_steep = 2;
  267.         k = 5;
  268.         for(j=0;j<5;j++)
  269.         {
  270.             for(i=0;i<2;i++)
  271.             {
  272.                 if(timu_buf[j][i+13]!=daan_buf[j][i])
  273.                 {     
  274.                     k--;
  275.                     break;
  276.                 }
  277.             }
  278.         }
  279.         LCD1602_string(1,1,"                \0");
  280.         LCD1602_string(1,1," exam is over ! \0");
  281.         LCD1602_string(2,1,"                \0");
  282.         LCD1602_string(2,1,"currut :\0");
  283.         LCD1602_char(2,9,k+'0');
  284.         LCD1602_string(2,10," Err:\0");
  285.         LCD1602_char(2,16,5-k+'0');
  286.         USART_SEND(0x09);
  287.         USART_SEND(k);
  288.         while((PINB&0x08)==0);
  289.     }  
  290. }
  291. /***************KEY ***********************/
  292. #define KEY_H1 0
  293. #define KEY_H2 1
  294. #define KEY_H3 2
  295. #define KEY_H4 3

  297. #define KEY_L1 4
  298. #define KEY_L2 5
  299. #define KEY_L3 6
  300. #define KEY_L4 7

  302. #define KEY_H1_GPIO                PORTC
  303. #define KEY_H1_PIN                 PINC  
  304. #define KEY_H1_GPIO_DDR            DDRC
  305. #define KEY_H1_GPIO_DDR_OUT        (KEY_H1_GPIO_DDR |= BIT[KEY_H1])
  306. #define KEY_H1_GPIO_DDR_IN         (KEY_H1_GPIO_DDR &= ~BIT[KEY_H1])
  307. #define KEY_H1_SET()                        (KEY_H1_GPIO |= BIT[KEY_H1])
  308. #define KEY_H1_RST()               (KEY_H1_GPIO &= ~BIT[KEY_H1])
  309. #define KEY_H1_GET()               (KEY_H1_PIN&BIT[KEY_H1])

  311. #define KEY_H2_GPIO                PORTC
  312. #define KEY_H2_PIN                 PINC  
  313. #define KEY_H2_GPIO_DDR            DDRC
  314. #define KEY_H2_GPIO_DDR_OUT        (KEY_H2_GPIO_DDR |= BIT[KEY_H2])
  315. #define KEY_H2_GPIO_DDR_IN         (KEY_H2_GPIO_DDR &= ~BIT[KEY_H2])
  316. #define KEY_H2_SET()                        (KEY_H2_GPIO |= BIT[KEY_H2])
  317. #define KEY_H2_RST()               (KEY_H2_GPIO &= ~BIT[KEY_H2])
  318. #define KEY_H2_GET()               (KEY_H2_PIN&BIT[KEY_H2])

  320. #define KEY_H3_GPIO                PORTC
  321. #define KEY_H3_PIN                 PINC  
  322. #define KEY_H3_GPIO_DDR            DDRC
  323. #define KEY_H3_GPIO_DDR_OUT        (KEY_H3_GPIO_DDR |= BIT[KEY_H3])
  324. #define KEY_H3_GPIO_DDR_IN         (KEY_H3_GPIO_DDR &= ~BIT[KEY_H3])
  325. #define KEY_H3_SET()                        (KEY_H3_GPIO |= BIT[KEY_H3])
  326. #define KEY_H3_RST()               (KEY_H3_GPIO &= ~BIT[KEY_H3])
  327. #define KEY_H3_GET()               (KEY_H3_PIN&BIT[KEY_H3])

  329. #define KEY_H4_GPIO                PORTC
  330. #define KEY_H4_PIN                 PINC  
  331. #define KEY_H4_GPIO_DDR            DDRC
  332. #define KEY_H4_GPIO_DDR_OUT        (KEY_H4_GPIO_DDR |= BIT[KEY_H4])
  333. #define KEY_H4_GPIO_DDR_IN         (KEY_H4_GPIO_DDR &= ~BIT[KEY_H4])
  334. #define KEY_H4_SET()                        (KEY_H4_GPIO |= BIT[KEY_H4])
  335. #define KEY_H4_RST()               (KEY_H4_GPIO &= ~BIT[KEY_H4])
  336. #define KEY_H4_GET()               (KEY_H4_PIN&BIT[KEY_H4])

  338. #define KEY_L1_GPIO                PORTC
  339. #define KEY_L1_PIN                 PINC  
  340. #define KEY_L1_GPIO_DDR            DDRC
  341. #define KEY_L1_GPIO_DDR_OUT        (KEY_L1_GPIO_DDR |= BIT[KEY_L1])
  342. #define KEY_L1_GPIO_DDR_IN         (KEY_L1_GPIO_DDR &= ~BIT[KEY_L1])
  343. #define KEY_L1_SET()                        (KEY_L1_GPIO |= BIT[KEY_L1])
  344. #define KEY_L1_RST()               (KEY_L1_GPIO &= ~BIT[KEY_L1])
  345. #define KEY_L1_GET()               (KEY_L1_PIN&BIT[KEY_L1])

  347. #define KEY_L2_GPIO                PORTC
  348. #define KEY_L2_PIN                 PINC  
  349. #define KEY_L2_GPIO_DDR            DDRC
  350. #define KEY_L2_GPIO_DDR_OUT        (KEY_L2_GPIO_DDR |= BIT[KEY_L2])
  351. #define KEY_L2_GPIO_DDR_IN         (KEY_L2_GPIO_DDR &= ~BIT[KEY_L2])
  352. #define KEY_L2_SET()                        (KEY_L2_GPIO |= BIT[KEY_L2])
  353. #define KEY_L2_RST()               (KEY_L2_GPIO &= ~BIT[KEY_L2])
  354. #define KEY_L2_GET()               (KEY_L2_PIN&BIT[KEY_L2])

  356. #define KEY_L3_GPIO                PORTC
  357. #define KEY_L3_PIN                 PINC  
  358. #define KEY_L3_GPIO_DDR            DDRC
  359. #define KEY_L3_GPIO_DDR_OUT        (KEY_L3_GPIO_DDR |= BIT[KEY_L3])
  360. #define KEY_L3_GPIO_DDR_IN         (KEY_L3_GPIO_DDR &= ~BIT[KEY_L3])
  361. #define KEY_L3_SET()                        (KEY_L3_GPIO |= BIT[KEY_L3])
  362. #define KEY_L3_RST()               (KEY_L3_GPIO &= ~BIT[KEY_L3])
  363. #define KEY_L3_GET()               (KEY_L3_PIN&BIT[KEY_L3])

  365. #define KEY_L4_GPIO                PORTC
  366. #define KEY_L4_PIN                 PINC  
  367. #define KEY_L4_GPIO_DDR            DDRC
  368. #define KEY_L4_GPIO_DDR_OUT        (KEY_L4_GPIO_DDR |= BIT[KEY_L4])
  369. #define KEY_L4_GPIO_DDR_IN         (KEY_L4_GPIO_DDR &= ~BIT[KEY_L4])
  370. #define KEY_L4_SET()                        (KEY_L4_GPIO |= BIT[KEY_L4])
  371. #define KEY_L4_RST()               (KEY_L4_GPIO &= ~BIT[KEY_L4])
  372. #define KEY_L4_GET()               (KEY_L4_PIN&BIT[KEY_L4])

  374. unsigned int key_n[16];
  375. bit key_flag=0;
  376. void key_scan(void)
  377. {
  378.         key_flag=0;
  379.         /*****检测第1行****************/
  380.         KEY_H1_RST(); KEY_H2_SET();KEY_H3_SET();KEY_H4_SET();
  381.         if(KEY_L1_GET()==0)
  382.         {
  383.                 delay_ms(1);
  384.                 if(KEY_L1_GET()==0)
  385.                 {
  386.                         key_n[0]++;
  387.                         key_flag=1;        
  388.                 }
  389.         }
  390.         else if(KEY_L2_GET()==0)
  391.         {
  392.                 delay_ms(1);
  393.                 if(KEY_L2_GET()==0)
  394.                 {
  395.                         key_n[1]++;
  396.                         key_flag=1;        
  397.                 }
  398.         }
  399.         else if(KEY_L3_GET()==0)
  400.         {
  401.                 delay_ms(1);
  402.                 if(KEY_L3_GET()==0)
  403.                 {
  404.                         key_n[2]++;
  405.                         key_flag=1;        
  406.                 }
  407.         }
  408.         else if(KEY_L4_GET()==0)
  409.         {
  410.                 delay_ms(1);
  411.                 if(KEY_L4_GET()==0)
  412.                 {
  413.                         key_n[3]++;
  414.                         key_flag=1;        
  415.                 }
  416.         }

  418.         /*****检测第2行****************/
  419.         KEY_H1_SET(); KEY_H2_RST();KEY_H3_SET();KEY_H4_SET();
  420.         if(KEY_L1_GET()==0)
  421.         {
  422.                 delay_ms(1);
  423.                 if(KEY_L1_GET()==0)
  424.                 {
  425.                         key_n[4]++;
  426.                         key_flag=1;        
  427.                 }
  428.         }
  429.         else if(KEY_L2_GET()==0)
  430.         {
  431.                 delay_ms(1);
  432.                 if(KEY_L2_GET()==0)
  433.                 {
  434.                         key_n[5]++;
  435.                         key_flag=1;        
  436.                 }
  437.         }
  438.         else if(KEY_L3_GET()==0)
  439.         {
  440.                 delay_ms(1);
  441.                 if(KEY_L3_GET()==0)
  442.                 {
  443.                         key_n[6]++;
  444.                         key_flag=1;        
  445.                 }
  446.         }
  447.         else if(KEY_L4_GET()==0)
  448.         {
  449.                 delay_ms(1);
  450.                 if(KEY_L4_GET()==0)
  451.                 {
  452.                         key_n[7]++;
  453.                         key_flag=1;        
  454.                 }
  455.         }

  457.         /*****检测第3行****************/
  458.         KEY_H1_SET(); KEY_H2_SET();KEY_H3_RST();KEY_H4_SET();
  459.         if(KEY_L1_GET()==0)
  460.         {
  461.                 delay_ms(1);
  462.                 if(KEY_L1_GET()==0)
  463.                 {
  464.                         key_n[8]++;
  465.                         key_flag=1;        
  466.                 }
  467.         }
  468.         else if(KEY_L2_GET()==0)
  469.         {
  470.                 delay_ms(1);
  471.                 if(KEY_L2_GET()==0)
  472.                 {
  473.                         key_n[9]++;
  474.                         key_flag=1;        
  475.                 }
  476.         }
  477.         else if(KEY_L3_GET()==0)
  478.         {
  479.                 delay_ms(1);
  480.                 if(KEY_L3_GET()==0)
  481.                 {
  482.                         key_n[10]++;
  483.                         key_flag=1;        
  484.                 }
  485.         }
  486.         else if(KEY_L4_GET()==0)
  487.         {
  488.                 delay_ms(1);
  489.                 if(KEY_L4_GET()==0)
  490.                 {
  491.                         key_n[11]++;
  492.                         key_flag=1;        
  493.                 }
  494.         }

  496.         /*****检测第4行****************/
  497.         KEY_H1_SET(); KEY_H2_SET();KEY_H3_SET();KEY_H4_RST();
  498.         if(KEY_L1_GET()==0)
  499.         {
  500.                 delay_ms(1);
  501.                 if(KEY_L1_GET()==0)
  502.                 {
  503.                         key_n[12]++;
  504.                         key_flag=1;        
  505.                 }
  506.         }
  507.         else if(KEY_L2_GET()==0)
  508.         {
  509.                 delay_ms(1);
  510.                 if(KEY_L2_GET()==0)
  511.                 {
  512.                         key_n[13]++;
  513.                         key_flag=1;        
  514.                 }
  515.         }
  516.         else if(KEY_L3_GET()==0)
  517.         {
  518.                 delay_ms(1);
  519.                 if(KEY_L3_GET()==0)
  520.                 {
  521.                         key_n[14]++;
  522.                         key_flag=1;        
  523.                 }
  524.         }
  525.         else if(KEY_L4_GET()==0)
  526.         {
  527.                 delay_ms(1);
  528.                 if(KEY_L4_GET()==0)
  529.                 {
  530.                         key_n[15]++;
  531.                         key_flag=1;        
  532.                 }
  533.         }               
  534. }

  536. void key_pro()
  537. {
  538.         if(key_flag==0)
  539.         {
  540.                 if(key_n[0]>0)//0
  541.                 {
  542.                         key_n[0]=0;        
  543.                         input_dat(0);
  544.                 }
  545.                 else if(key_n[1]>0)//1
  546.                 {
  547.                         key_n[1]=0;
  548.                         input_dat(1);        
  549.                 }
  550.                 else if(key_n[2]>0)//2
  551.                 {
  552.                         key_n[2]=0;
  553.                         input_dat(2);        
  554.                 }
  555.                 else if(key_n[3]>0)//3
  556.                 {
  557.                         key_n[3]=0;
  558.             input_dat(3);        
  559.                 }
  560.                 else if(key_n[4]>0)//4
  561.                 {
  562.                         key_n[4]=0;        
  563.                         input_dat(4);
  564.                 }
  565.                 else if(key_n[5]>0)//5
  566.                 {
  567.                         key_n[5]=0;        
  568.                         input_dat(5);
  569.                 }
  570.                 else if(key_n[6]>0)//6
  571.                 {
  572.                         key_n[6]=0;        
  573.                         input_dat(6);
  574.                 }
  575.                 else if(key_n[7]>0)//乘位
  576.                 {
  577.                         key_n[7]=0;
  578.             input_dat(7);        
  579.                 }
  580.                 else if(key_n[8]>0)//1
  581.                 {
  582.                         key_n[8]=0;        
  583.                         input_dat(8);
  584.                 }
  585.                 else if(key_n[9]>0)//2
  586.                 {
  587.                         key_n[9]=0;        
  588.                         input_dat(9);
  589.                 }
  590.                 else if(key_n[10]>0)//3
  591.                 {
  592.                         key_n[10]=0;
  593.                         input_dat('A');        
  594.                 }
  595.                 else if(key_n[11]>0)//方式数字转换
  596.                 {
  597.                         key_n[11]=0;
  598.             input_dat('B');        
  599.                 }
  600.                 else if(key_n[12]>0)//明暗转换
  601.                 {
  602.                         key_n[12]=0;
  603.             input_dat('C');        
  604.                 }
  605.                 else if(key_n[13]>0)//0
  606.                 {
  607.                         key_n[13]=0;
  608.                         input_dat('D');        
  609.                 }
  610.                 else if(key_n[14]>0)//接收
  611.                 {
  612.                         key_n[14]=0;
  613.             input_dat('E');
  614.                 }
  615.                 else if(key_n[15]>0)//发送
  616.                 {
  617.                         key_n[15]=0;
  618.             input_dat('F');        
  619.                 }                        
  620.         }
  621. }
  622. void key(void)
  623. {
  624.         key_scan();
  625.         key_pro();
  626. }
  627. /**************UART*************************/
  628. void USART_INIT(void)
  629. {
  630.     PORTD = 0x02; // TXD(PD1)输出
  631.     DDRD  = 0x00; // RXD(PD0)输入,上拉有效
  632.     UCSRA = 0x00; // USART初始化
  633.     UCSRB = (1<<RXCIE)|(1<<RXEN)|(1<<TXEN); // 允许RXC中断,接收允许,发送允许
  634.     // UCSRB = 0x98;
  635.     UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); // 8 Data, 1 Stop, No Parity
  636.     // UCSRC = 0x86;
  637.     UBRRH = BAUD_H; // 设置波特率，1200bps
  638.     UBRRL = BAUD_L;
  639. }
  640. void USART_SEND(unsigned char data) // USART发送子程序
  641. {
  642.     while (!(UCSRA & (1<<UDRE))); // 等待发送寄存器空
  643.     UDR = data; // 发送数据
  644. }
  645. /**************LCD*************************/
  646. #define LCD_DATA_GPIO             PORTA//LCD数据接口定义
  647. #define LCD_DATA_GPIO_DDR         DDRA
  648. #define SET_LCD_DATA_GPIO_DDR     (LCD_DATA_GPIO_DDR|=0XFF)
  649. #define CLR_LCD_DATA_GPIO_DDR     (LCD_DATA_GPIO_DDR&=0X00)

  651. #define LCD_RS 5
  652. #define LCD_RW 6
  653. #define LCD_EN 7

  655. #define LCD_RS_GPIO                PORTB
  656. #define LCD_RS_GPIO_DDR            DDRB
  657. #define SET_LCD_RS_GPIO_DDR        (LCD_RS_GPIO_DDR|=BIT[LCD_RS])
  658. #define CLR_LCD_RS_GPIO_DDR        (LCD_RS_GPIO_DDR&=~BIT[LCD_RS])
  659. #define RS_SET() (LCD_RS_GPIO|=BIT[LCD_RS])
  660. #define RS_RST() (LCD_RS_GPIO&=~BIT[LCD_RS])

  662. #define LCD_RW_GPIO                PORTB
  663. #define LCD_RW_GPIO_DDR            DDRB
  664. #define SET_LCD_RW_GPIO_DDR        (LCD_RW_GPIO_DDR|=BIT[LCD_RW])
  665. #define CLR_LCD_RW_GPIO_DDR        (LCD_RW_GPIO_DDR&=~BIT[LCD_RW])
  666. #define RW_SET() (LCD_RW_GPIO|=BIT[LCD_RW])
  667. #define RW_RST() (LCD_RW_GPIO&=~BIT[LCD_RW])   

  669. #define LCD_EN_GPIO                PORTB
  670. #define LCD_EN_GPIO_DDR            DDRB
  671. #define SET_LCD_EN_GPIO_DDR        (LCD_EN_GPIO_DDR|=BIT[LCD_EN])
  672. #define CLR_LCD_EN_GPIO_DDR        (LCD_EN_GPIO_DDR&=~BIT[LCD_EN])
  673. #define EN_SET() (LCD_EN_GPIO|=BIT[LCD_EN])
  674. #define EN_RST() (LCD_EN_GPIO&=~BIT[LCD_EN])



  678. void lcd_gpio_init(void)
  679. {
  680.     SET_LCD_RS_GPIO_DDR;
  681.     SET_LCD_RW_GPIO_DDR;
  682.     SET_LCD_EN_GPIO_DDR;
  683. }
  684. /*****************************************************
  685. 函数功能：将模式设置指令或显示地址写入液晶模块
  686. 入口参数：dictate
  687. ***************************************************/
  688. void WriteInstruction (unsigned char dictate)
  689. {   
  690.      delay_ms(2);
  691.      RS_RST();                  //根据规定，RS和R/W同时为低电平时，可以写入指令
  692.      RW_RST();   
  693.      EN_RST();                   //E置低电平(根据表8-6，写指令时，E为高脉冲，
  694.                              // 就是让E从0到1发生正跳变，所以应先置"0"
  695.      delay_us(2);            //空操作两个机器周期，给硬件反应时间
  696.      LCD_DATA_GPIO=dictate;            //将数据送入P0口，即写入指令或地址
  697.      delay_us(4);               //空操作四个机器周期，给硬件反应时间
  698.      EN_SET();                   //E置高电平
  699.      delay_us(4);               //空操作四个机器周期，给硬件反应时间
  700.      EN_RST();                  //当E由高电平跳变成低电平时，液晶模块开始执行命令
  701. }
  702. /*****************************************************
  703. 函数功能：指定字符显示的实际地址
  704. 入口参数：x
  705. ***************************************************/
  706. void WriteAddress(unsigned char x)
  707. {
  708.      WriteInstruction(x|0x80); //显示位置的确定方法规定为"80H+地址码x"
  709. }
  710. /*****************************************************
  711. 函数功能：将数据(字符的标准ASCII码)写入液晶模块
  712. 入口参数：y(为字符常量)
  713. ***************************************************/
  714. void WriteData(unsigned char y)
  715. {
  716.       delay_ms(2);  
  717.       RS_SET();           //RS为高电平，RW为低电平时，可以写入数据
  718.       RW_RST();
  719.       EN_RST();            //E置低电平(根据表8-6，写指令时，E为高脉冲，
  720.                        // 就是让E从0到1发生正跳变，所以应先置"0"
  721.       LCD_DATA_GPIO=y;           //将数据送入P0口，即将数据写入液晶模块
  722.       delay_us(4);      //空操作四个机器周期，给硬件反应时间
  723.       EN_SET();          //E置高电平
  724.       delay_us(40);       //空操作四个机器周期，给硬件反应时间
  725.           EN_RST();            //当E由高电平跳变成低电平时，液晶模块开始执行命令
  726. }

  728. void LCD1602_char(unsigned char hang,unsigned char lie,unsigned char sign)//显示一个字节
  729. {
  730.         unsigned char a;
  731.         if(hang == 1)a = 0x00;
  732.         if(hang == 2)a = 0x40;
  733.         a = a + lie - 1;
  734.         WriteAddress(a);//向LCD写入数据要显示的地址
  735.         WriteData(sign);//向LCD写入要显示的数据
  736. }
  737. void LCD1602_string(unsigned char hang,unsigned char lie,unsigned char const *p)//向LCD写入要显示的字符串
  738. {
  739.         unsigned char a;
  740.         if(hang == 1) a = 0x00;
  741.         if(hang == 2) a = 0x40;
  742.         a = a + lie - 1;
  743.         WriteAddress(a);//写入显示的首地址
  744.         while(1)
  745.         {
  746.                 if(*p == '\0') break;
  747.                 WriteData(*p);
  748.                 p++;
  749.         }
  750. }
  751. /*****************************************************
  752. 函数功能：对LCD的显示模式进行初始化设置
  753. ***************************************************/
  754. void LcdInitiate(void)
  755. {
  756.     delay_ms(15);             //延时15ms，首次写指令时应给LCD一段较长的反应时间
  757.     WriteInstruction(0x38);  //显示模式设置：16×2显示，5×7点阵，8位数据接口
  758.     delay_ms(5);   //延时5ms　
  759.     WriteInstruction(0x38);
  760.     delay_ms(5);
  761.     WriteInstruction(0x38);
  762.     delay_ms(5);
  763.     WriteInstruction(0x0c);  //显示模式设置：显示开，有光标，光标闪烁
  764.     delay_ms(5);
  765.     WriteInstruction(0x06);  //显示模式设置：光标右移，字符不移
  766.     delay_ms(5);
  767.     WriteInstruction(0x01);  //清屏幕指令，将以前的显示内容清除
  768.     delay_ms(5);
  769.     LCD1602_string(1,1," \0");
  770. }
  771. 终端程序
  772. #include <mega16.h>
  773. #include <delay.h>

  775. #define BAUD    9600    // 波特率采用9600bps
  776. #define CRYSTAL 4000000 // 系统时钟4MHz

  778. //计算和定义波特率设置参数
  779. #define BAUD_SETTING (unsigned int)((unsigned long)CRYSTAL/(16*(unsigned long)BAUD)-1) // 波特率计算
  780. #define BAUD_H (unsigned char)(BAUD_SETTING>>8) // 高8位
  781. #define BAUD_L (unsigned char)(BAUD_SETTING) // 低8位

  783. unsigned char const num_str[]={"0123456789"};
  784. void USART_INIT(void);
  785. void USART_SEND(unsigned char data); // USART发送子程序
  786. void USART_SEND_N(unsigned char num,unsigned char *buf);
  787. interrupt [USART_RXC] void USART_RCV_INT(void); // USART接收中断服务
  788. void lcd_gpio_init(void);
  789. void LcdInitiate(void);
  790. void LCD1602_string(unsigned char hang,unsigned char lie,unsigned char const *p);
  791. void LCD1602_char(unsigned char hang,unsigned char lie,unsigned char sign);
  792. unsigned char rx_buf[16],rx_cnt=0,rx_cnt_r=0;
  793. void main(void)
  794. {
  795.     unsigned char dat=0,i,flag_start = 0,lcd_buf[16],lcd_cnt;
  796.     unsigned int tim_cnt = 0,t = 0;
  797.     USART_INIT();
  798.     lcd_gpio_init();
  799.     LcdInitiate();
  800.     LCD1602_string(1,1,"Name:CDE\0");
  801.     LCD1602_string(2,1,"Num:987654\0");
  802.     #asm("sei") // 开中断      
  803.     while(1)
  804.     {     
  805.         delay_ms(1);
  806.         if(flag_start==2)
  807.         {
  808.             
  809.         }
  810.         else if(flag_start==1)
  811.         {
  812.                
  813.         }
  814.         if(rx_cnt)
  815.         {
  816.             if(rx_cnt == rx_cnt_r)
  817.             {   
  818.                 if(rx_buf[0]==0x09&&rx_cnt==2)
  819.                 {
  820.                     LCD1602_string(1,1,"                \0");
  821.                     LCD1602_string(1,1," exam is over ! \0");
  822.                     LCD1602_string(2,1,"                \0");
  823.                     LCD1602_string(2,1,"currut :\0");
  824.                     LCD1602_char(2,9,rx_buf[1]+'0');
  825.                     LCD1602_string(2,10," Err:\0");
  826.                     LCD1602_char(2,16,5-rx_buf[1]+'0');     
  827.                 }
  828.                 else if(rx_buf[0]==0x00&&rx_cnt==10)
  829.                 {
  830.                     lcd_cnt = 0;
  831.                     for(i=0;i<3;i++)
  832.                     {
  833.                         if(rx_buf[i+1]!=('C'+i))break;   
  834.                     }
  835.                     if(i==3)
  836.                     {
  837.                         for(i=0;i<6;i++)
  838.                         {
  839.                             if(rx_buf[i+4]!=(9-i))break;   
  840.                         }   
  841.                     }
  842.                     if(i==6)
  843.                     {
  844.                         flag_start = 1;      
  845.                         LCD1602_string(1,1,"From the end of \0");
  846.                         LCD1602_string(2,1,"the exam->00:00 \0");
  847.                         //发送时间
  848.                         lcd_cnt = 0;
  849.                         lcd_buf[lcd_cnt++] = 0x01;//发送时间
  850.                         lcd_buf[lcd_cnt++] = 0x02;//发送分钟
  851.                         lcd_buf[lcd_cnt++] = 0x00;//发送秒钟
  852.                         for(i=0;i<lcd_cnt;i++)USART_SEND(lcd_buf[i]);
  853.                        delay_ms(300);
  854.                         USART_SEND(0x02); //发送题1
  855.                         USART_SEND_N(15,"3+1*3+6/2=   9 ");
  856.                         delay_ms(300);
  857.                         USART_SEND(0x03); //发送题2
  858.                         USART_SEND_N(15,"5+10/5+1*1=  11");
  859.                         delay_ms(300);
  860.                         USART_SEND(0x04); //发送题3
  861.                         USART_SEND_N(15,"9-3*3+2*1=   2 ");
  862.                         delay_ms(300);
  863.                         USART_SEND(0x05); //发送题4
  864.                         USART_SEND_N(15,"12/3+8/4+2=  8 ");
  865.                         delay_ms(300);
  866.                         USART_SEND(0x06); //发送题5
  867.                         USART_SEND_N(15,"15/3+2*6-11= 6 ");
  868.                     }
  869.                     else
  870.                     {
  871.                         lcd_cnt = 0;
  872.                         lcd_buf[lcd_cnt++] = 0x00;//发送考生校验
  873.                         lcd_buf[lcd_cnt++] = 0x01;//发送错误
  874.                         for(i=0;i<lcd_cnt;i++)USART_SEND(lcd_buf[i]);   
  875.                     }      
  876.                 }
  877.                 else if(rx_buf[0]==0x01&&rx_cnt==3)//收到开始考试指令
  878.                 {
  879.                         tim_cnt =  rx_buf[1];
  880.                         tim_cnt =  tim_cnt*60 + rx_buf[2];
  881.                         lcd_cnt = 0;
  882.                         lcd_buf[lcd_cnt++] = rx_buf[1]/10%10+'0';
  883.                         lcd_buf[lcd_cnt++] = rx_buf[1]%10+'0';
  884.                         lcd_buf[lcd_cnt++] = 0;
  885.                         LCD1602_string(2,11,lcd_buf);
  886.                         lcd_cnt = 0;
  887.                         lcd_buf[lcd_cnt++] = rx_buf[2]/10%10+'0';
  888.                         lcd_buf[lcd_cnt++] = rx_buf[2]%10+'0';
  889.                         lcd_buf[lcd_cnt++] = 0;
  890.                         LCD1602_string(2,14,lcd_buf);
  891.                         
  892.                 }
  893.                 rx_cnt = 0;
  894.             }
  895.             rx_cnt_r = rx_cnt;
  896.         }
  897.     }
  898. }


  901. interrupt [USART_RXC] void USART_RCV_INT(void) // USART接收中断服务
  902. {
  903.     unsigned char data;
  904.     data = UDR; // 接收数据
  905.     if(rx_cnt<16)
  906.     {
  907.         rx_buf[rx_cnt++] = data;
  908.     }
  909. }

  911. /**************UART*************************/
  912. void USART_INIT(void)
  913. {
  914.     PORTD = 0x02; // TXD(PD1)输出
  915.     DDRD  = 0x00; // RXD(PD0)输入,上拉有效
  916.     UCSRA = 0x00; // USART初始化
  917.     UCSRB = (1<<RXCIE)|(1<<RXEN)|(1<<TXEN); // 允许RXC中断,接收允许,发送允许
  918.     // UCSRB = 0x98;
  919.     UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); // 8 Data, 1 Stop, No Parity
  920.     // UCSRC = 0x86;
  921.     UBRRH = BAUD_H; // 设置波特率，1200bps
  922.     UBRRL = BAUD_L;
  923. }
  924. void USART_SEND(unsigned char data) // USART发送子程序
  925. {
  926.     while (!(UCSRA & (1<<UDRE))); // 等待发送寄存器空
  927.     UDR = data; // 发送数据
  928. }
  929. void USART_SEND_N(unsigned char num,unsigned char *buf)
  930. {
  931.     unsigned char i;
  932.     for(i=0;i<num;i++)
  933.     {
  934.         USART_SEND(buf[i]);   
  935.     }   
  936. }
  937. /**************LCD*************************/
  938. #define BIT0 0X01
  939. #define BIT1 0X02
  940. #define BIT2 0X04
  941. #define BIT3 0X08
  942. #define BIT4 0X10
  943. #define BIT5 0X20
  944. #define BIT6 0X40
  945. #define BIT7 0X80

  947. unsigned char const BIT[]={BIT0,BIT1,BIT2,BIT3,BIT4,BIT5,BIT6,BIT7};

  949. #define LCD_DATA_GPIO             PORTA//LCD数据接口定义
  950. #define LCD_DATA_GPIO_DDR         DDRA
  951. #define SET_LCD_DATA_GPIO_DDR     (LCD_DATA_GPIO_DDR|=0XFF)
  952. #define CLR_LCD_DATA_GPIO_DDR     (LCD_DATA_GPIO_DDR&=0X00)

  954. #define LCD_RS 5
  955. #define LCD_RW 6
  956. #define LCD_EN 7

  958. #define LCD_RS_GPIO                PORTB
  959. #define LCD_RS_GPIO_DDR            DDRB
  960. #define SET_LCD_RS_GPIO_DDR        (LCD_RS_GPIO_DDR|=BIT[LCD_RS])
  961. #define CLR_LCD_RS_GPIO_DDR        (LCD_RS_GPIO_DDR&=~BIT[LCD_RS])
  962. #define RS_SET() (LCD_RS_GPIO|=BIT[LCD_RS])
  963. #define RS_RST() (LCD_RS_GPIO&=~BIT[LCD_RS])

  965. #define LCD_RW_GPIO                PORTB
  966. #define LCD_RW_GPIO_DDR            DDRB
  967. #define SET_LCD_RW_GPIO_DDR        (LCD_RW_GPIO_DDR|=BIT[LCD_RW])
  968. #define CLR_LCD_RW_GPIO_DDR        (LCD_RW_GPIO_DDR&=~BIT[LCD_RW])
  969. #define RW_SET() (LCD_RW_GPIO|=BIT[LCD_RW])
  970. #define RW_RST() (LCD_RW_GPIO&=~BIT[LCD_RW])   

  972. #define LCD_EN_GPIO                PORTB
  973. #define LCD_EN_GPIO_DDR            DDRB
  974. #define SET_LCD_EN_GPIO_DDR        (LCD_EN_GPIO_DDR|=BIT[LCD_EN])
  975. #define CLR_LCD_EN_GPIO_DDR        (LCD_EN_GPIO_DDR&=~BIT[LCD_EN])
  976. #define EN_SET() (LCD_EN_GPIO|=BIT[LCD_EN])
  977. #define EN_RST() (LCD_EN_GPIO&=~BIT[LCD_EN])



  981. void lcd_gpio_init(void)
  982. {
  983.     SET_LCD_RS_GPIO_DDR;
  984.     SET_LCD_RW_GPIO_DDR;
  985.     SET_LCD_EN_GPIO_DDR;
  986. }
  987. /*****************************************************
  988. 函数功能：将模式设置指令或显示地址写入液晶模块
  989. 入口参数：dictate
  990. ***************************************************/
  991. void WriteInstruction (unsigned char dictate)
  992. {   
  993.      delay_ms(2);
  994.      RS_RST();                  //根据规定，RS和R/W同时为低电平时，可以写入指令
  995.      RW_RST();   
  996.      EN_RST();                   //E置低电平(根据表8-6，写指令时，E为高脉冲，
  997.                              // 就是让E从0到1发生正跳变，所以应先置"0"
  998.      delay_us(2);            //空操作两个机器周期，给硬件反应时间
  999.      LCD_DATA_GPIO=dictate;            //将数据送入P0口，即写入指令或地址
  1000.      delay_us(4);               //空操作四个机器周期，给硬件反应时间
  1001.      EN_SET();                   //E置高电平
  1002.      delay_us(4);               //空操作四个机器周期，给硬件反应时间
  1003.      EN_RST();                  //当E由高电平跳变成低电平时，液晶模块开始执行命令
  1004. }
  1005. /*****************************************************
  1006. 函数功能：指定字符显示的实际地址
  1007. 入口参数：x
  1008. ***************************************************/
  1009. void WriteAddress(unsigned char x)
  1010. {
  1011.      WriteInstruction(x|0x80); //显示位置的确定方法规定为"80H+地址码x"
  1012. }
  1013. /*****************************************************
  1014. 函数功能：将数据(字符的标准ASCII码)写入液晶模块
  1015. 入口参数：y(为字符常量)
  1016. ***************************************************/
  1017. void WriteData(unsigned char y)
  1018. {
  1019.       delay_ms(2);  
  1020.       RS_SET();           //RS为高电平，RW为低电平时，可以写入数据
  1021.       RW_RST();
  1022.       EN_RST();            //E置低电平(根据表8-6，写指令时，E为高脉冲，
  1023.                        // 就是让E从0到1发生正跳变，所以应先置"0"
  1024.       LCD_DATA_GPIO=y;           //将数据送入P0口，即将数据写入液晶模块
  1025.       delay_us(4);      //空操作四个机器周期，给硬件反应时间
  1026.       EN_SET();          //E置高电平
  1027.       delay_us(40);       //空操作四个机器周期，给硬件反应时间
  1028.           EN_RST();            //当E由高电平跳变成低电平时，液晶模块开始执行命令
  1029. }

  1031. void LCD1602_char(unsigned char hang,unsigned char lie,unsigned char sign)//显示一个字节
  1032. {
  1033.         unsigned char a;
  1034.         if(hang == 1)a = 0x00;
  1035.         if(hang == 2)a = 0x40;
  1036.         a = a + lie - 1;
  1037.         WriteAddress(a);//向LCD写入数据要显示的地址
  1038.         WriteData(sign);//向LCD写入要显示的数据
  1039. }
  1040. void LCD1602_string(unsigned char hang,unsigned char lie,unsigned char const *p)//向LCD写入要显示的字符串
  1041. {
  1042.         unsigned char a;
  1043.         if(hang == 1) a = 0x00;
  1044.         if(hang == 2) a = 0x40;
  1045.         a = a + lie - 1;
  1046.         WriteAddress(a);//写入显示的首地址
  1047.         while(1)
  1048.         {
  1049.                 if(*p == '\0') break;
  1050.                 WriteData(*p);
  1051.                 p++;
  1052.         }
  1053. }
  1054. /*****************************************************
  1055. 函数功能：对LCD的显示模式进行初始化设置
  1056. ***************************************************/
  1057. void LcdInitiate(void)
  1058. {
  1059.     delay_ms(15);             //延时15ms，首次写指令时应给LCD一段较长的反应时间
  1060.     WriteInstruction(0x38);  //显示模式设置：16×2显示，5×7点阵，8位数据接口
  1061.     delay_ms(5);   //延时5ms　
  1062.     WriteInstruction(0x38);
  1063.     delay_ms(5);
  1064.     WriteInstruction(0x38);
  1065.     delay_ms(5);
  1066.     WriteInstruction(0x0c);  //显示模式设置：显示开，有光标，光标闪烁
  1067.     delay_ms(5);
  1068.     WriteInstruction(0x06);  //显示模式设置：光标右移，字符不移
  1069.     delay_ms(5);
  1070.     WriteInstruction(0x01);  //清屏幕指令，将以前的显示内容清除
  1071.     delay_ms(5);
  1072.     LCD1602_string(1,1," \0");
  1073. }
复制代码

全部资料51hei下载地址：
atmega16设计电子考试系统仿真及程序.rar (870.03 KB, 下载次数: 32)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏3 分享淘帖 顶顶 踩踩
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表