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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 单片机LCD12864程序烧到实物上后出现乱码 运行不正常 仿 ...
返回列表 发新帖
查看: 1455|回复: 4
打印 上一主题 下一主题
收起左侧

单片机LCD12864程序烧到实物上后出现乱码 运行不正常 仿真没问题

[复制链接]
跳转到指定楼层
楼主
ID:1013350 发表于 2022-3-26 22:57 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
本人最近做一个基于avr单片机简易的交通灯系统，原定的功能是在交通灯正常运行时12864显示屏显示“交通灯正常运行”，代码写出来之后仿真也未出现问题，把程序烧进实物之后发现12864显示虽然亮了，但屏上未显示内容，而重复多次复位操作后发现有时会显示几个正确字符，但存在乱码。经百度后判断是时序问题，我修改了多次延时之后都没能让12864正常显示，现问下各位大佬怎么调整时序，以让12864正常运行？


单片机源程序如下:
  1. #define F_CPU 8000000UL
  2. #include <avr/io.h>
  3. #include <util/delay.h>
  4. #include <string.h>
  5. #define uchar unsigned char
  6. #define uint unsigned int
  7. #define RS (1<<5)
  8. #define RW (1<<6)
  9. #define EN (1<<7)
  10. #define delay_ms(x) _delay_ms(x)
  11. #define RED_1 (1<<0)
  12. #define RED_2 (1<<3)
  13. #define YEL_1 (1<<1)
  14. #define YEL_2 (1<<4)
  15. #define GREEN_1 (1<<2)
  16. #define GREEN_2 (1<<5)
  17. //此处定义字符串
  18. char text_1[]={"交通灯正常运行中"};
  19. char text_2[]={"    紧急模式"};
  20. char text_3[]={"调整间断模式"};
  21. char text_4[]={"红灯"};
  22. char text_5[]={"黄灯"};
  23. char red_time[]={"05s"};
  24. char YEL_time[]={"07ms"};
  25. int emer = 0;
  26. int adju = 0;
  27. int key = 0;
  28. int staus = 0;
  29. int n=9,Yel_time=7;
  30. void EEPROM_write(unsigned int uiAddress, unsigned char ucData)
  31. {
  32.         /* 等待上一次写操作结束 */
  33.         while(EECR & (1<<EEWE))
  34.         ;
  35.         /* 设置地址和数据寄存器 */
  36.         EEAR = uiAddress;
  37.         EEDR = ucData;
  38.         /* 置位 EEMWE */
  39.         EECR |= (1<<EEMWE);
  40.         /* 置位 EEWE 以启动写操作 E */
  41.         EECR |= (1<<EEWE);
  42. }
  43. unsigned char EEPROM_read(unsigned int uiAddress)
  44. {
  45.         /* 等待上一次写操作结束 */
  46.         while(EECR & (1<<EEWE))
  47.         ;
  48.         /* 设置地址寄存器 */
  49.         EEAR = uiAddress;
  50.         /* 设置 EERE 以启动读操作 */
  51.         EECR |= (1<<EERE);
  52.         /* 自数据寄存器返回数据 */
  53.         return EEDR;
  54. }
  55. int key_board(void) {
  56.         unsigned char i,j; //键码记录
  57.         unsigned char key_num=0; //按键表示的数字
  58.         i=PIND&0xF3;
  59.         if (i == 0xF3) return key_num; //无按键按下，退出
  60.         delay_ms(10); //去按键颤抖
  61.         j = PIND&0xF3;
  62.         if(i == j) { //二次对比确定按键操作
  63.                 switch (i) { //将按键码转换成键值
  64.                         case 0xF2: key_num=1;break;
  65.                         case 0xF1: key_num=2;break;
  66.                         case 0xE3: key_num=3;break;
  67.                         case 0xD3: key_num=4;break;
  68.                         case 0xB3: key_num=5;break;
  69.                         case 0x73: key_num=6;break;
  70.                         default: key_num=0;break;
  71.                 }
  72.         }
  73.         while(PIND!=0xF3); //等待按键松开
  74.         return key_num;
  75. }
  76. void emer_mode(){
  77.         int a=1;
  78.         WriteCommandLCM(0x01);
  79.         PORTC=(RED_1)|(RED_2);
  80.         PORTA=(GREEN_1)|(GREEN_2);
  81.         DisplayList(0x80,text_2);
  82.         while(a){
  83.                 key=key_board();
  84.                 if (key)
  85.                 {
  86.                         a=0;
  87.                         key=1;
  88.                         WriteCommandLCM(0x01);
  89.                         s_ms(100);
  90.                         DisplayList(0x80,text_1);
  91.                 }
  92.         }
  93. }
  94. void adju_mode(){
  95.         staus = 1;
  96.         int real_time;
  97.         int sit = 0,sel=3;
  98.         unsigned char poab,pocb;
  99.         pocb=PORTC;
  100.         poab=PORTA;
  101.         real_time=n-4;
  102.         WriteCommandLCM(0x01);
  103.         DisplayList(0x80,text_3);
  104.         DisplayList(0x90,text_4);
  105.         DisplayList(0x95,text_5);
  106.         red_time[0]=(real_time/10)+48;
  107.         red_time[1]=(real_time%10)+48;
  108.         YEL_time[0]=(Yel_time/10)+48;
  109.         YEL_time[1]=(Yel_time%10)+48;
  110.         DisplayList(0x88,red_time);
  111.         DisplayList(0x8D,YEL_time);
  112.         PORTC=(RED_1)|(RED_2);
  113.         PORTA=(GREEN_1)|(GREEN_2);
  114.         while(staus){
  115.                 delay_ms(200);
  116.                 sit=key_board();
  117.                 if (sit==3)
  118.                 {
  119.                         sel=sit;
  120.                         PORTC=(RED_1)|(RED_2);
  121.                         PORTA=(GREEN_1)|(GREEN_2);
  122.                 }
  123.                 else if (sit==4)
  124.                 {
  125.                         sel=sit;
  126.                         PORTC=(YEL_1)|(YEL_2);
  127.                         PORTA=(YEL_1)|(YEL_2);
  128.                 }
  129.                 if (sel==3)
  130.                 {
  131.                         PORTC^=(RED_1)|(RED_2);
  132.                         PORTA^=(GREEN_1)|(GREEN_2);
  133.                 }
  134.                 else if (sel==4)
  135.                 {
  136.                         PORTC^=(YEL_1)|(YEL_2);
  137.                         PORTA^=(YEL_1)|(YEL_2);
  138.                 }
  139.                 if (sit==5&&sel==3)
  140.                 {
  141.                         n++;
  142.                         delay_ms(100);
  143.                         if (n-4>15)
  144.                         {
  145.                                 n=9;
  146.                         }
  147.                         EEPROM_write(0x00,n);
  148.                         real_time=n-4;
  149.                         red_time[0]=(real_time/10)+48;
  150.                         red_time[1]=(real_time%10)+48;
  151.                         DisplayList(0x88,red_time);
  152.                 }
  153.                 else if (sit==6&&sel==3)
  154.                 {
  155.                         n--;
  156.                         delay_ms(100);
  157.                         if (n-4<5)
  158.                         {
  159.                                 n=19;
  160.                         }
  161.                         EEPROM_write(0x00,n);
  162.                         real_time=n-4;
  163.                         red_time[0]=(real_time/10)+48;
  164.                         red_time[1]=(real_time%10)+48;
  165.                         DisplayList(0x88,red_time);
  166.                 }
  167.                 if (sit==5&&sel==4)
  168.                 {
  169.                         Yel_time++;
  170.                         delay_ms(100);
  171.                         if (Yel_time>20)
  172.                         {
  173.                                 Yel_time=5;
  174.                         }
  175.                         EEPROM_write(0x08,Yel_time);
  176.                         YEL_time[0]=(Yel_time/10)+48;
  177.                         YEL_time[1]=(Yel_time%10)+48;
  178.                         DisplayList(0x8D,YEL_time);
  179.                 }
  180.                 else if (sit==6&&sel==4)
  181.                 {
  182.                         Yel_time--;
  183.                         delay_ms(100);
  184.                         if (Yel_time<5)
  185.                         {
  186.                                 Yel_time=20;
  187.                         }
  188.                         EEPROM_write(0x08,Yel_time);
  189.                         YEL_time[0]=(Yel_time/10)+48;
  190.                         YEL_time[1]=(Yel_time%10)+48;
  191.                         DisplayList(0x8D,YEL_time);
  192.                 }
  193.                 if (sit==2)
  194.                 {
  195.                         WriteCommandLCM(0x01);
  196.                         s_ms(100);
  197.                         DisplayList(0x80,text_1);
  198.                         PORTA=poab;
  199.                         PORTC=pocb;
  200.                         staus=0;
  201.                 }
  202.         }
  203. }
  204. void get_key(){
  205.         int sel=0;
  206.         sel=key_board();
  207.         if (sel==1)
  208.         {
  209.                 emer_mode();
  210.         }
  211.         else if (sel==2)
  212.         {
  213.                 adju_mode();
  214.         }
  215. }
  216. //延时函数
  217. void s_ms(uint ms)
  218. {
  219.         int a;
  220.         for (a=0;a<1;a++)
  221.         {
  222.                 for(;ms>1;ms--);
  223.         }
  224. }

  226. //写数据
  227. void WriteDataLCM(unsigned char WDLCM)
  228. {
  229.         ReadStatusLCM(); //检测忙
  230.         s_ms(100);
  231.         PORTE|=RS;       //RS=1
  232.         s_ms(100);
  233.         PORTE&=~RW;      //RW=0
  234.         s_ms(100);
  235.         PORTE|=EN;       //EN=1
  236.         s_ms(100);
  237.         PORTB=WDLCM;     //输出数据
  238.         s_ms(100);
  239.         PORTE&=~EN;      //EN=0
  240.         s_ms(100);
  241. }

  243. //写指令
  244. void WriteCommandLCM(unsigned char WCLCM)
  245. {
  246.         ReadStatusLCM(); //根据需要检测忙
  247.         s_ms(100);
  248.         PORTE&=~RS;      //RS=0
  249.         s_ms(100);
  250.         PORTE&=~RW;      //RW=0
  251.         s_ms(100);
  252.         PORTE|=EN;       //EN=1
  253.         s_ms(100);
  254.         PORTB=WCLCM;     //输出指令
  255.         s_ms(100);
  256.         PORTE&=~EN;      //EN=0
  257.         s_ms(100);
  258. }

  260. //读状态:检测忙
  261. void ReadStatusLCM(void)
  262. {
  263.         uchar temp;
  264.         uchar flag = 1;
  265.         while(flag==1)
  266.         {
  267.                 DDRB=0x00;      //端口B改为输入
  268.                 PORTB=0xff;
  269.                 s_ms(100);
  270.                 PORTE&=~RS;     //RS=0
  271.                 s_ms(100);
  272.                 PORTE|=RW;      //RW=1
  273.                 s_ms(100);
  274.                 PORTE|=EN;      //EN=1
  275.                 s_ms(1000);
  276.                 temp = PINB;    //读端口B
  277.                 s_ms(1000);
  278.                 DDRB=0xff;      //端口B改为
  279.                 s_ms(100);
  280.                 PORTE&=~EN;     //EN=0
  281.                 s_ms(100);
  282.                 if(temp>>7==0)
  283.                 flag = 0;
  284.                 return;
  285.         }
  286. }
  287. //LCM初始化
  288. void LCMInit(void)
  289. {
  290.         WriteCommandLCM(0x38);    //三次显示模式设置，不检测忙信号
  291.         s_ms(1000);
  292.         WriteCommandLCM(0x38);
  293.         s_ms(1000);
  294.         WriteCommandLCM(0x38);
  295.         s_ms(1000);
  296.         WriteCommandLCM(0x38);    //显示模式设置,开始要求每次检测忙信号
  297.         WriteCommandLCM(0x08);    //关闭显示
  298.         WriteCommandLCM(0x01);    //显示清屏
  299.         WriteCommandLCM(0x06);    //显示光标移动设置
  300.         WriteCommandLCM(0x0C);    //显示开及光标设置
  301. }

  303. //按指定位置显示一串字符
  304. //液晶显示：汉字为16*16，字母及数字为8*16，此次显示的文本
  305. //          从第一行第一列开始，依次向左，如果想在不同的
  306. //          位置显示，只需修改相应的行值即可。液晶显示
  307. //          完毕后，转入语音文本发送。
  308. //DisplsyList(X,DData)函数:X为0x80在第一行显示；X为0x90在
  309. //                        第二行显示；X为0x88在第三行显示；X为0x98在
  310. //                        第四行显示；DData为显示数组。
  311. void DisplayList(unsigned char X,char *DData)
  312. {
  313.         unsigned char length;
  314.         unsigned char i=0;
  315.         char *p;
  316.         p = DData;
  317.         length = strlen(p);
  318.         WriteCommandLCM(0x08);
  319.         WriteCommandLCM(X);
  320.         WriteCommandLCM(0x06);
  321.         WriteCommandLCM(0x0C);
  322.         WriteCommandLCM(X);
  323.         for(i=0;i<length;i++)
  324.         {
  325.                 WriteDataLCM(DData[i]);
  326.                 i++;
  327.                 WriteDataLCM(DData[i]);
  328.         }
  329. }
  330. void Init(){
  331.         DDRA|=~((1<<6)|(1<<7));
  332.         DDRC|=~((1<<6)|(1<<7));
  333.         PORTC|=(RED_1)|(RED_2);
  334.         PORTA|=(GREEN_1)|(GREEN_2);
  335.         //端口初始化
  336.         DDRB=0xff;
  337.         PORTB=0xff;
  338.         DDRG=(1<<3)|(1<<4);
  339.         PORTG=(1<<3)|(1<<4);
  340.         DDRE|=RW|RS|EN;
  341.         PORTE|=RW|RS|EN;
  342.         DDRD|=(0<<0)|(0<<1)|(0<<4)|(0<<5)|(0<<6)|(0<<7);
  343.         PORTD|=(1<<0)|(1<<1)|(1<<4)|(1<<5)|(1<<6)|(1<<7);
  344.         s_ms(200);
  345.         s_ms(200);
  346.         LCMInit(); //LCM初始化
  347. }
  348. int main(void)
  349. {
  350.         int a,b=0,c=0,time=10;
  351.         int im;
  352.         int chf=1;
  353.         Init();
  354.         ReadStatusLCM();
  355.         DisplayList(0x80,text_1);     //显示初始界面
  356.         s_ms(100);
  357.         im=EEPROM_read(0x10);
  358.         if (im)
  359.         {
  360.                 EEPROM_write(0x00,n);
  361.                 EEPROM_write(0x08,Yel_time);
  362.                 EEPROM_write(0x10,0);
  363.         }
  364.         n=EEPROM_read(0x00);
  365.         Yel_time=EEPROM_read(0x08);
  366.     while(1)
  367.     {
  368.                 while(chf==0)
  369.                 {
  370.                         for (a=0;a<n;a++)
  371.                         {
  372.                                 if (b==0)
  373.                                 {
  374.                                         PORTA=(GREEN_1)|(RED_2);
  375.                                         while(a>=n-5&&a<n){
  376.                                                 for (;a<n;a++)
  377.                                                 {
  378.                                                         get_key();
  379.                                                         PORTA^=(RED_2);
  380.                                                         delay_ms(200);
  381.                                                 }
  382.                                                 PORTA=(YEL_2)|(GREEN_1);
  383.                                                 for(c=0;c<Yel_time;c++)
  384.                                                 {
  385.                                                         get_key();
  386.                                                         delay_ms(100);
  387.                                                         }
  388.                                         }
  389.                                 }
  390.                                 else if (b==1)
  391.                                 {
  392.                                         PORTA=(RED_1)|(GREEN_2);
  393.                                         while(a>=n-5&&a<n){
  394.                                                 for (;a<n;a++)
  395.                                                 {
  396.                                                         get_key();
  397.                                                         PORTA^=(RED_1);
  398.                                                         delay_ms(200);
  399.                                                 }
  400.                                                 PORTA=(YEL_1)|(GREEN_2);
  401.                                                 for(c=0;c<Yel_time;c++)
  402.                                                 {
  403.                                                         get_key();
  404.                                                         delay_ms(100);
  405.                                                         }
  406.                                                 PORTA=(GREEN_1)|(GREEN_2);
  407.                                                 chf=1;
  408.                                                 PORTC=(GREEN_1)|(RED_2);
  409.                                         }
  410.                                 }
  411.                                 for(c=0;c<time;c++)
  412.                                 {
  413.                                         get_key();
  414.                                         delay_ms(100);
  415.                                         }
  416.                         }
  417.                         b=(++b)%2;
  418.                 }
  419.                 while(chf==1)
  420.                 {
  421.                         for (a=0;a<n;a++)
  422.                         {
  423.                                 if (b==0)
  424.                                 {
  425.                                         PORTC=(GREEN_1)|(RED_2);
  426.                                         while(a>=n-5&&a<n){
  427.                                                 for (;a<n;a++)
  428.                                                 {
  429.                                                         get_key();
  430.                                                         PORTC^=(GREEN_1);
  431.                                                         delay_ms(200);
  432.                                                 }
  433.                                                 PORTC=(YEL_1)|(RED_2);
  434.                                                 for(c=0;c<Yel_time;c++)
  435.                                                 {
  436.                                                         get_key();
  437.                                                         delay_ms(100);
  438.                                                         }
  439.                                         }
  440.                                 }
  441.                                 else if (b==1)
  442.                                 {
  443.                                         PORTC=(RED_1)|(GREEN_2);
  444.                                         while(a>=n-5&&a<n){
  445.                                                 for (;a<n;a++)
  446.                                                 {
  447.                                                         get_key();
  448.                                                         PORTC^=(GREEN_2);
  449.                                                         delay_ms(200);
  450.                                                 }
  451.                                                 PORTC=(YEL_2)|(RED_1);
  452.                                                 for(c=0;c<Yel_time;c++)
  453.                                                 {
  454.                                                         get_key();
  455.                                                         delay_ms(100);
  456.                                                         }
  457.                                                 PORTC=(RED_1)|(RED_2);
  458.                                                 chf=0;
  459.                                                 PORTA=(GREEN_1)|(RED_2);
  460.                                         }
  461.                                 }
  462.                                 for(c=0;c<time;c++)
  463.                                 {
  464.                                         get_key();
  465.                                         delay_ms(100);
  466.                                         }
  467.                         }
  468.                         b=(++b)%2;
  469.                 }
  470.         }
  471. }
