21ic电子技术开发论坛 › 单片机与嵌入式系统 › 侃单片机论坛 › 同一个程序在atmega16和atmega16L下面跑出来的结果怎么 ...
返回列表 发新帖我要提问

[AVR单片机] 同一个程序在atmega16和atmega16L下面跑出来的结果怎么不一样啊？？？

[复制链接]
3335|5
 楼主| machiel 发表于 2013-3-13 19:30 | 显示全部楼层 |阅读模式
atmega16l, 烧写, 电压, 供电电压, 供电
看书册说这两者的区别只是供电电压不一啊？怎么我同一个程序烧写进去，结果却是完全不一样呢？？？
是不是哪里需要设置或者什么的呀？求解答！很迷惑~自己找不到原因了。我的程序在atmega16-8pu上是可以的但是今天换了一个atmega16l-8pu下载相同的程序，板子就工作不正常了，哪位可以告诉一下这是什么情况，或者遇到过这样的情况，怎么解决的？？？谢谢！！！
回复

收藏 举报

相关帖子
qin552011373 发表于 2013-3-13 21:14 | 显示全部楼层
你的什么样的程序？贴出来看看
回复

收藏 举报

 楼主| machiel 发表于 2013-3-14 10:25 | 显示全部楼层
qin552011373 发表于 2013-3-13 21:14
你的什么样的程序？贴出来看看
复制
  1. #include <avr/io.h>
    

  2. #define F_CPU        7372800UL
    

  3. #include <util/delay.h>
    

  4. #include <avr/interrupt.h>
    

  5. #include <string.h>
    

  6. #include <util/crc16.h>
    

  7. #include <avr/pgmspace.h>
    

  8. #include <avr/wdt.h>
    

  9. typedef unsigned char u8;
    

  10. typedef unsigned int u32;
    

  11. #define BAUDRATE            9600UL
    

  12. #define POLY                0X1021
    

  13. /*****************************************/
    

  14. #define RX_BUF_SIZE            6                // receive data size 
    

  15. #define TX_BUF_SIZE                5                // send buf
    

  16. #define START       0X83   //"S"
    

  17. #define END                    0X69 //"E"
    

  18. #define W_IO            0X87  //"W"
    

  19. #define R_IO            0X82  //"R"
    

  20. #define RESET                0X00        //"reset"
    

  21. #define FAIL            0X70  //"F"
    

  22. #define E_CMD                0X67   //"C"
    


  23. 

  24. #define PA                        0X41 //A
    

  25. #define PB                        0X42 //B
    

  26. #define PC                        0X43 //C
    

  27. #define PD                        0x44 //D
    


  28. 

  29. /**********************************************/
    

  30. #define SET(X,Y)        (X)|=(1<<(Y))
    

  31. #define CLI(X,Y)        (X)&=~(1<<(Y))
    

  32. #define enable_interrupt()        sei()
    

  33. #define disable_interrupt()        cli()
    


  34. 

  35. #define delay_us(US)        _delay_us(US)//delay time can't exceed 768us
    

  36. #define delay_ms(MS)    _delay_ms(MS)//max delay time 262ms
    

  37. #define delay_cycle()        asm("nop")
    


  38. 


  39. 


  40. 

  41. static void sendbyte( u8 dat);
    

  42. static void send( u8 *ptr,u8 len);
    

  43. static void reset_mcu(void);
    

  44. static void set_port(u8 port,u8 bit,u8 value);
    

  45. static void read_port(u8 port,u8 bit);
    


  46. 

  47. /*mcu receive data from PC buffer*/
    


  48. 

  49. static volatile u8 rx_buf[RX_BUF_SIZE]; 
    

  50. static volatile u8 rx_flag=0;
    

  51. static volatile u8 rx_num=0;
    


  52. 

  53. /*mcu transmit data to PC buffer*/
    


  54. 

  55. static volatile u8 tx_buf[TX_BUF_SIZE];
    

  56. static volatile u8 tx_w_index=0;
    

  57. static volatile u8 tx_r_index=0;
    

  58. static volatile u8 tx_num=0;
    


  59. 

  60. static volatile u8 dir_value=0xff;
    

  61. static volatile u8 port_value=0x00;
    

  62. const static volatile u8 error_p[]={FAIL,FAIL,FAIL};
    

  63. const static volatile u8 error_c[]={E_CMD,E_CMD,E_CMD};
    

  64. const static volatile u8 reset[]={RESET,RESET,RESET};
    


  65. 


  66. 

  67. void usart_init(void)
    

  68. {
    

  69.         UCSRB=0X00;
    

  70.         UCSRA&=~(1<<U2X);// no double baud rate
    

  71.     
    

  72.     UCSRB&=~(1<<UCSZ2);// 0 1 1 8 bit data
    

  73.     UCSRC|=(1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);
    

  74.     UCSRC&=~(1<<UMSEL);// asynchronous mode
    

  75.     UCSRC&=~(1<<USBS);// 1 stop bit
    

  76.     UCSRC&=~(1<<UPM1);//no parity check
    

  77.         UCSRC&=~(1<<UPM0);
    

  78.     UCSRC&=~(1<<UCPOL);//no clock polarity
    


  79. 

  80.         UBRRL=(u8)((F_CPU/16/BAUDRATE)-1);
    

  81.     UBRRH=(u8)(((F_CPU/16/BAUDRATE)-1)>>8); //set baud rate
    


  82. 

  83.           UCSRB|=(1<<TXCIE)|(1<<RXCIE)|(1<<TXEN)|(1<<RXEN);
    

  84.         DDRD|=(1<<DDD1);//TXD
    

  85.         DDRD&=~(1<<DDD0);//RXD
    


  86. 

  87. }
    


  88. 

  89. static void reset_mcu(void)
    

  90. {
    

  91.         WDTCR|=1<<WDTOE|1<<WDE;// disable watchdog;
    

  92.         WDTCR&=~(1<<WDE);
    


  93. 

  94.         WDTCR=0X40;//17.1ms RESET
    

  95. }
    


  96. 

  97. SIGNAL(USART_TXC_vect)
    

  98. {
    

  99. //        disable_interrupt();
    

  100.         if(tx_num>0)
    

  101.         {
    

  102.                 --tx_num;
    

  103.                 UDR=tx_buf[tx_r_index];
    

  104.                 ++tx_r_index;
    

  105.                 if(tx_r_index==TX_BUF_SIZE)
    

  106.                         tx_r_index=0;
    

  107.         }
    

  108. //        enable_interrupt();
    

  109. }
    


  110. 

  111. static void sendbyte( u8 dat)
    

  112. {
    

  113.         while(tx_num==TX_BUF_SIZE);//
    

  114.         disable_interrupt();
    

  115.         if(tx_num!=0||!(UCSRA&(1<<UDRE)))//buffer is not empty!
    

  116.         {
    

  117.                 tx_buf[tx_w_index]=dat;
    

  118.                 ++tx_w_index;
    

  119.                 if(tx_w_index==TX_BUF_SIZE)
    

  120.                         tx_w_index=0;
    

  121.                 ++tx_num;
    

  122.         }
    

  123.         else
    

  124.         {
    

  125.                 UDR=dat;
    

  126.         //        while(!(UCSRA&(1<<TXC)));//
    

  127.         //        UCSRA|=(1<<TXC);
    

  128.         }
    

  129.         enable_interrupt();
    

  130. }
    


  131. 

  132. static void send( u8 *ptr,u8 len)
    

  133. {        
    

  134.         u8 i=0;
    

  135.         for(i=0;i<len;i++)
    

  136.         {
    

  137.                 sendbyte(*(ptr+i));
    

  138.         }
    

  139. }
    


  140. 

  141. SIGNAL(USART_RXC_vect)
    

  142. {
    


  143. 

  144.         u8 dat=0,status=0;
    

  145. //        disable_interrupt();//////
    

  146.         status=UCSRA;
    

  147.         dat=UDR;
    

  148.         if(!rx_flag)
    

  149.         {
    

  150.                 if(!(status&(1<<FE|1<<DOR|1<<PE)))
    

  151.                 {
    

  152.                         rx_buf[rx_num]=dat;
    

  153.                         ++rx_num;
    

  154.                         if(rx_num==RX_BUF_SIZE)
    

  155.                         {
    

  156.                                 rx_num=0;
    

  157.                                 rx_flag=1;
    

  158.                         }
    

  159.                 }
    

  160.         }
    

  161. //        enable_interrupt();////
    

  162. }
    


  163. 

  164. void set_port(u8 port,u8 bit,u8 value)
    

  165. {
    

  166.         switch(port)
    

  167.         {
    

  168.                 case PA:
    

  169.                         if(bit<8)
    

  170.                         {
    

  171.                                 DDRA|=(1<<bit);
    

  172.                                 if(value==0x01)
    

  173.                                         PORTA|=(1<<bit);
    

  174.                                 else if(value==0x00)
    

  175.                                         PORTA&=~(1<<bit);
    

  176.                                 delay_ms(1);
    

  177.                                 dir_value=DDRA;
    

  178.                                 port_value=PORTA;
    

  179.                         }
    

  180.                         break;
    

  181.                 case PB:
    

  182.                         if(bit<8)
    

  183.                         {
    

  184.                                 DDRB|=(1<<bit);
    

  185.                                 if(value==0x01)
    

  186.                                         PORTB|=(1<<bit);
    

  187.                                 else if(value==0x00)
    

  188.                                         PORTB&=~(1<<bit);
    

  189.                                 delay_ms(1);
    

  190.                                 dir_value=DDRB;
    

  191.                                 port_value=PORTB;
    

  192.                         }
    

  193.                         break;
    

  194.                    case PC:
    

  195.                         if(bit<8)
    

  196.                         {
    

  197.                                 DDRC|=(1<<bit);
    

  198.                                 if(value==0x01)
    

  199.                                         PORTC|=(1<<bit);
    

  200.                                 else if(value==0x00)
    

  201.                                         PORTC&=~(1<<bit);
    

  202.                                 delay_ms(1);
    

  203.                                 dir_value=DDRC;
    

  204.                                 port_value=PORTC;
    

  205.                         }
    

  206.                         break;
    

  207.                 case PD:
    

  208.                         if(bit>1&&bit<8)
    

  209.                         {
    

  210.                                 DDRD|=(1<<bit);
    

  211.                                 if(value==0x01)
    

  212.                                         PORTD|=(1<<bit);
    

  213.                                 else if(value==0x00)
    

  214.                                         PORTD&=~(1<<bit);
    

  215.                                 delay_ms(1);
    

  216.                                 dir_value=DDRD;
    

  217.                                 port_value=PORTD;
    

  218.                         }
    

  219.                         break;
    

  220.         default:
    

  221.                         break;
    

  222.         }
    

  223. }
    


  224. 

  225. void read_port(u8 port,u8 bit)
    

  226. {
    

  227.         switch(port)
    

  228.         {
    

  229.                 case PA:
    

  230.                         if(bit<8)
    

  231.                         {
    

  232.                                 DDRA&=~(1<<bit);
    

  233.                                 PORTA|=(1<<bit);
    

  234.                                 delay_ms(1);//output change into input delay
    

  235.                                 dir_value=DDRA;
    

  236.                                 port_value=PINA;
    

  237.                         }
    

  238.                         break;
    

  239.                 case PB:
    

  240.                         if(bit<8)
    

  241.                         {
    

  242.                                 DDRB&=~(1<<bit);
    

  243.                                 PORTB|=(1<<bit);
    

  244.                                 delay_ms(1);//output change into input delay
    

  245.                                 dir_value=DDRB;
    

  246.                                 port_value=PINB;
    

  247.                         }
    

  248.                         break;
    

  249.                    case PC:
    

  250.                         if(bit<8)
    

  251.                         {
    

  252.                                 DDRC&=~(1<<bit);
    

  253.                                 PORTC|=(1<<bit);
    

  254.                                 delay_ms(1);//output change into input delay
    

  255.                                 dir_value=DDRC;
    

  256.                                 port_value=PINC;
    

  257.                         }
    

  258.                         break;
    

  259.                 case PD:
    

  260.                         if(bit>1&&bit<8)
    

  261.                         {
    

  262.                                 DDRD&=~(1<<bit);
    

  263.                                 PORTD|=(1<<bit);
    

  264.                                 delay_ms(1);//output change into input delay
    

  265.                                 dir_value=DDRD;
    

  266.                                 port_value=PIND;
    

  267.                         }
    

  268.                         break;
    

  269.         default:
    

  270.                         break;
    

  271.         }
    

  272. }
    


  273. 

  274. void handle_cmd()
    

  275. {
    


  276. 

  277.         if(rx_flag)
    

  278.         {
    

  279.                 if((rx_buf[0]==START)&&(rx_buf[RX_BUF_SIZE-1]==END))
    

  280.                 {
    

  281.                         switch(rx_buf[1])
    

  282.                         {        
    

  283.                                 case R_IO:
    

  284.                                         read_port(rx_buf[2],rx_buf[3]);
    

  285.                                         if((rx_buf[2]==PA||rx_buf[2]==PB||
    

  286.                                         rx_buf[2]==PC||rx_buf[2]==PD)&&rx_buf[3]<8)
    

  287.                                         {
    

  288.                                                 sendbyte(START);
    

  289.                                                 sendbyte(R_IO);
    

  290.                                                 sendbyte(dir_value);
    

  291.                                                 sendbyte(port_value);
    

  292.                                                 sendbyte(END);
    

  293.                                         }
    

  294.                                         break;
    

  295.                                 case W_IO:
    

  296.                                         set_port(rx_buf[2],rx_buf[3],rx_buf[4]);
    

  297.                                         if((rx_buf[2]==PA||rx_buf[2]==PB||
    

  298.                                         rx_buf[2]==PC||rx_buf[2]==PD)&&rx_buf[3]<8)
    

  299.                                         {
    

  300.                                                 sendbyte(START);
    

  301.                                                 sendbyte(W_IO);
    

  302.                                                 sendbyte(dir_value);
    

  303.                                                 sendbyte(port_value);
    

  304.                                                 sendbyte(END);
    

  305.                                         }
    

  306.                                         break;
    

  307.                                  case RESET:
    

  308.                                         sendbyte(START);
    

  309.                                         send((u8*)reset,3);
    

  310.                                         sendbyte(END);
    

  311.                                         reset_mcu();
    

  312.                                         delay_ms(50);
    

  313.                                         break;
    

  314.                                 default:
    

  315.                                         sendbyte(START);
    

  316.                                         send((u8 *)error_c,3);
    

  317.                                         sendbyte(END);
    

  318.                                         break;                                        
    

  319.                         }
    

  320.                 }
    

  321.                 else
    

  322.                 {
    

  323.                         sendbyte(START);
    

  324.                         send((u8 *)error_p,3);
    

  325.                         sendbyte(END);
    

  326.                 }
    

  327.         rx_flag=0;
    

  328.         }        
    

  329. }
    


  330. 

  331. void disable_jtag(void)
    

  332. {
    

  333.         MCUCSR|=(1<<JTD);
    

  334.         MCUCSR|=(1<<JTD);
    

  335. }
    


  336. 

  337. void init_wdt(void)
    

  338. {
    

  339.         WDTCR|=1<<WDTOE|1<<WDE;// disable watchdog;
    

  340.         WDTCR&=~(1<<WDE);
    

  341.         
    

  342.         WDTCR|=1<<WDE|1<<WDP2|1<<WDP1|1<<WDP0;//enable watchdog;2.1S        
    

  343. }
    


  344. 

  345. void init_io(void)
    

  346. {
    

  347.         
    

  348.         DDRA=0XFF;
    

  349.         DDRB=0XFF;
    

  350.         DDRC=0XFF;
    

  351.         DDRD=0XFF;
    

  352.         DDRD|=(1<<DDD1);//TXD
    

  353.         DDRD&=~(1<<DDD0);//RXD
    

  354.         PORTA=0X00;
    

  355.         PORTB=0X00;
    

  356.         PORTC=0X00;
    

  357.         PORTD=0X03;
    

  358. }
    

  359. int main(void)
    

  360. {
    

  361.         disable_interrupt();
    

  362.         disable_jtag();
    

  363.         init_io();
    

  364.         usart_init();
    

  365.         init_wdt();
    

  366.         enable_interrupt();
    

  367.         while(1)
    

  368.         {
    

  369.                 wdt_reset();
    

  370.                 handle_cmd();        
    

  371.         }
    

  372.         return 0;
    

  373. }
    


  374.


这个是代码，设置的时候选的是不优化！
回复

收藏 举报

airwill 发表于 2013-3-14 19:53 | 显示全部楼层
一行注释都没有, 牛人的作品啊.
建议楼主, 掌握一些调试技巧, 自己搞定吧.
回复

收藏 举报

评分

参与人数 1威望 +6 收起 理由
qin552011373 + 6 确实如此

查看全部评分

qin552011373 发表于 2013-3-14 23:44 | 显示全部楼层
看不出来哪里的问题
回复

收藏 举报

 楼主| machiel 发表于 2013-3-15 08:27 | 显示全部楼层
airwill 发表于 2013-3-14 19:53
一行注释都没有, 牛人的作品啊.
建议楼主, 掌握一些调试技巧, 自己搞定吧.

额，注释全部被我删了，呵呵，我还是在线仿真一下看看
回复

收藏 举报

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

本版积分规则

machiel
个人签名：正在努力进化的小菜....

14

主题

251

帖子

1

粉丝
快速回复 在线客服 返回列表 返回顶部