复制代码

01.7z

22.3 KB, 下载次数: 6

程序及电路图
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏1 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:584814 发表于 2022-3-27 11:57 | 只看该作者
你买的硬件与仿真中的规格不符（包括偏差较大），或硬件连接错。
回复

使用道具 举报

板凳
ID:230742 发表于 2022-3-27 17:31 | 只看该作者
先检查12864是不是ST7920芯片驱动的，带中文字库的（看图好像是，如果不是会有CS1和CS2）,
找一个别的和你的单片机差不多的例程看看12864的时序，对比一下。
或者直接烧进去看看显示的汉字是否正确。
以前用STC89C52用P0接12864要接上拉电阻。虽然仿真不用，但实物要用。
线路要仔细检查好，我就把上拉电阻排焊反过。检查2两天才发现。
再检查一下是不是用的STC的单片机仿真的，实物用的AVR?
回复

使用道具 举报

地板
ID:1013350 发表于 2022-3-28 15:57 | 只看该作者
man1234567 发表于 2022-3-27 11:57
你买的硬件与仿真中的规格不符（包括偏差较大），或硬件连接错。

感谢你的回答，经检测后发现是代码的读状态函数出了问题，把读状态函数注释掉，然后加足够的延时实物正常运行
回复

使用道具 举报

5#
ID:1013350 发表于 2022-3-28 15:57 | 只看该作者
啤酒瓶子老大 发表于 2022-3-27 17:31
先检查12864是不是ST7920芯片驱动的，带中文字库的（看图好像是，如果不是会有CS1和CS2）,
找一个别的和你 ...

感谢你的回答，经检测后发现是代码的读状态函数出了问题，把读状态函数注释掉，然后加足够的延时实物正常运行
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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