搜索
bottom↓
楼主: JAMESKING

关于开发产品的一些个人看法,我现在使用51和AVR单片机

[复制链接]

出0入0汤圆

发表于 2007-4-1 02:00:47 | 显示全部楼层
热烈祝贺JAMESKING兄的贴子盖到100楼!



占位学习。

出0入0汤圆

发表于 2007-4-1 11:46:36 | 显示全部楼层
晕…被楼上的抢了100…



我也来说说我的认识吧:

1. 51, 以前在大学时主要用的就是Atmel的,也玩过高档的51(电子设计大赛上用的就是uPSD32xx的一款,反正功能是很强,flash 256K,云云…不过就是下载程序超级麻烦,而且价格暴贵,所以只在大赛上用过, 毕竟不是自己掏钱买的,呵呵…因为当初本来用AT89S52的,结果程序编译下来12K,空间不够,才改用这款的…结果嘛,呵呵,还行,全国二等,本来可以拿一等的,只是由于某些因素…)

2. ARM,我的毕业设计就是用的这个东东,自己买的开发板,三星的S3C44B0,买了以后自己再在上面扩充(自己买的万用板焊接扩充的),花了1个半月,最后用它做了一个智能温度监视系统,3个CPU协同工作(ARM, 51, AVR), 用串口通讯,通讯协议是自己写的…就是这个东东,让我找到了现在的工作…

3. AVR,自从那个ARM开发板坏了以后,就没啥玩的了(最近正在用skyeye模拟ARM),加上上班了,也没那么多的时间搞自己的东西了,所以AVR只是业余玩玩了,当成第二选项了…用的GCC编译器…



总结:

    个人感觉, 对单片机而言, 如果不会汇编,那跟瞎子摸象没啥区别…但是C语言也是必需要掌握的,因为也要考虑到开发效率的问题…所以个人感觉,作为业余玩时,可以用汇编;但是一旦上班以后,最好还是用C语言…关键的是后期维护和移植性,不是像楼上有些人(没有针对的意思哈)所说的51移植到AVR之类的问题…因为公司的东西不是换一个新的单片机就从头重新写新的代码(公司肯定希望能用以前的代码经过简单修改就能使用),而且如果全部都是用汇编写的话, 那一旦当初写这个代码的人一走, 那这个代码岂不是基本没人维护了?加上是汇编的, 可阅读性差,相信没几个人认为看汇编比看C语言好理解吧? 加上现在的C编译器编译出来的汇编已经跟自己写的汇编没多大差距了,所以我建议,能不用汇编的地方就不用汇编,但是需要用到汇编的地方就一定要用汇编,而且你一定要知道某段C代码编译成汇编的大概样子,这样才是达到高效率,高移植性,高维护性的作用…对单片机用不用OS也要看情况,如果功能很简单完全没必要用OS,否则就最好用OS,当然OS也要有所选择(具体选择我就不说了哈)…

    对32位CPU而言,如ARM, MIPS, PowerPC等,这种情况下,不用C语言开发的肯定是脑子有问题…当然初始化代码用汇编是少不了的…而且这种情况下,不用OS也是几乎不可能的…

    对于楼主所说的软件抗干扰问题,其实有一本书写的非常好(<<单片机系统实用抗干扰技术>>,强烈推荐给各位),不过这方面我也说两点, 对于像51这样的CISC CPU,最好能加软件抗干扰的地方就加软件抗干扰,对于C语言软件抗干扰,周立功写了一本相关的书(书名忘了);对于RISC CPU, 像AVR, 其实除了开启看门狗外,大多数情况下完全没必要软件抗干扰(除非用于环境极其恶劣的情况下),因为都是精简指令集了,基本上不会出现PC乱跳的问题(这点就是RISC出现的最主要的原因之一),即使有乱跳的情况出现(假设哈),看门狗也会捕捉到并重启系统的…



    所以综上,可以得出以下几个结论(仅个人观点):

    a. 对单片机(指16位以下),汇编是必须要掌握的…

    b. C语言也是必须要掌握的,除非你不想到或不会到正规的公司工作…

    c. 能用C语言的地方就用C语言,但是要用汇编的地方就一定要用汇编…

    d. 对于CISC CPU,最好加上所有的抗干扰方法;对于RISC CPU,多数情况下,只需要开启看门狗就可以了…

出0入0汤圆

发表于 2007-4-18 11:58:52 | 显示全部楼层
我也湘潭的,湘滩大学,,,刚学avr

出0入0汤圆

发表于 2007-7-25 13:41:47 | 显示全部楼层
各位都是大师,学习了.

走出学校之后,才有机会学习AVR单片机,当然完全是业余的了,水平相当菜

出0入0汤圆

发表于 2007-7-25 15:38:23 | 显示全部楼层
仁者见仁,智者见智

出0入0汤圆

发表于 2007-11-23 13:26:33 | 显示全部楼层
老师们好,我的水平相当菜.

出0入0汤圆

发表于 2007-11-23 21:00:25 | 显示全部楼层
学海无涯,回头是崖
开个玩笑,向前辈们学习

出0入0汤圆

发表于 2007-11-24 11:51:05 | 显示全部楼层
我现在感觉到,一个好的C语言程序架构,不管什么环境都可以移植得上去。

如果把软件驱动层,软件层严格分开。软件层是很容易移植的

出0入0汤圆

发表于 2007-11-28 12:03:54 | 显示全部楼层
“定时炸_弹”!!! 想学习!!!

出0入0汤圆

发表于 2008-1-4 09:49:23 | 显示全部楼层
没时间看了,收藏起来

现在小弟在搞对FLASH读写,头都大了........

把DATASHEET都翻懒了,还没弄好

高手能不能指点一下?http://www.ouravr.com/bbs/bbs_content.jsp?bbs_sn=880428&bbs_page_no=1&search_mode=3&search_text=feitian215&bbs_id=9999

出0入0汤圆

发表于 2008-1-4 13:26:55 | 显示全部楼层
ding
再盖一楼

出0入0汤圆

发表于 2008-2-19 15:05:23 | 显示全部楼层
希望高手继续 抗干扰+版权保护的讨论。

出0入0汤圆

发表于 2008-2-19 22:33:53 | 显示全部楼层
尺有所长,寸有所短。

出0入0汤圆

发表于 2008-2-21 01:48:55 | 显示全部楼层
我觉得工程师不要搞什么花样比较好,工程师都是玩技术的,老板是玩人的,不老实玩死你

出0入0汤圆

发表于 2008-2-21 03:06:37 | 显示全部楼层
这个帖子盖得很高啊!从05年盖到现在。楼主主的心得我先记下了!

出0入0汤圆

发表于 2008-2-21 15:35:13 | 显示全部楼层
如果什么都做,那肯定什么都不能做到最好

出0入0汤圆

发表于 2008-5-16 22:35:57 | 显示全部楼层
软件抗干扰,推荐周航慈先生的四本51-asm语言大作:
1。《单片机程序设计基础(修订版)》
2。《单片机引用程序设计技术(修订版)》
3。《单片机程序应用设计技术》第一版,7.25元
4。《PHILIPS51LPC系列单片机原理及应用设计》
(<<单片机系统实用抗干扰技术>>


留个记号,这几本书我只看过第一本,就已经很受用了

出0入0汤圆

发表于 2008-5-16 22:56:45 | 显示全部楼层
这个帖还真能盖,几年了

出0入0汤圆

发表于 2008-5-17 01:00:15 | 显示全部楼层
好贴

出0入0汤圆

发表于 2008-5-27 13:34:37 | 显示全部楼层
好贴,我再盖一楼

出0入46汤圆

发表于 2008-5-27 20:18:36 | 显示全部楼层
加多一层!

出0入0汤圆

发表于 2008-5-28 00:09:18 | 显示全部楼层
这贴子去年就看过了,今年又复习一次,呵呵。
祝楼越盖越高!

出0入0汤圆

发表于 2008-6-1 15:19:00 | 显示全部楼层
越盖越高!哈哈!我也帮一下忙。

出0入0汤圆

发表于 2008-6-1 17:27:57 | 显示全部楼层
个人鄙视"炸_弹"做法,
人是讲感情的,做生意就要双方互利,
如果一个产品厂家获利20%,销售商获利80%,销售商会不玩命的推销这个产品么,
一个销售商赚了很多,厂家赚了更多的销售商.
多东西像做人,当以真诚相待,
如果遇到吝啬的老板和抠门的合作伙伴,
一笑了之,损失些钱财而已,
关键是可以通过一件事"认识"了一个人,
一个真诚的良心,真心的伙伴,用钱能买到么...

出0入0汤圆

发表于 2008-6-1 21:00:22 | 显示全部楼层
一个真诚的良心,真心的伙伴,用钱买不到,
但销售商获利80%的产品也未必会玩命的推销,还要看产品是不是符合市场需求

出0入0汤圆

发表于 2008-6-1 22:42:06 | 显示全部楼层
【123楼】 amsl
有人说得好:"人在社会上混,首先是要生存,然后才是感情"!
当你损失了,生存受到威胁时,还要感情吗?仓廪实面知礼节嘛,这话你不会不懂吧.另外,如果老板舍不得把那点项目费给你,这样的老板值得为他付出吗?所以该放炸_弹就放炸_弹.

出0入0汤圆

发表于 2008-6-18 13:22:47 | 显示全部楼层
呵呵 继续盖

出0入0汤圆

发表于 2008-6-18 19:47:59 | 显示全部楼层
商场如战场,一条战壕里的是战友,对面的就是敌人.敌人可不和你讲什么良心,感情.除非他是在耍花招!

出0入0汤圆

发表于 2008-6-22 16:56:10 | 显示全部楼层
其实事总有解决办法的.有什么大不了呢?是吧

出0入0汤圆

发表于 2008-6-25 10:03:24 | 显示全部楼层
没感觉

出0入0汤圆

发表于 2008-7-3 09:52:51 | 显示全部楼层
是的,该放还是要放

出0入0汤圆

发表于 2008-7-3 10:37:46 | 显示全部楼层
gai

出0入0汤圆

发表于 2008-7-5 22:06:18 | 显示全部楼层
各取所长,按劳分配哦,呵呵

出0入0汤圆

发表于 2008-7-11 16:55:02 | 显示全部楼层
应该加入类似条款,特别是对于一些小项目。  拿不到钱,还有什么感情可讲。

出0入0汤圆

发表于 2008-7-12 18:34:08 | 显示全部楼层
PIC我实在看不惯它的分页,实在太讨厌了
楼主,同感!!支持

出0入0汤圆

发表于 2008-7-23 10:52:12 | 显示全部楼层
高手真多啊

出0入0汤圆

发表于 2008-7-23 17:18:04 | 显示全部楼层
你这个办法不错

出0入0汤圆

发表于 2008-7-29 19:48:16 | 显示全部楼层
是的,我也看不惯PIC的分页,才转到了AVR.  支持株洲的老乡。

出0入0汤圆

发表于 2008-8-16 20:32:58 | 显示全部楼层
商场如战场,一条战壕里的是战友,对面的就是敌人.敌人可不和你讲什么良心,感情.除非他是在耍花招

出130入129汤圆

发表于 2008-8-16 21:07:15 | 显示全部楼层
钱都不给你 ,你还讲敢情?在学校没出来吧,没钱可是饿死人的

出0入0汤圆

发表于 2008-8-21 16:36:43 | 显示全部楼层
看一种芯片是否有用,我认为主要看以下几点:  
1.能不能满足市场对你的产品的要求;  
2.成本比较低;  
3.开发费用低;包括硬件成本和软件成本;  
4.印刷板设计容易;  
5.加密性能优良;  
6.有一定的升级余地;  
7.可以放逻辑炸_弹(没办法,适合中国这种“欠钱的是老子,讨债的是孙子”国情);  
8.引脚驱动能力大,可以尽量少的外扩器件;  
9.开发语言可以很容易加入软件抗干扰,而且占用的代码资源少;  
10.工作温度范围宽,电源适应能力强。

出0入0汤圆

发表于 2008-8-21 16:36:43 | 显示全部楼层
看一种芯片是否有用,我认为主要看以下几点:  
1.能不能满足市场对你的产品的要求;  
2.成本比较低;  
3.开发费用低;包括硬件成本和软件成本;  
4.印刷板设计容易;  
5.加密性能优良;  
6.有一定的升级余地;  
7.可以放逻辑炸_弹(没办法,适合中国这种“欠钱的是老子,讨债的是孙子”国情);  
8.引脚驱动能力大,可以尽量少的外扩器件;  
9.开发语言可以很容易加入软件抗干扰,而且占用的代码资源少;  
10.工作温度范围宽,电源适应能力强。

出0入0汤圆

发表于 2008-8-25 18:56:57 | 显示全部楼层
c语言真的有那么差劲么,

出0入0汤圆

发表于 2009-6-9 10:14:32 | 显示全部楼层
mark

出0入0汤圆

发表于 2009-6-9 13:58:21 | 显示全部楼层
支持51,avr ,avr32,呵呵 看不惯pic ,因为我看不到pic优点,鄙视msp,有了avr32和arm  让msp去死吧

出0入0汤圆

发表于 2009-6-9 15:03:22 | 显示全部楼层
mark

出0入0汤圆

发表于 2009-6-10 16:50:40 | 显示全部楼层
顶你 兄弟!

出0入0汤圆

发表于 2009-6-10 19:07:57 | 显示全部楼层
这么早的帖子,现在看看,还是有收获!顶一下!

出0入0汤圆

发表于 2009-6-10 19:40:00 | 显示全部楼层
既然挖出来了。我也顶顶

出0入0汤圆

发表于 2009-6-10 22:54:53 | 显示全部楼层
哎,中国人是讲钱,什么时候才能把技术真正做到家啊

出0入0汤圆

发表于 2009-6-10 23:01:28 | 显示全部楼层
感觉PIC可以,低档系列是分页烦人,不过PIC产品线多,中高档和高档系列还是很有优势啊,要不然PIC系列怎么会出货量第一啊。
每种单片机都各有优缺点,AVR PIC MSP430 51 ARM 等这些芯片都是要掌握的啊

出0入0汤圆

发表于 2009-6-11 09:12:20 | 显示全部楼层
mark,真怪没早点看到这帖!

出0入0汤圆

发表于 2009-6-11 09:55:04 | 显示全部楼层
学习了

出0入0汤圆

发表于 2009-6-11 13:21:12 | 显示全部楼层
再盖一楼

出0入0汤圆

发表于 2009-6-11 13:30:59 | 显示全部楼层
针对你的特定行业是有用的。各有算长,各个mcu厂商也不是傻子,如果真的一无是处,他们花那么大力气搞了做啥?

出675入8汤圆

发表于 2009-6-11 16:47:03 | 显示全部楼层
学学怎么放炸_弹

出0入0汤圆

发表于 2009-6-11 17:37:31 | 显示全部楼层
我觉得汇编可以,但是C也不错啊。我在电子竞赛动员会上提了些关于汇编的问题,结果引来一大片笑声,甚至有人说 什么年代了还用汇编。我就郁闷了,汇编有什么不好……

出0入0汤圆

发表于 2009-6-11 20:29:51 | 显示全部楼层
之前看过,没有MARK,补上。

出0入0汤圆

发表于 2009-6-12 00:53:35 | 显示全部楼层
呵呵,学习了好多!

出0入0汤圆

发表于 2009-6-25 09:46:29 | 显示全部楼层
好好,顶!

出0入0汤圆

发表于 2009-6-27 16:32:15 | 显示全部楼层
老贴还能顶这么久,楼主说得有点误导人,现在全部用汇编开发程序的人很少,大部分都是C语言和汇编混合编程,C语言用的多,汇编语言只在一些特殊情况下用。

出0入0汤圆

发表于 2009-6-27 16:53:04 | 显示全部楼层
lz确实误导了  还在用汇编?  不上os?

出0入0汤圆

发表于 2009-6-28 18:39:01 | 显示全部楼层
如果是256K的代码,用汇编方便还是C呢?

出0入0汤圆

发表于 2009-6-29 04:07:02 | 显示全部楼层
虽然我不用PIC,但是PIC的优点还是有的,例如AVR的耗电与89C51差不多,而PIC则要小一个数量级,这在用电池供电的便携项目上还是有优势的。另外似乎PIC的抗干扰稳定性上也比AVR要强,这点对于工业环境的产品也很重要。

出0入0汤圆

发表于 2009-6-29 13:02:26 | 显示全部楼层
没有墨水可以泼.
继续盖楼......

出0入8汤圆

发表于 2009-6-29 13:51:58 | 显示全部楼层
mark!

出0入0汤圆

发表于 2009-6-29 14:11:27 | 显示全部楼层
添砖加瓦。

出0入0汤圆

发表于 2009-8-14 21:49:33 | 显示全部楼层
诸如STM32等,都有其自身唯一的ID,用于在加密防盗方面也是不错的。
正如楼上所说,私自使用逻辑炸_弹是违法的,要么在当初的双方合同里就以某种方式注明。
譬如测试周期、余款支付完毕开放完整功能等等。

出0入0汤圆

发表于 2009-8-14 22:01:43 | 显示全部楼层
楼主是不是肤浅了点,你不会的东西就说它不好吗,C语言不比汇编效率低,实时系统也不花里胡哨,都是很实用的工具,提高你的效率和软件设计的“美观”

出0入0汤圆

发表于 2009-8-14 22:51:58 | 显示全部楼层
mark

出0入0汤圆

发表于 2009-8-14 23:51:59 | 显示全部楼层
mark

出0入0汤圆

发表于 2009-8-15 00:36:56 | 显示全部楼层
足见LZ对C缺乏了解。

出0入0汤圆

发表于 2009-8-15 03:38:23 | 显示全部楼层
晕,居然说"C语言不比汇编效率低",不知道说什么好!
说C开发速度快我还是认同的,但实际上决定一个程序的效率的,还是程序员的思路,而C限制了不少提高效率的方法的使用,比如说avr中拿几个寄存器出来做全局变量,并且是做位变量使用......
还有,C为什么有时要镶嵌汇编?还不是要提高程序的效率?!

出0入0汤圆

发表于 2009-8-15 10:06:31 | 显示全部楼层
学到了不少。

出0入0汤圆

发表于 2009-8-15 17:38:58 | 显示全部楼层
添砖加瓦.

出0入0汤圆

发表于 2009-8-15 18:52:42 | 显示全部楼层
复杂度高的项目,无关效率的部分用C, 关键部分用汇编嵌入。我觉得汇编与c都没有完全的好与不好,优势互补比较合理。用得习惯其实不在乎哪种语言工具。语言是死的,人是活的。有时候我先写好伪代码,根据伪代码写类C的汇编。

出0入0汤圆

发表于 2009-8-18 01:03:24 | 显示全部楼层
【172楼】 qianhng

你用来做循环的变量,应用比较频繁的变量,C会自动用寄存器作为变量的,这个已经不用你来操心了,
还有,C语言对位变量的使用不是人可以比拟的,特别是PIC的编译器,因为低端pic只有两级堆栈,C用位变量代替了函数的返回
51有位运算,C也是完全支持的
这些,如果有心研究,可以仔细的看看C编译后的汇编语言列表,你就会佩服C编译的效率了

下面是一段简单的C语言和它编译出来的汇编,各位汇编高手看看,效率有多差?

这是C语言代码:

   1          # pragma CODE,SMALL,db,ot(9)
   2          # include <absacc.h>
   3          # include <reg52.h>
   4
   5          void delay5ms(void)
   6          {unsigned char cyc=255;
   7   1       while(--cyc);
   8   1      }
   9
  10          unsigned int total;
  11          void main(void)
  12          {unsigned char ch;
  13   1       while(1)
  14   1       {for(ch=100;ch!=0;ch--)
  15   2         delay5ms();
  16   2         total++;
  17   2       }
  18   1      }
  19

这是对应的汇编列表,对应到具体行号

             ; FUNCTION delay5ms (BEGIN)
                                           ; SOURCE LINE # 5
                                           ; SOURCE LINE # 6
;---- Variable 'cyc' assigned to Register 'R7' ----  cyc已经自动用寄存器做变量了,这段代码人写也不过如此!
0000 7FFF              MOV     R7,#0FFH
0002         ?C0001:
                                           ; SOURCE LINE # 7
0002 DFFE              DJNZ    R7,?C0001
                                           ; SOURCE LINE # 8
0004         ?C0003:
0004 22                RET
             ; FUNCTION delay5ms (END)

             ; FUNCTION main (BEGIN)
                                           ; SOURCE LINE # 11
                                           ; SOURCE LINE # 12
0000         ?C0004:
                                           ; SOURCE LINE # 13
                                           ; SOURCE LINE # 14
;---- Variable 'ch' assigned to Register 'R6' ---- ch 也被配给寄存器了
0000 7E64              MOV     R6,#064H
0002         ?C0006:
                                           ; SOURCE LINE # 15
0002 120000      R     LCALL   delay5ms
0005 DEFB              DJNZ    R6,?C0006
0007         ?C0007:
                                           ; SOURCE LINE # 16
0007 0500        R     INC     total+01H    这是全局变量
0009 E500        R     MOV     A,total+01H
000B 70F3              JNZ     ?C0004
000D 0500        R     INC     total
000F         ?C0010:
                                           ; SOURCE LINE # 17
000F 80EF              SJMP    ?C0004
             ; FUNCTION main (END)

这是占用的资源统计

MODULE INFORMATION:   STATIC OVERLAYABLE
   CODE SIZE        =     22    ----
   CONSTANT SIZE    =   ----    ----
   XDATA SIZE       =   ----    ----
   PDATA SIZE       =   ----    ----
   DATA SIZE        =      2    ----
   IDATA SIZE       =   ----    ----
   BIT SIZE         =   ----    ----
END OF MODULE INFORMATION.

一共用了22个字节的ROM空间 2个字节的RAM

说C语言效率低的,好好研究研究C再发表议论,不要误人子弟!

出0入0汤圆

发表于 2009-8-18 02:38:03 | 显示全部楼层
没有差劲的编程语言,只有差劲的编译器和差劲的程序员。

出0入0汤圆

发表于 2009-8-18 09:12:06 | 显示全部楼层
下面是一个在主循环扫描32个键的状态,并且在每一个键单独按下的状态下调用相应的子程序将其状态清零的汇编程序。

请【176楼】 zhxzhx 一丁 将这个程序用高效率的C写出来以证明C的效率不比汇编低。
.include "m48def.inc"
                .DEF        BUTTON_A = R20
                        .EQU        BUTTON_0_BIT = 0
                        .EQU        BUTTON_1_BIT = 1
                        .EQU        BUTTON_2_BIT = 2
                        .EQU        BUTTON_3_BIT = 3
                        .EQU        BUTTON_4_BIT = 4
                        .EQU        BUTTON_5_BIT = 5
                        .EQU        BUTTON_6_BIT = 6
                        .EQU        BUTTON_7_BIT = 7
                .DEF        BUTTON_B = R21
                        .EQU        BUTTON_8_BIT = 0
                        .EQU        BUTTON_9_BIT = 1
                        .EQU        BUTTON_10_BIT = 2
                        .EQU        BUTTON_11_BIT = 3
                        .EQU        BUTTON_12_BIT = 4
                        .EQU        BUTTON_13_BIT = 5
                        .EQU        BUTTON_14_BIT = 6
                        .EQU        BUTTON_15_BIT = 7
                .DEF        BUTTON_C = R22
                        .EQU        BUTTON_16_BIT = 0
                        .EQU        BUTTON_17_BIT = 1
                        .EQU        BUTTON_18_BIT = 2
                        .EQU        BUTTON_19_BIT = 3
                        .EQU        BUTTON_20_BIT = 4
                        .EQU        BUTTON_21_BIT = 5
                        .EQU        BUTTON_22_BIT = 6
                        .EQU        BUTTON_23_BIT = 7
                .DEF        BUTTON_D = R23
                        .EQU        BUTTON_24_BIT = 0
                        .EQU        BUTTON_25_BIT = 1
                        .EQU        BUTTON_26_BIT = 2
                        .EQU        BUTTON_27_BIT = 3
                        .EQU        BUTTON_28_BIT = 4
                        .EQU        BUTTON_29_BIT = 5
                        .EQU        BUTTON_30_BIT = 6
                        .EQU        BUTTON_31_BIT = 7
.CSEG
                LDI        R16,HIGH(RAMEND)               
                OUT        SPH,R16
                LDI        R16,LOW(RAMEND)
                OUT        SPL,R16
MAIN_LOOP:
                SBRC BUTTON_A,BUTTON_0_BIT
                        RCALL BUTTON_0_ON
                SBRC BUTTON_A,BUTTON_1_BIT
                        RCALL BUTTON_1_ON
                SBRC BUTTON_A,BUTTON_2_BIT
                        RCALL BUTTON_2_ON
                SBRC BUTTON_A,BUTTON_3_BIT
                        RCALL BUTTON_3_ON
                SBRC BUTTON_A,BUTTON_4_BIT
                        RCALL BUTTON_4_ON
                SBRC BUTTON_A,BUTTON_5_BIT
                        RCALL BUTTON_5_ON
                SBRC BUTTON_A,BUTTON_6_BIT
                        RCALL BUTTON_6_ON
                SBRC BUTTON_A,BUTTON_7_BIT
                        RCALL BUTTON_7_ON
                SBRC BUTTON_B,BUTTON_8_BIT
                        RCALL BUTTON_8_ON
                SBRC BUTTON_B,BUTTON_9_BIT
                        RCALL BUTTON_9_ON
                SBRC BUTTON_B,BUTTON_10_BIT
                        RCALL BUTTON_10_ON
                SBRC BUTTON_B,BUTTON_11_BIT
                        RCALL BUTTON_11_ON
                SBRC BUTTON_B,BUTTON_12_BIT
                        RCALL BUTTON_12_ON
                SBRC BUTTON_B,BUTTON_13_BIT
                        RCALL BUTTON_13_ON
                SBRC BUTTON_B,BUTTON_14_BIT
                        RCALL BUTTON_14_ON
                SBRC BUTTON_B,BUTTON_15_BIT
                        RCALL BUTTON_15_ON
                SBRC BUTTON_C,BUTTON_16_BIT
                        RCALL BUTTON_16_ON
                SBRC BUTTON_C,BUTTON_17_BIT
                        RCALL BUTTON_17_ON
                SBRC BUTTON_C,BUTTON_18_BIT
                        RCALL BUTTON_18_ON
                SBRC BUTTON_C,BUTTON_19_BIT
                        RCALL BUTTON_19_ON
                SBRC BUTTON_C,BUTTON_20_BIT
                        RCALL BUTTON_20_ON
                SBRC BUTTON_C,BUTTON_21_BIT
                        RCALL BUTTON_21_ON
                SBRC BUTTON_C,BUTTON_22_BIT
                        RCALL BUTTON_22_ON
                SBRC BUTTON_C,BUTTON_23_BIT
                        RCALL BUTTON_23_ON
                SBRC BUTTON_D,BUTTON_24_BIT
                        RCALL BUTTON_24_ON
                SBRC BUTTON_D,BUTTON_25_BIT
                        RCALL BUTTON_25_ON
                SBRC BUTTON_D,BUTTON_26_BIT
                        RCALL BUTTON_26_ON
                SBRC BUTTON_D,BUTTON_27_BIT
                        RCALL BUTTON_27_ON
                SBRC BUTTON_D,BUTTON_28_BIT
                        RCALL BUTTON_28_ON
                SBRC BUTTON_D,BUTTON_29_BIT
                        RCALL BUTTON_29_ON
                SBRC BUTTON_D,BUTTON_30_BIT
                        RCALL BUTTON_30_ON
                SBRC BUTTON_D,BUTTON_31_BIT
                        RCALL BUTTON_31_ON
                RJMP MAIN_LOOP

BUTTON_0_ON:
                CBR BUTTON_A,1<<BUTTON_0_BIT
                RET
BUTTON_1_ON:
                CBR BUTTON_A,1<<BUTTON_1_BIT
                RET
BUTTON_2_ON:
                CBR BUTTON_A,1<<BUTTON_2_BIT
                RET
BUTTON_3_ON:
                CBR BUTTON_A,1<<BUTTON_3_BIT
                RET
BUTTON_4_ON:
                CBR BUTTON_A,1<<BUTTON_4_BIT
                RET
BUTTON_5_ON:
                CBR BUTTON_A,1<<BUTTON_5_BIT
                RET
BUTTON_6_ON:
                CBR BUTTON_A,1<<BUTTON_6_BIT
                RET
BUTTON_7_ON:
                CBR BUTTON_A,1<<BUTTON_7_BIT
                RET
BUTTON_8_ON:
                CBR BUTTON_B,1<<BUTTON_8_BIT
                RET
BUTTON_9_ON:
                CBR BUTTON_B,1<<BUTTON_9_BIT
                RET
BUTTON_10_ON:
                CBR BUTTON_B,1<<BUTTON_10_BIT
                RET
BUTTON_11_ON:
                CBR BUTTON_B,1<<BUTTON_11_BIT
                RET
BUTTON_12_ON:
                CBR BUTTON_B,1<<BUTTON_12_BIT
                RET
BUTTON_13_ON:
                CBR BUTTON_B,1<<BUTTON_13_BIT
                RET
BUTTON_14_ON:
                CBR BUTTON_B,1<<BUTTON_14_BIT
                RET
BUTTON_15_ON:
                CBR BUTTON_B,1<<BUTTON_15_BIT
                RET
BUTTON_16_ON:
                CBR BUTTON_C,1<<BUTTON_16_BIT
                RET
BUTTON_17_ON:
                CBR BUTTON_C,1<<BUTTON_17_BIT
                RET
BUTTON_18_ON:
                CBR BUTTON_C,1<<BUTTON_18_BIT
                RET
BUTTON_19_ON:
                CBR BUTTON_C,1<<BUTTON_19_BIT
                RET
BUTTON_20_ON:
                CBR BUTTON_C,1<<BUTTON_20_BIT
                RET
BUTTON_21_ON:
                CBR BUTTON_C,1<<BUTTON_21_BIT
                RET
BUTTON_22_ON:
                CBR BUTTON_C,1<<BUTTON_22_BIT
                RET
BUTTON_23_ON:
                CBR BUTTON_C,1<<BUTTON_23_BIT
                RET
BUTTON_24_ON:
                CBR BUTTON_D,1<<BUTTON_24_BIT
                RET
BUTTON_25_ON:
                CBR BUTTON_D,1<<BUTTON_25_BIT
                RET
BUTTON_26_ON:
                CBR BUTTON_D,1<<BUTTON_26_BIT
                RET
BUTTON_27_ON:
                CBR BUTTON_D,1<<BUTTON_27_BIT
                RET
BUTTON_28_ON:
                CBR BUTTON_D,1<<BUTTON_28_BIT
                RET
BUTTON_29_ON:
                CBR BUTTON_D,1<<BUTTON_29_BIT
                RET
BUTTON_30_ON:
                CBR BUTTON_D,1<<BUTTON_30_BIT
                RET
BUTTON_31_ON:
                CBR BUTTON_D,1<<BUTTON_31_BIT
                RET
.EXIT       

编译结果:
ATmega48 memory use summary [bytes]:
Segment   Begin    End      Code   Data   Used    Size   Use%
---------------------------------------------------------------
[.cseg] 0x000000 0x00010a    266      0    266    4096   6.5%
[.dseg] 0x000100 0x000100      0      0      0     512   0.0%
[.eseg] 0x000000 0x000000      0      0      0     256   0.0%

Assembly complete, 0 errors. 0 warnings

出0入0汤圆

发表于 2009-8-18 09:37:39 | 显示全部楼层
【178楼】的汇编代码,我认为没有太大的价值,既不是以很高的效率实现一个复杂的算法,也不是以很简单的方法实现一个复杂的功能,反而让代码看上去很繁琐。

出0入0汤圆

发表于 2009-8-18 10:00:17 | 显示全部楼层
我不想试图证明汇编和C语言哪个效率更高,因为那是没有意义的。
效率的高低完全取决于你使用怎样的编程方法实现某个特定的功能,C语言也是被编译成汇编来执行程序的,当代码很复杂的时候一个优秀的C编译器编译出来的汇编代码不会比自己的写的汇编代码差到哪去,反而更有可能比自己的写的汇编代码效率更高,这个是有编写C编译器的人的水平决定的,能够编写出一个优秀的C编译器的人的汇编能力绝对是一流的,所以我并不认为一个普通的工程师写出的汇编代码的效率会高于一个一流的C编译器设计师设计的C编译器编译出来的汇编代码。

出0入0汤圆

发表于 2009-8-18 10:12:21 | 显示全部楼层
mark

出0入0汤圆

发表于 2009-8-18 10:12:40 | 显示全部楼层
【179楼】你就当178楼的是客户需求就可以了,客户可是不一定要复杂的算法和复杂的功能,只要达到他的要求就好了,他也不管代码是否很烦琐,他要的只是结果罢了.
效率是什么?
程序中时间的效率是在最短的时间内完成最多的任务,代码的效率是用最少的代码实现最多的功能(不管执行时间长短),其实有时候这两方面是冲突的,在强调时序的时候就未必能用最少的代码去实现它.
说到价值,能达到客户要求的程序就有价值,达不到客户要求的程序就没有价值.
说到最后,Alexkey,你认为我上面说的哪里有错吗,请不吝指点.
欢迎各位拍砖
很期待 zhxzhx 一丁 的高效率C程序,我也很希望我是错的,毕竟C容易上手许多!

出0入0汤圆

发表于 2009-8-18 10:44:18 | 显示全部楼层
【180楼】 Alexkey 提到"能够编写出一个优秀的C编译器的人的汇编能力绝对是一流的"这个我不否认,可是为什么世界上那么多的C语言程序员各自选用各自的AVR C语言环境并相信他的选择是最好的,有人说IAR最好,有人说ICCAVR最好......难道那些写C编译器的人都不优秀吗?不是的,只是他们在各方面的侧重点不一样罢了,有时侯一个人想要照顾到所有的方面是不可能的,因为他是人,不是神.
Alexkey提到“所以我并不认为一个普通的工程师写出的汇编代码的效率会高于一个一流的C编译器设计师设计的C编译器编译出来的汇编代码。”,我就是“一个普通的工程师”,我“写出的汇编代码”请看【178楼】,在你看来是不会高于“一个一流的C编译器设计师设计的C编译器编译出来的汇编代码”的!
那么也请 Alexkey 用C写一个实现【178楼】功能的程序,让大家看看“一个一流的C编译器设计师设计的C编译器编译出来的汇编代码”的效率有多高,在主循环里占用MCU的时间最少。

出0入0汤圆

发表于 2009-8-18 14:45:46 | 显示全部楼层
就这么一段短小的代码有什么可比性,再说C语言的效率也不仅仅是跟编译器有关系,不同的CPU执行相同的代码也有天壤之别,特别是当程序中有大量浮点运算,数据缓存,堆栈管理,一旦程序复杂度提高,我不认为一个人能面面俱到的把这些功能用汇编都实现的同时又保证代码的高效率。
理论上虽然汇编能实现你想要实现的任何功能,不过如果一个产品需要操作系统,内存管理,文件系统,以及各种通信接口,在我看来用汇编那是不可能完成的任务,即使使用C语言也要借助很多现成的代码,恐怕要找类似的汇编代码不太现实。
我所要表达的就是,汇编和C语言的效率谁高谁低不是绝对的,完全取决于使用的人和要实现的功能。
写程序心态很重要,实现同样功能的方法有很多种,一段有价值的代码应该是具有比较好的可读性,并且可以被不同的项目重复使用。还有很多时候程序的运行效率不是绝对的重点,开发效率也很重要,程序运行的稳定性更重要。
成本控制是一个比较大的概念,也并不是选择便宜的MCU就成本低了,毕竟在很多产品中MCU的成本只是比较小的一部分。
举个例子,比如你想用普通的51单片机来实现音视频的实时编解码,不管你用汇编还是C语言,编程水平再怎么高超,恐怕那也是不可能完成的任务,老板当然希望你能做到,因为成本低啊。

出0入0汤圆

发表于 2009-8-18 15:35:52 | 显示全部楼层
一开始,我不服【168楼】 Alexkey :“C语言不比汇编效率低”
因此在【172楼】提出反驳论据“说C开发速度快我还是认同的,但实际上决定一个程序的效率的,还是程序员的思路,而C限制了不少提高效率的方法的使用,比如说avr中拿几个寄存器出来做全局变量,并且是做位变量使用......”
【176楼】 zhxzhx 一丁:“【172楼】 qianhng  ......说C语言效率低的,好好研究研究C再发表议论,不要误人子弟!”
所以我在【178楼】 举出这个例子以对我说过的话负责,我不是忽悠大家,而是汇编确实能做到效率最高
既然【184楼】 Alexkey 说“我所要表达的就是,汇编和C语言的效率谁高谁低不是绝对的,完全取决于使用的人和要实现的功能。”那就是仍认为“C语言不比汇编效率低”那总得拿出事实根据给大家看看吧,别不是忽悠大家吧?!
话说回来,汇编又确实不容易掌握,用汇编开发系统的是高手的事,不是你我的事。
在低端芯片这块,汇编占据天然绝对的优势,在高端,由于汇编开发周期长,C占优势,并不是汇编效率不高。
在这里,再次请 zhxzhx 一丁看看【178楼】,请你对你自己的话负责。

出0入0汤圆

发表于 2009-8-18 16:10:18 | 显示全部楼层
想不到楼主这个帖子在最后竟然引发了对于C和汇编的争论。看到180楼到185楼的争论,很受益,大家争论的同时证明大家都做了很多思考。
本人一直在用C,主要是开发周期短,可移植性高,代码重复利用率比较大,只要将大部分的实现特定功能的代码都写出函数的形式,并把这些函数作为函数库存在,则以后开发相类似的程序时,就可能在很短的时间内完成程序开发。有时为了程序的可移植性,可重复利用性,甚至牺牲代码的长度,来使代码更通用。
所以同意182楼,“程序中时间的效率是在最短的时间内完成最多的任务,代码的效率是用最少的代码实现最多的功能(不管执行时间长短),其实有时候这两方面是冲突的,在强调时序的时候就未必能用最少的代码去实现它. 说到价值,能达到客户要求的程序就有价值,达不到客户要求的程序就没有价值. ”
同意184楼,“汇编和C语言的效率谁高谁低不是绝对的,完全取决于使用的人和要实现的功能。写程序心态很重要,实现同样功能的方法有很多种,一段有价值的代码应该是具有比较好的可读性,并且可以被不同的项目重复使用。还有很多时候程序的运行效率不是绝对的重点,开发效率也很重要,程序运行的稳定性更重要。”
学习汇编对提高C的效率是有用的,实现同一功能,C往往后很多方法,但最终要编译成汇编和机器代码,如果对汇编指令有很深了解,就可以在写C时,当实现同一功能时,采用汇编中有的指令的方式,这样可以提高程序效率。
例如实现从0--1000的重复:
方法1:if(++i>=1000)i=0;
方法2:if(--i==0)i=1000;
方法2的效率会比方法1的效率高,具体为什么请看汇编的跳转指令。

出0入0汤圆

发表于 2009-8-18 19:27:40 | 显示全部楼层
汇编你可以控制MCU的一切,但是汇编你需要操纵一切。寄存器分配,sram分配,堆栈,子程序参数、返回值,统统不能没有你。
而C编译器让你从各个指令,寄存器,地址中解放出来,从而你可以专注于需要专注的地方,从开发的角度讲,如果让我选择,我会优先选择c,在c不能满足苛刻的运行资源和效率要求下才会考虑混合进一些汇编。

int max(int *array)
{
char a;
int maximum=-32768;
for(a=0;a<16;a++)
if(array[a]>maximum)
   maximum=array[a];

return (maximum);
}

以上一个简单的c函数,GCC编译后54byte,如果改成汇编,如何呢?运行效率有多大的提高?
那如果是
long max(long *array)
{
char a;
long maximum=-2147483648;
for(a=0;a<16;a++)
if(array[a]>maximum)
   maximum=array[a];
return (maximum);
}
GCC编译后94byte,但是我需要的只是改了一下类型。如果改成汇编呢?
我保证汇编会让你头大,而且容易出错。

出0入0汤圆

发表于 2009-8-18 21:44:32 | 显示全部楼层
【187楼】说的有道理,在科学计算方面,汇编程序开发的速度拍马也比不上C;汇编强在对资源(内存、寄存器、mcu时间等)的利用、时序的控制及代码的灵活上,这也是C拍马也比不上的。
如果用大牛拉小车,C没问题,要用小牛拉大车则非汇编不可!
C“可移植性高,代码重复利用率比较大”确实不错,但汇编也不是不可重复利用。说起移植性来,不同的MCU连寄存器都不同(以M8和M88为例)和硬件相关的部分无论是C还是汇编一般都要手工改动,和硬件无关的部分C是占了优势的。
其实最提倡用C的是要经常换技术人员的老板、因为用C的风格都差不多,换起来方便,既可以用随时换人来压旧人也可以用我有可用的代码来压新人;而用汇编的差别就大了,换一个几乎前功尽弃。^_^宁要听使唤的,也不要太牛的嘛,反正在中国搞技术的价格低!

出0入0汤圆

发表于 2009-8-18 22:31:34 | 显示全部楼层
是的个人够用就好,不过楼主讲得还是有些片面,因为你接触的产品,都不是高档产品,用不了那么复杂而已,所以AVR就够了。

出0入0汤圆

发表于 2009-8-19 10:08:10 | 显示全部楼层
再盖一层

出0入0汤圆

发表于 2009-8-26 00:09:16 | 显示全部楼层
这是C代码

   1          # pragma CODE,SMALL,db,ot(9)
   2          # include <absacc.h>
   3          # include <reg52.h>
   4
   5          bdata unsigned char R_20;
   6          sbit BUTTON_0_BIT = R_20^0;
   7          sbit BUTTON_1_BIT = R_20^1;
   8          sbit BUTTON_2_BIT = R_20^2;
   9          sbit BUTTON_3_BIT = R_20^3;
  10          sbit BUTTON_4_BIT = R_20^4;
  11          sbit BUTTON_5_BIT = R_20^5;
  12          sbit BUTTON_6_BIT = R_20^6;
  13          sbit BUTTON_7_BIT = R_20^7;
  14
  15          bdata unsigned char R_21;
  16          sbit BUTTON_8_BIT  = R_21^0;
  17          sbit BUTTON_9_BIT  = R_21^1;
  18          sbit BUTTON_10_BIT = R_21^2;
  19          sbit BUTTON_11_BIT = R_21^3;
  20          sbit BUTTON_12_BIT = R_21^4;
  21          sbit BUTTON_13_BIT = R_21^5;
  22          sbit BUTTON_14_BIT = R_21^6;
  23          sbit BUTTON_15_BIT = R_21^7;
  24
  25          bdata unsigned char R_22;
  26          sbit BUTTON_16_BIT = R_22^0;
  27          sbit BUTTON_17_BIT = R_22^1;
  28          sbit BUTTON_18_BIT = R_22^2;
  29          sbit BUTTON_19_BIT = R_22^3;
  30          sbit BUTTON_20_BIT = R_22^4;
  31          sbit BUTTON_21_BIT = R_22^5;
  32          sbit BUTTON_22_BIT = R_22^6;
  33          sbit BUTTON_23_BIT = R_22^7;
  34
  35          bdata unsigned char R_23;
  36          sbit BUTTON_24_BIT = R_23^0;
  37          sbit BUTTON_25_BIT = R_23^1;
  38          sbit BUTTON_26_BIT = R_23^2;
  39          sbit BUTTON_27_BIT = R_23^3;
  40          sbit BUTTON_28_BIT = R_23^4;
  41          sbit BUTTON_29_BIT = R_23^5;
  42          sbit BUTTON_30_BIT = R_23^6;
  43          sbit BUTTON_31_BIT = R_23^7;
  44
  45          void BUTTON_0_ON(void)
  46          {BUTTON_0_BIT=0;
  47   1      }
  48
  49          void BUTTON_1_ON(void)
  50          {BUTTON_1_BIT=0;
  51   1      }
  52          void BUTTON_2_ON(void)
  53          {BUTTON_2_BIT=0;
  54   1      }
  55          void BUTTON_3_ON(void)
  56          {BUTTON_3_BIT=0;
  57   1      }
  58          void BUTTON_4_ON(void)
  59          {BUTTON_4_BIT=0;
  60   1      }
  61          void BUTTON_5_ON(void)
  62          {BUTTON_5_BIT=0;
  63   1      }
  64          void BUTTON_6_ON(void)
  65          {BUTTON_6_BIT=0;
  66   1      }
  67          void BUTTON_7_ON(void)
  68          {BUTTON_7_BIT=0;
  69   1      }
  70          void BUTTON_8_ON(void)
  71          {BUTTON_8_BIT=0;
  72   1      }
  73          void BUTTON_9_ON(void)
  74          {BUTTON_9_BIT=0;
  75   1      }
  76          void BUTTON_10_ON(void)
  77          {BUTTON_10_BIT=0;
  78   1      }
  79          void BUTTON_11_ON(void)
  80          {BUTTON_11_BIT=0;
  81   1      }
  82          void BUTTON_12_ON(void)
  83          {BUTTON_12_BIT=0;
  84   1      }
  85          void BUTTON_13_ON(void)
  86          {BUTTON_13_BIT=0;
  87   1      }
  88          void BUTTON_14_ON(void)
  89          {BUTTON_14_BIT=0;
  90   1      }
  91          void BUTTON_15_ON(void)
  92          {BUTTON_15_BIT=0;
  93   1      }
  94          void BUTTON_16_ON(void)
  95          {BUTTON_16_BIT=0;
  96   1      }
  97          void BUTTON_17_ON(void)
  98          {BUTTON_17_BIT=0;
  99   1      }
100          void BUTTON_18_ON(void)
101          {BUTTON_18_BIT=0;
102   1      }
103          void BUTTON_19_ON(void)
104          {BUTTON_19_BIT=0;
105   1      }
106          void BUTTON_20_ON(void)
107          {BUTTON_20_BIT=0;
108   1      }
109          void BUTTON_21_ON(void)
110          {BUTTON_21_BIT=0;
111   1      }
112          void BUTTON_22_ON(void)
113          {BUTTON_22_BIT=0;
114   1      }
115          void BUTTON_23_ON(void)
116          {BUTTON_23_BIT=0;
117   1      }
118          void BUTTON_24_ON(void)
119          {BUTTON_24_BIT=0;
120   1      }
121          void BUTTON_25_ON(void)
122          {BUTTON_25_BIT=0;
123   1      }
124          void BUTTON_26_ON(void)
125          {BUTTON_26_BIT=0;
126   1      }
127          void BUTTON_27_ON(void)
128          {BUTTON_27_BIT=0;
129   1      }
130          void BUTTON_28_ON(void)
131          {BUTTON_28_BIT=0;
132   1      }
133
134          void BUTTON_29_ON(void)
135          {BUTTON_29_BIT=0;
136   1      }
137
138          void BUTTON_30_ON(void)
139          {BUTTON_29_BIT=0;
140   1      }
141          void BUTTON_31_ON(void)
142          {BUTTON_29_BIT=0;
143   1      }
144
145
146          void main(void)
147          {while(1)
148   1        {
149   2        if (BUTTON_0_BIT) BUTTON_0_ON();
150   2        if (BUTTON_1_BIT) BUTTON_1_ON();
151   2        if (BUTTON_2_BIT) BUTTON_2_ON();
152   2        if (BUTTON_3_BIT) BUTTON_3_ON();
153   2        if (BUTTON_4_BIT) BUTTON_4_ON();
154   2        if (BUTTON_5_BIT) BUTTON_5_ON();
155   2        if (BUTTON_6_BIT) BUTTON_6_ON();
156   2        if (BUTTON_7_BIT) BUTTON_7_ON();
157   2        if (BUTTON_8_BIT) BUTTON_8_ON();
158   2        if (BUTTON_9_BIT) BUTTON_9_ON();
159   2        if (BUTTON_10_BIT) BUTTON_10_ON();
160   2        if (BUTTON_11_BIT) BUTTON_11_ON();
161   2        if (BUTTON_12_BIT) BUTTON_12_ON();
162   2        if (BUTTON_13_BIT) BUTTON_13_ON();
163   2        if (BUTTON_14_BIT) BUTTON_14_ON();
164   2        if (BUTTON_15_BIT) BUTTON_15_ON();
165   2        if (BUTTON_16_BIT) BUTTON_16_ON();
166   2        if (BUTTON_17_BIT) BUTTON_17_ON();
167   2        if (BUTTON_18_BIT) BUTTON_18_ON();
168   2        if (BUTTON_19_BIT) BUTTON_19_ON();
169   2        if (BUTTON_20_BIT) BUTTON_20_ON();
170   2        if (BUTTON_21_BIT) BUTTON_21_ON();
171   2        if (BUTTON_22_BIT) BUTTON_22_ON();
172   2        if (BUTTON_23_BIT) BUTTON_23_ON();
173   2        if (BUTTON_24_BIT) BUTTON_24_ON();
174   2        if (BUTTON_25_BIT) BUTTON_25_ON();
175   2        if (BUTTON_26_BIT) BUTTON_26_ON();
176   2        if (BUTTON_27_BIT) BUTTON_27_ON();
177   2        if (BUTTON_28_BIT) BUTTON_28_ON();
178   2        if (BUTTON_29_BIT) BUTTON_29_ON();
179   2        if (BUTTON_30_BIT) BUTTON_30_ON();
180   2        if (BUTTON_31_BIT) BUTTON_31_ON();
181   2
182   2        }
183   1      }
184

这是编译产生的汇编代码

我没有AVR的C编译器,这是51的,但是大家可以看看产生的汇编代码的形式,是不是和178楼的基本一样?

             ; FUNCTION BUTTON_0_ON (BEGIN)
                                           ; SOURCE LINE # 45
                                           ; SOURCE LINE # 46
0000 C200        R     CLR     BUTTON_0_BIT
                                           ; SOURCE LINE # 47
0002 22                RET
             ; FUNCTION BUTTON_0_ON (END)

             ; FUNCTION BUTTON_1_ON (BEGIN)
                                           ; SOURCE LINE # 49
                                           ; SOURCE LINE # 50
0000 C200        R     CLR     BUTTON_1_BIT
                                           ; SOURCE LINE # 51
0002 22                RET
             ; FUNCTION BUTTON_1_ON (END)

             ; FUNCTION BUTTON_2_ON (BEGIN)
                                           ; SOURCE LINE # 52
                                           ; SOURCE LINE # 53
0000 C200        R     CLR     BUTTON_2_BIT
                                           ; SOURCE LINE # 54
0002 22                RET
             ; FUNCTION BUTTON_2_ON (END)

             ; FUNCTION BUTTON_3_ON (BEGIN)
                                           ; SOURCE LINE # 55
                                           ; SOURCE LINE # 56
0000 C200        R     CLR     BUTTON_3_BIT
                                           ; SOURCE LINE # 57
0002 22                RET
             ; FUNCTION BUTTON_3_ON (END)

             ; FUNCTION BUTTON_4_ON (BEGIN)
                                           ; SOURCE LINE # 58
                                           ; SOURCE LINE # 59
0000 C200        R     CLR     BUTTON_4_BIT
                                           ; SOURCE LINE # 60
0002 22                RET
             ; FUNCTION BUTTON_4_ON (END)

             ; FUNCTION BUTTON_5_ON (BEGIN)
                                           ; SOURCE LINE # 61
                                           ; SOURCE LINE # 62
0000 C200        R     CLR     BUTTON_5_BIT
                                           ; SOURCE LINE # 63
0002 22                RET
             ; FUNCTION BUTTON_5_ON (END)

             ; FUNCTION BUTTON_6_ON (BEGIN)
                                           ; SOURCE LINE # 64
                                           ; SOURCE LINE # 65
0000 C200        R     CLR     BUTTON_6_BIT
                                           ; SOURCE LINE # 66
0002 22                RET
             ; FUNCTION BUTTON_6_ON (END)

             ; FUNCTION BUTTON_7_ON (BEGIN)
                                           ; SOURCE LINE # 67
                                           ; SOURCE LINE # 68

0000 C200        R     CLR     BUTTON_7_BIT
                                           ; SOURCE LINE # 69
0002 22                RET
             ; FUNCTION BUTTON_7_ON (END)

             ; FUNCTION BUTTON_8_ON (BEGIN)
                                           ; SOURCE LINE # 70
                                           ; SOURCE LINE # 71
0000 C200        R     CLR     BUTTON_8_BIT
                                           ; SOURCE LINE # 72
0002 22                RET
             ; FUNCTION BUTTON_8_ON (END)

             ; FUNCTION BUTTON_9_ON (BEGIN)
                                           ; SOURCE LINE # 73
                                           ; SOURCE LINE # 74
0000 C200        R     CLR     BUTTON_9_BIT
                                           ; SOURCE LINE # 75
0002 22                RET
             ; FUNCTION BUTTON_9_ON (END)

             ; FUNCTION BUTTON_10_ON (BEGIN)
                                           ; SOURCE LINE # 76
                                           ; SOURCE LINE # 77
0000 C200        R     CLR     BUTTON_10_BIT
                                           ; SOURCE LINE # 78
0002 22                RET
             ; FUNCTION BUTTON_10_ON (END)

             ; FUNCTION BUTTON_11_ON (BEGIN)
                                           ; SOURCE LINE # 79
                                           ; SOURCE LINE # 80
0000 C200        R     CLR     BUTTON_11_BIT
                                           ; SOURCE LINE # 81
0002 22                RET
             ; FUNCTION BUTTON_11_ON (END)

             ; FUNCTION BUTTON_12_ON (BEGIN)
                                           ; SOURCE LINE # 82
                                           ; SOURCE LINE # 83
0000 C200        R     CLR     BUTTON_12_BIT
                                           ; SOURCE LINE # 84
0002 22                RET
             ; FUNCTION BUTTON_12_ON (END)

             ; FUNCTION BUTTON_13_ON (BEGIN)
                                           ; SOURCE LINE # 85
                                           ; SOURCE LINE # 86
0000 C200        R     CLR     BUTTON_13_BIT
                                           ; SOURCE LINE # 87
0002 22                RET
             ; FUNCTION BUTTON_13_ON (END)

             ; FUNCTION BUTTON_14_ON (BEGIN)
                                           ; SOURCE LINE # 88
                                           ; SOURCE LINE # 89
0000 C200        R     CLR     BUTTON_14_BIT
                                           ; SOURCE LINE # 90
0002 22                RET
             ; FUNCTION BUTTON_14_ON (END)

             ; FUNCTION BUTTON_15_ON (BEGIN)

                                           ; SOURCE LINE # 91
                                           ; SOURCE LINE # 92
0000 C200        R     CLR     BUTTON_15_BIT
                                           ; SOURCE LINE # 93
0002 22                RET
             ; FUNCTION BUTTON_15_ON (END)

             ; FUNCTION BUTTON_16_ON (BEGIN)
                                           ; SOURCE LINE # 94
                                           ; SOURCE LINE # 95
0000 C200        R     CLR     BUTTON_16_BIT
                                           ; SOURCE LINE # 96
0002 22                RET
             ; FUNCTION BUTTON_16_ON (END)

             ; FUNCTION BUTTON_17_ON (BEGIN)
                                           ; SOURCE LINE # 97
                                           ; SOURCE LINE # 98
0000 C200        R     CLR     BUTTON_17_BIT
                                           ; SOURCE LINE # 99
0002 22                RET
             ; FUNCTION BUTTON_17_ON (END)

             ; FUNCTION BUTTON_18_ON (BEGIN)
                                           ; SOURCE LINE # 100
                                           ; SOURCE LINE # 101
0000 C200        R     CLR     BUTTON_18_BIT
                                           ; SOURCE LINE # 102
0002 22                RET
             ; FUNCTION BUTTON_18_ON (END)

             ; FUNCTION BUTTON_19_ON (BEGIN)
                                           ; SOURCE LINE # 103
                                           ; SOURCE LINE # 104
0000 C200        R     CLR     BUTTON_19_BIT
                                           ; SOURCE LINE # 105
0002 22                RET
             ; FUNCTION BUTTON_19_ON (END)

             ; FUNCTION BUTTON_20_ON (BEGIN)
                                           ; SOURCE LINE # 106
                                           ; SOURCE LINE # 107
0000 C200        R     CLR     BUTTON_20_BIT
                                           ; SOURCE LINE # 108
0002 22                RET
             ; FUNCTION BUTTON_20_ON (END)

             ; FUNCTION BUTTON_21_ON (BEGIN)
                                           ; SOURCE LINE # 109
                                           ; SOURCE LINE # 110
0000 C200        R     CLR     BUTTON_21_BIT
                                           ; SOURCE LINE # 111
0002 22                RET
             ; FUNCTION BUTTON_21_ON (END)

             ; FUNCTION BUTTON_22_ON (BEGIN)
                                           ; SOURCE LINE # 112
                                           ; SOURCE LINE # 113
0000 C200        R     CLR     BUTTON_22_BIT
                                           ; SOURCE LINE # 114
0002 22                RET
             ; FUNCTION BUTTON_22_ON (END)

             ; FUNCTION BUTTON_23_ON (BEGIN)
                                           ; SOURCE LINE # 115
                                           ; SOURCE LINE # 116
0000 C200        R     CLR     BUTTON_23_BIT
                                           ; SOURCE LINE # 117
0002 22                RET
             ; FUNCTION BUTTON_23_ON (END)

             ; FUNCTION BUTTON_24_ON (BEGIN)
                                           ; SOURCE LINE # 118
                                           ; SOURCE LINE # 119
0000 C200        R     CLR     BUTTON_24_BIT
                                           ; SOURCE LINE # 120
0002 22                RET
             ; FUNCTION BUTTON_24_ON (END)

             ; FUNCTION BUTTON_25_ON (BEGIN)
                                           ; SOURCE LINE # 121
                                           ; SOURCE LINE # 122
0000 C200        R     CLR     BUTTON_25_BIT
                                           ; SOURCE LINE # 123
0002 22                RET
             ; FUNCTION BUTTON_25_ON (END)

             ; FUNCTION BUTTON_26_ON (BEGIN)
                                           ; SOURCE LINE # 124
                                           ; SOURCE LINE # 125
0000 C200        R     CLR     BUTTON_26_BIT
                                           ; SOURCE LINE # 126
0002 22                RET
             ; FUNCTION BUTTON_26_ON (END)

             ; FUNCTION BUTTON_27_ON (BEGIN)
                                           ; SOURCE LINE # 127
                                           ; SOURCE LINE # 128
0000 C200        R     CLR     BUTTON_27_BIT
                                           ; SOURCE LINE # 129
0002 22                RET
             ; FUNCTION BUTTON_27_ON (END)

             ; FUNCTION BUTTON_28_ON (BEGIN)
                                           ; SOURCE LINE # 130
                                           ; SOURCE LINE # 131
0000 C200        R     CLR     BUTTON_28_BIT
                                           ; SOURCE LINE # 132
0002 22                RET
             ; FUNCTION BUTTON_28_ON (END)

             ; FUNCTION BUTTON_29_ON (BEGIN)
                                           ; SOURCE LINE # 134
                                           ; SOURCE LINE # 135
0000 C200        R     CLR     BUTTON_29_BIT
                                           ; SOURCE LINE # 136
0002 22                RET
             ; FUNCTION BUTTON_29_ON (END)

             ; FUNCTION BUTTON_30_ON (BEGIN)
                                           ; SOURCE LINE # 138
                                           ; SOURCE LINE # 139
0000 C200        R     CLR     BUTTON_29_BIT
                                           ; SOURCE LINE # 140
0002 22                RET
             ; FUNCTION BUTTON_30_ON (END)

             ; FUNCTION BUTTON_31_ON (BEGIN)
                                           ; SOURCE LINE # 141
                                           ; SOURCE LINE # 142
0000 C200        R     CLR     BUTTON_29_BIT
                                           ; SOURCE LINE # 143
0002 22                RET
             ; FUNCTION BUTTON_31_ON (END)

             ; FUNCTION main (BEGIN)
                                           ; SOURCE LINE # 146
                                           ; SOURCE LINE # 147
0000         ?C0033:
                                           ; SOURCE LINE # 148
                                           ; SOURCE LINE # 149
0000 300003      R     JNB     BUTTON_0_BIT,?C0035
0003 120000      R     LCALL   BUTTON_0_ON
0006         ?C0035:
                                           ; SOURCE LINE # 150
0006 300003      R     JNB     BUTTON_1_BIT,?C0036
0009 120000      R     LCALL   BUTTON_1_ON
000C         ?C0036:
                                           ; SOURCE LINE # 151
000C 300003      R     JNB     BUTTON_2_BIT,?C0037
000F 120000      R     LCALL   BUTTON_2_ON
0012         ?C0037:
                                           ; SOURCE LINE # 152
0012 300003      R     JNB     BUTTON_3_BIT,?C0038
0015 120000      R     LCALL   BUTTON_3_ON
0018         ?C0038:
                                           ; SOURCE LINE # 153
0018 300003      R     JNB     BUTTON_4_BIT,?C0039
001B 120000      R     LCALL   BUTTON_4_ON
001E         ?C0039:
                                           ; SOURCE LINE # 154
001E 300003      R     JNB     BUTTON_5_BIT,?C0040
0021 120000      R     LCALL   BUTTON_5_ON
0024         ?C0040:
                                           ; SOURCE LINE # 155
0024 300003      R     JNB     BUTTON_6_BIT,?C0041
0027 120000      R     LCALL   BUTTON_6_ON
002A         ?C0041:
                                           ; SOURCE LINE # 156
002A 300003      R     JNB     BUTTON_7_BIT,?C0042
002D 120000      R     LCALL   BUTTON_7_ON
0030         ?C0042:
                                           ; SOURCE LINE # 157
0030 300003      R     JNB     BUTTON_8_BIT,?C0043
0033 120000      R     LCALL   BUTTON_8_ON
0036         ?C0043:
                                           ; SOURCE LINE # 158
0036 300003      R     JNB     BUTTON_9_BIT,?C0044
0039 120000      R     LCALL   BUTTON_9_ON
003C         ?C0044:
                                           ; SOURCE LINE # 159
003C 300003      R     JNB     BUTTON_10_BIT,?C0045
003F 120000      R     LCALL   BUTTON_10_ON
0042         ?C0045:
                                           ; SOURCE LINE # 160
0042 300003      R     JNB     BUTTON_11_BIT,?C0046
0045 120000      R     LCALL   BUTTON_11_ON
0048         ?C0046:
                                           ; SOURCE LINE # 161
0048 300003      R     JNB     BUTTON_12_BIT,?C0047
004B 120000      R     LCALL   BUTTON_12_ON
004E         ?C0047:
                                           ; SOURCE LINE # 162
004E 300003      R     JNB     BUTTON_13_BIT,?C0048
0051 120000      R     LCALL   BUTTON_13_ON
0054         ?C0048:
                                           ; SOURCE LINE # 163
0054 300003      R     JNB     BUTTON_14_BIT,?C0049
0057 120000      R     LCALL   BUTTON_14_ON
005A         ?C0049:
                                           ; SOURCE LINE # 164
005A 300003      R     JNB     BUTTON_15_BIT,?C0050
005D 120000      R     LCALL   BUTTON_15_ON
0060         ?C0050:
                                           ; SOURCE LINE # 165
0060 300003      R     JNB     BUTTON_16_BIT,?C0051
0063 120000      R     LCALL   BUTTON_16_ON
0066         ?C0051:
                                           ; SOURCE LINE # 166
0066 300003      R     JNB     BUTTON_17_BIT,?C0052
0069 120000      R     LCALL   BUTTON_17_ON
006C         ?C0052:
                                           ; SOURCE LINE # 167
006C 300003      R     JNB     BUTTON_18_BIT,?C0053
006F 120000      R     LCALL   BUTTON_18_ON
0072         ?C0053:
                                           ; SOURCE LINE # 168
0072 300003      R     JNB     BUTTON_19_BIT,?C0054
0075 120000      R     LCALL   BUTTON_19_ON
0078         ?C0054:
                                           ; SOURCE LINE # 169
0078 300003      R     JNB     BUTTON_20_BIT,?C0055
007B 120000      R     LCALL   BUTTON_20_ON
007E         ?C0055:
                                           ; SOURCE LINE # 170
007E 300003      R     JNB     BUTTON_21_BIT,?C0056
0081 120000      R     LCALL   BUTTON_21_ON
0084         ?C0056:
                                           ; SOURCE LINE # 171
0084 300003      R     JNB     BUTTON_22_BIT,?C0057
0087 120000      R     LCALL   BUTTON_22_ON
008A         ?C0057:
                                           ; SOURCE LINE # 172
008A 300003      R     JNB     BUTTON_23_BIT,?C0058
008D 120000      R     LCALL   BUTTON_23_ON
0090         ?C0058:
                                           ; SOURCE LINE # 173
0090 300003      R     JNB     BUTTON_24_BIT,?C0059
0093 120000      R     LCALL   BUTTON_24_ON
0096         ?C0059:
                                           ; SOURCE LINE # 174
0096 300003      R     JNB     BUTTON_25_BIT,?C0060
0099 120000      R     LCALL   BUTTON_25_ON
009C         ?C0060:
                                           ; SOURCE LINE # 175
009C 300003      R     JNB     BUTTON_26_BIT,?C0061
009F 120000      R     LCALL   BUTTON_26_ON
00A2         ?C0061:
                                           ; SOURCE LINE # 176
00A2 300003      R     JNB     BUTTON_27_BIT,?C0062
00A5 120000      R     LCALL   BUTTON_27_ON
00A8         ?C0062:
                                           ; SOURCE LINE # 177
00A8 300003      R     JNB     BUTTON_28_BIT,?C0063
00AB 120000      R     LCALL   BUTTON_28_ON
00AE         ?C0063:
                                           ; SOURCE LINE # 178
00AE 300003      R     JNB     BUTTON_29_BIT,?C0064
00B1 120000      R     LCALL   BUTTON_29_ON
00B4         ?C0064:
                                           ; SOURCE LINE # 179
00B4 300003      R     JNB     BUTTON_30_BIT,?C0065
00B7 120000      R     LCALL   BUTTON_30_ON
00BA         ?C0065:
                                           ; SOURCE LINE # 180
00BA 200003      R     JB      BUTTON_31_BIT,$ + 6H
00BD 020000      R     LJMP    ?C0033
00C0 120000      R     LCALL   BUTTON_31_ON
                                           ; SOURCE LINE # 182
00C3 020000      R     LJMP    ?C0033
             ; FUNCTION main (END)

出0入0汤圆

发表于 2009-8-28 11:19:38 | 显示全部楼层
真正的武器要看掌握在哪个人手上。我看过有人用汇编的可懒了,操作LCM什么都是填充,好做嘛,就复制修改行了,那个效率可不敢恭维,我用C 7K可以做到,它的界面简单多了,用了12K的空间。

出0入0汤圆

发表于 2009-8-28 17:29:53 | 显示全部楼层
【191楼】:“我没有AVR的C编译器,这是51的”

51和AVR对变量的使用差远了:51的变量可以直接使用的,而AVR的变量却要先加载到寄存器才可以使用。
还有C51支持位变量而AVR的C很少有支持位变量的。
所以不能拿C51来说AVR的C的事。

何况要在程序中留出几个寄存器不用,对AVR的C来说代价不是一般的小。

出0入0汤圆

发表于 2009-8-28 17:47:31 | 显示全部楼层
【193楼】 qianhng

  AVR的C 也是支持位变量的,
  实际上,任何C都是支持位域的,哪怕你的MCU不支持位处理,他也会模拟出来

  我的意思是C的编译效率,不是人们想的那样低

出0入0汤圆

发表于 2009-8-28 17:51:17 | 显示全部楼层
程序还请你用AVR的C来写和编译。
麻烦你用事实来说服我,谢谢!

出0入0汤圆

发表于 2009-8-28 19:08:03 | 显示全部楼层
终于找到一个AVR的C了!

这是版本和参数设置

//////////////////////////////////////////////////////////////////////////////
//                                                                           /
//                                                     28/Aug/2009  19:09:57 /
// IAR Atmel AVR C/C++ Compiler V4.10A/W32, Evaluation Version               /
// Copyright 1996-2005 IAR Systems. All rights reserved.                     /
//                                                                           /
//    Source file  =  D:\AVR\CTEST\main.c                                    /
//    Command line =  --cpu=m48 -ms -o D:\AVR\CTEST\Debug\Obj\ -lb           /
//                    D:\AVR\CTEST\Debug\List\ --initializers_in_flash -s2   /
//                    --no_cse --no_inline --no_code_motion --no_cross_call  /
//                    --no_clustering --no_tbaa --debug                      /
//                    -DENABLE_BIT_DEFINITIONS -e --enable_multibytes -I     /
//                    "C:\Program Files\IAR Systems\Embedded Workbench       /
//                    Evaluation version\avr\INC\" -I "C:\Program Files\IAR  /
//                    Systems\Embedded Workbench  Evaluation                 /
//                    version\avr\INC\CLIB\" --eeprom_size 256               /
//                    D:\AVR\CTEST\main.c                                    /
//    List file    =  D:\AVR\CTEST\Debug\List\main.s90                       /
//                                                                           /
//                                                                           /
//////////////////////////////////////////////////////////////////////////////

这是源程序

*包含所需头文件*/
# include <iom48.h>
# include <intrinsics.h>
# include <stdlib.h>
# include <stdio.h>
# include <string.h>
# include <math.h>

SFR_B_R(0x1c, BUTTON_A)
SFR_B_R(0x1d, BUTTON_B)
SFR_B_R(0x1e, BUTTON_C)
SFR_B_R(0x1f, BUTTON_D)


void BUTTON_0_ON(void)
{BUTTON_A_Bit0=0;
}
void BUTTON_1_ON(void)
{BUTTON_A_Bit1=0;
}
void BUTTON_2_ON(void)
{BUTTON_A_Bit2=0;
}
void BUTTON_3_ON(void)
{BUTTON_A_Bit3=0;
}
void BUTTON_4_ON(void)
{BUTTON_A_Bit4=0;
}
void BUTTON_5_ON(void)
{BUTTON_A_Bit5=0;
}
void BUTTON_6_ON(void)
{BUTTON_A_Bit6=0;
}
void BUTTON_7_ON(void)
{BUTTON_A_Bit7=0;
}

void BUTTON_8_ON(void)
{BUTTON_B_Bit0=0;
}
void BUTTON_9_ON(void)
{BUTTON_B_Bit1=0;
}
void BUTTON_10_ON(void)
{BUTTON_B_Bit2=0;
}
void BUTTON_11_ON(void)
{BUTTON_B_Bit3=0;
}
void BUTTON_12_ON(void)
{BUTTON_B_Bit4=0;
}
void BUTTON_13_ON(void)
{BUTTON_B_Bit5=0;
}
void BUTTON_14_ON(void)
{BUTTON_B_Bit6=0;
}
void BUTTON_15_ON(void)
{BUTTON_B_Bit7=0;
}

void BUTTON_16_ON(void)
{BUTTON_C_Bit0=0;
}
void BUTTON_17_ON(void)
{BUTTON_C_Bit1=0;
}
void BUTTON_18_ON(void)
{BUTTON_C_Bit2=0;
}
void BUTTON_19_ON(void)
{BUTTON_C_Bit3=0;
}
void BUTTON_20_ON(void)
{BUTTON_C_Bit4=0;
}
void BUTTON_21_ON(void)
{BUTTON_C_Bit5=0;
}
void BUTTON_22_ON(void)
{BUTTON_C_Bit6=0;
}
void BUTTON_23_ON(void)
{BUTTON_C_Bit7=0;
}

void BUTTON_24_ON(void)
{BUTTON_D_Bit0=0;
}
void BUTTON_25_ON(void)
{BUTTON_D_Bit1=0;
}
void BUTTON_26_ON(void)
{BUTTON_D_Bit2=0;
}
void BUTTON_27_ON(void)
{BUTTON_D_Bit3=0;
}
void BUTTON_28_ON(void)
{BUTTON_D_Bit4=0;
}
void BUTTON_29_ON(void)
{BUTTON_D_Bit5=0;
}
void BUTTON_30_ON(void)
{BUTTON_D_Bit6=0;
}
void BUTTON_31_ON(void)
{BUTTON_D_Bit7=0;
}

void main(void)
{while(1)
  {
  if (BUTTON_A_Bit0) BUTTON_0_ON();
  if (BUTTON_A_Bit1) BUTTON_1_ON();
  if (BUTTON_A_Bit2) BUTTON_2_ON();
  if (BUTTON_A_Bit3) BUTTON_3_ON();
  if (BUTTON_A_Bit4) BUTTON_4_ON();
  if (BUTTON_A_Bit5) BUTTON_5_ON();
  if (BUTTON_A_Bit6) BUTTON_6_ON();
  if (BUTTON_A_Bit7) BUTTON_7_ON();

  if (BUTTON_B_Bit0) BUTTON_8_ON();
  if (BUTTON_B_Bit1) BUTTON_9_ON();
  if (BUTTON_B_Bit2) BUTTON_10_ON();
  if (BUTTON_B_Bit3) BUTTON_11_ON();
  if (BUTTON_B_Bit4) BUTTON_12_ON();
  if (BUTTON_B_Bit5) BUTTON_13_ON();
  if (BUTTON_B_Bit6) BUTTON_14_ON();
  if (BUTTON_B_Bit7) BUTTON_15_ON();

  if (BUTTON_C_Bit0) BUTTON_16_ON();
  if (BUTTON_C_Bit1) BUTTON_17_ON();
  if (BUTTON_C_Bit2) BUTTON_18_ON();
  if (BUTTON_C_Bit3) BUTTON_19_ON();
  if (BUTTON_C_Bit4) BUTTON_20_ON();
  if (BUTTON_C_Bit5) BUTTON_21_ON();
  if (BUTTON_C_Bit6) BUTTON_22_ON();
  if (BUTTON_C_Bit7) BUTTON_23_ON();

  if (BUTTON_D_Bit0) BUTTON_24_ON();
  if (BUTTON_D_Bit1) BUTTON_25_ON();
  if (BUTTON_D_Bit2) BUTTON_26_ON();
  if (BUTTON_D_Bit3) BUTTON_27_ON();
  if (BUTTON_D_Bit4) BUTTON_28_ON();
  if (BUTTON_D_Bit5) BUTTON_29_ON();
  if (BUTTON_D_Bit6) BUTTON_30_ON();
  if (BUTTON_D_Bit7) BUTTON_31_ON();

  }
}

这是汇编代码

        RSEG CODE:CODE:NOROOT(1)
BUTTON_0_ON:
        CBI        0x1C, 0x00
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_1_ON:
        CBI        0x1C, 0x01
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_2_ON:
        CBI        0x1C, 0x02
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_3_ON:
        CBI        0x1C, 0x03
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_4_ON:
        CBI        0x1C, 0x04
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_5_ON:
        CBI        0x1C, 0x05
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_6_ON:
        CBI        0x1C, 0x06
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_7_ON:
        CBI        0x1C, 0x07
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_8_ON:
        CBI        0x1D, 0x00
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_9_ON:
        CBI        0x1D, 0x01
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_10_ON:
        CBI        0x1D, 0x02
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_11_ON:
        CBI        0x1D, 0x03
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_12_ON:
        CBI        0x1D, 0x04
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_13_ON:
        CBI        0x1D, 0x05
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_14_ON:
        CBI        0x1D, 0x06
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_15_ON:
        CBI        0x1D, 0x07
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_16_ON:
        CBI        0x1E, 0x00
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_17_ON:
        CBI        0x1E, 0x01
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_18_ON:
        CBI        0x1E, 0x02
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_19_ON:
        CBI        0x1E, 0x03
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_20_ON:
        CBI        0x1E, 0x04
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_21_ON:
        CBI        0x1E, 0x05
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_22_ON:
        CBI        0x1E, 0x06
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_23_ON:
        CBI        0x1E, 0x07
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_24_ON:
        CBI        0x1F, 0x00
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_25_ON:
        CBI        0x1F, 0x01
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_26_ON:
        CBI        0x1F, 0x02
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_27_ON:
        CBI        0x1F, 0x03
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_28_ON:
        CBI        0x1F, 0x04
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_29_ON:
        CBI        0x1F, 0x05
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_30_ON:
        CBI        0x1F, 0x06
        RET

        RSEG CODE:CODE:NOROOT(1)
BUTTON_31_ON:
        CBI        0x1F, 0x07
        RET

        RSEG CODE:CODE:NOROOT(1)
main:
??main_0:
        SBIC        0x1C, 0x00
        RCALL        BUTTON_0_ON
??main_1:
        SBIC        0x1C, 0x01
        RCALL        BUTTON_1_ON
??main_2:
        SBIC        0x1C, 0x02
        RCALL        BUTTON_2_ON
??main_3:
        SBIC        0x1C, 0x03
        RCALL        BUTTON_3_ON
??main_4:
        SBIC        0x1C, 0x04
        RCALL        BUTTON_4_ON
??main_5:
        SBIC        0x1C, 0x05
        RCALL        BUTTON_5_ON
??main_6:
        SBIC        0x1C, 0x06
        RCALL        BUTTON_6_ON
??main_7:
        SBIC        0x1C, 0x07
        RCALL        BUTTON_7_ON
??main_8:
        SBIC        0x1D, 0x00
        RCALL        BUTTON_8_ON
??main_9:
        SBIC        0x1D, 0x01
        RCALL        BUTTON_9_ON
??main_10:
        SBIC        0x1D, 0x02
        RCALL        BUTTON_10_ON
??main_11:
        SBIC        0x1D, 0x03
        RCALL        BUTTON_11_ON
??main_12:
        SBIC        0x1D, 0x04
        RCALL        BUTTON_12_ON
??main_13:
        SBIC        0x1D, 0x05
        RCALL        BUTTON_13_ON
??main_14:
        SBIC        0x1D, 0x06
        RCALL        BUTTON_14_ON
??main_15:
        SBIC        0x1D, 0x07
        RCALL        BUTTON_15_ON
??main_16:
        SBIC        0x1E, 0x00
        RCALL        BUTTON_16_ON
??main_17:
        SBIC        0x1E, 0x01
        RCALL        BUTTON_17_ON
??main_18:
        SBIC        0x1E, 0x02
        RCALL        BUTTON_18_ON
??main_19:
        SBIC        0x1E, 0x03
        RCALL        BUTTON_19_ON
??main_20:
        SBIC        0x1E, 0x04
        RCALL        BUTTON_20_ON
??main_21:
        SBIC        0x1E, 0x05
        RCALL        BUTTON_21_ON
??main_22:
        SBIC        0x1E, 0x06
        RCALL        BUTTON_22_ON
??main_23:
        SBIC        0x1E, 0x07
        RCALL        BUTTON_23_ON
??main_24:
        SBIC        0x1F, 0x00
        RCALL        BUTTON_24_ON
??main_25:
        SBIC        0x1F, 0x01
        RCALL        BUTTON_25_ON
??main_26:
        SBIC        0x1F, 0x02
        RCALL        BUTTON_26_ON
??main_27:
        SBIC        0x1F, 0x03
        RCALL        BUTTON_27_ON
??main_28:
        SBIC        0x1F, 0x04
        RCALL        BUTTON_28_ON
??main_29:
        SBIC        0x1F, 0x05
        RCALL        BUTTON_29_ON
??main_30:
        SBIC        0x1F, 0x06
        RCALL        BUTTON_30_ON
??main_31:
        SBIS        0x1F, 0x07
        RJMP        ??main_0
        RCALL        BUTTON_31_ON
        RJMP        ??main_0

        ASEGN ABSOLUTE:DATA:NOROOT,03cH
// union <unnamed> volatile __io _A_BUTTON_A
_A_BUTTON_A:
        DS 1

        ASEGN ABSOLUTE:DATA:NOROOT,03dH
// union <unnamed> volatile __io _A_BUTTON_B
_A_BUTTON_B:
        DS 1

        ASEGN ABSOLUTE:DATA:NOROOT,03eH
// union <unnamed> volatile __io _A_BUTTON_C
_A_BUTTON_C:
        DS 1

        ASEGN ABSOLUTE:DATA:NOROOT,03fH
// union <unnamed> volatile __io _A_BUTTON_D
_A_BUTTON_D:
        DS 1

        ASEGN ABSOLUTE:DATA:NOROOT,01fH
__?EECR:

        ASEGN ABSOLUTE:DATA:NOROOT,020H
__?EEDR:

        ASEGN ABSOLUTE:DATA:NOROOT,021H
__?EEARL:

        END

这是资源占用

//
//   4 bytes in segment ABSOLUTE
// 260 bytes in segment CODE
//
// 260 bytes of CODE memory
//   0 bytes of DATA memory (+ 4 bytes shared)
//
//Errors: none
//Warnings: none

出0入0汤圆

发表于 2009-8-28 19:09:51 | 显示全部楼层
qianhng  你看看,和你的汇编,结构是不是还是一样的?

出0入0汤圆

发表于 2009-8-28 19:43:36 | 显示全部楼层
终于给你找到IAR了,我试试,真有那么高的效率的话我都要改用IAR了.

出0入0汤圆

发表于 2009-8-29 03:39:37 | 显示全部楼层
zhxzhx 一丁,你弄错了一点:
你使用了端口地址0x1c~0x1f来作为存放状态的变量,而不是使用寄存器。
端口地址0x1c~0x1f在m48中是EIFR、EIMSK、GPIOR0、EECR,如果用它们来作变量,后果不可预知。

我下载了IAR AVR 5.10A,试了下,效率还是不如汇编,麻烦你再找找吧!

使用寄存器的程序应该是这样:
# include <iom48.h>
# include <intrinsics.h>
# include <stdlib.h>
# include <stdio.h>
# include <string.h>
# include <math.h>
union BIT_VAR
{
  unsigned char Val;
  struct
  {
    unsigned char Bit0:1,
      Bit1:1,
      Bit2:1,
      Bit3:1,
      Bit4:1,
      Bit5:1,
      Bit6:1,
      Bit7:1;
  };
};
__regvar __no_init union BIT_VAR BUTTON_A @ 12;
__regvar __no_init union BIT_VAR BUTTON_B @ 13;
__regvar __no_init union BIT_VAR BUTTON_C @ 14;
__regvar __no_init union BIT_VAR BUTTON_D @ 15;

void BUTTON_0_ON(void)
{BUTTON_A.Bit0=0;
}
void BUTTON_1_ON(void)
{BUTTON_A.Bit1=0;
}
void BUTTON_2_ON(void)
{BUTTON_A.Bit2=0;
}
void BUTTON_3_ON(void)
{BUTTON_A.Bit3=0;
}
void BUTTON_4_ON(void)
{BUTTON_A.Bit4=0;
}
void BUTTON_5_ON(void)
{BUTTON_A.Bit5=0;
}
void BUTTON_6_ON(void)
{BUTTON_A.Bit6=0;
}
void BUTTON_7_ON(void)
{BUTTON_A.Bit7=0;
}

void BUTTON_8_ON(void)
{BUTTON_B.Bit0=0;
}
void BUTTON_9_ON(void)
{BUTTON_B.Bit1=0;
}
void BUTTON_10_ON(void)
{BUTTON_B.Bit2=0;
}
void BUTTON_11_ON(void)
{BUTTON_B.Bit3=0;
}
void BUTTON_12_ON(void)
{BUTTON_B.Bit4=0;
}
void BUTTON_13_ON(void)
{BUTTON_B.Bit5=0;
}
void BUTTON_14_ON(void)
{BUTTON_B.Bit6=0;
}
void BUTTON_15_ON(void)
{BUTTON_B.Bit7=0;
}

void BUTTON_16_ON(void)
{BUTTON_C.Bit0=0;
}
void BUTTON_17_ON(void)
{BUTTON_C.Bit1=0;
}
void BUTTON_18_ON(void)
{BUTTON_C.Bit2=0;
}
void BUTTON_19_ON(void)
{BUTTON_C.Bit3=0;
}
void BUTTON_20_ON(void)
{BUTTON_C.Bit4=0;
}
void BUTTON_21_ON(void)
{BUTTON_C.Bit5=0;
}
void BUTTON_22_ON(void)
{BUTTON_C.Bit6=0;
}
void BUTTON_23_ON(void)
{BUTTON_C.Bit7=0;
}

void BUTTON_24_ON(void)
{BUTTON_D.Bit0=0;
}
void BUTTON_25_ON(void)
{BUTTON_D.Bit1=0;
}
void BUTTON_26_ON(void)
{BUTTON_D.Bit2=0;
}
void BUTTON_27_ON(void)
{BUTTON_D.Bit3=0;
}
void BUTTON_28_ON(void)
{BUTTON_D.Bit4=0;
}
void BUTTON_29_ON(void)
{BUTTON_D.Bit5=0;
}
void BUTTON_30_ON(void)
{BUTTON_D.Bit6=0;
}
void BUTTON_31_ON(void)
{BUTTON_D.Bit7=0;
}

void main(void)
{
while(1)
  {
  if (BUTTON_A.Bit0) BUTTON_0_ON();
  if (BUTTON_A.Bit1) BUTTON_1_ON();
  if (BUTTON_A.Bit2) BUTTON_2_ON();
  if (BUTTON_A.Bit3) BUTTON_3_ON();
  if (BUTTON_A.Bit4) BUTTON_4_ON();
  if (BUTTON_A.Bit5) BUTTON_5_ON();
  if (BUTTON_A.Bit6) BUTTON_6_ON();
  if (BUTTON_A.Bit7) BUTTON_7_ON();

  if (BUTTON_B.Bit0) BUTTON_8_ON();
  if (BUTTON_B.Bit1) BUTTON_9_ON();
  if (BUTTON_B.Bit2) BUTTON_10_ON();
  if (BUTTON_B.Bit3) BUTTON_11_ON();
  if (BUTTON_B.Bit4) BUTTON_12_ON();
  if (BUTTON_B.Bit5) BUTTON_13_ON();
  if (BUTTON_B.Bit6) BUTTON_14_ON();
  if (BUTTON_B.Bit7) BUTTON_15_ON();

  if (BUTTON_C.Bit0) BUTTON_16_ON();
  if (BUTTON_C.Bit1) BUTTON_17_ON();
  if (BUTTON_C.Bit2) BUTTON_18_ON();
  if (BUTTON_C.Bit3) BUTTON_19_ON();
  if (BUTTON_C.Bit4) BUTTON_20_ON();
  if (BUTTON_C.Bit5) BUTTON_21_ON();
  if (BUTTON_C.Bit6) BUTTON_22_ON();
  if (BUTTON_C.Bit7) BUTTON_23_ON();

  if (BUTTON_D.Bit0) BUTTON_24_ON();
  if (BUTTON_D.Bit1) BUTTON_25_ON();
  if (BUTTON_D.Bit2) BUTTON_26_ON();
  if (BUTTON_D.Bit3) BUTTON_27_ON();
  if (BUTTON_D.Bit4) BUTTON_28_ON();
  if (BUTTON_D.Bit5) BUTTON_29_ON();
  if (BUTTON_D.Bit6) BUTTON_30_ON();
  if (BUTTON_D.Bit7) BUTTON_31_ON();

  }
}
编译结果是:
###############################################################################
#                                                                             #
#                                                       29/Aug/2009  03:43:33 #
# IAR Atmel AVR C/C++ Compiler V5.10A/W32                                     #
# Copyright 1996-2008 IAR Systems. All rights reserved.                       #
#                                                                             #
#    Source file  =  F:\单片机\制作\test_iar\main.c                           #
#    Command line =  F:\单片机\制作\test_iar\main.c --cpu=m48 -ms -o          #
#                    F:\单片机\制作\test_iar\Debug\Obj\ -lCN                  #
#                    F:\单片机\制作\test_iar\Debug\List\ -lB                  #
#                    F:\单片机\制作\test_iar\Debug\List\                      #
#                    --initializers_in_flash -z3 --no_cse --no_inline         #
#                    --no_code_motion --no_cross_call --no_clustering         #
#                    --no_tbaa --debug -e -I "I:\Program Files\IAR            #
#                    Systems\Embedded Workbench 5.0 Evaluation\avr\INC\" -I   #
#                    "I:\Program Files\IAR Systems\Embedded Workbench 5.0     #
#                    Evaluation\avr\INC\CLIB\" --eeprom_size 256              #
#                    --lock_regs=4                                            #
#    List file    =  F:\单片机\制作\test_iar\Debug\List\main.lst              #
#    Object file  =  F:\单片机\制作\test_iar\Debug\Obj\main.r90               #
#                                                                             #
#                                                                             #
###############################################################################

F:\单片机\制作\test_iar\main.c
      1          # include <iom48.h>
      2          # include <intrinsics.h>
      3          # include <stdlib.h>
      4          # include <stdio.h>
      5          # include <string.h>
      6          # include <math.h>
      7          union BIT_VAR
      8          {
      9            unsigned char Val;
     10            struct
     11            {
     12              unsigned char Bit0:1,
     13                Bit1:1,
     14                Bit2:1,
     15                Bit3:1,
     16                Bit4:1,
     17                Bit5:1,
     18                Bit6:1,
     19                Bit7:1;
     20            };
     21          };

   \                                 In  segment REGVAR_AN, at 0xc, root
     22          __regvar __no_init union BIT_VAR BUTTON_A @ 12;
   \                     BUTTON_A:
   \   00000000                      DS 1

   \                                 In  segment REGVAR_AN, at 0xd, root
     23          __regvar __no_init union BIT_VAR BUTTON_B @ 13;
   \                     BUTTON_B:
   \   00000000                      DS 1

   \                                 In  segment REGVAR_AN, at 0xe, root
     24          __regvar __no_init union BIT_VAR BUTTON_C @ 14;
   \                     BUTTON_C:
   \   00000000                      DS 1

   \                                 In  segment REGVAR_AN, at 0xf, root
     25          __regvar __no_init union BIT_VAR BUTTON_D @ 15;
   \                     BUTTON_D:
   \   00000000                      DS 1
     26         

   \                                 In  segment CODE, align 2, keep-with-next
     27          void BUTTON_0_ON(void)
   \                     BUTTON_0_ON:
     28          {BUTTON_A.Bit0=0;
   \   00000000                      REQUIRE ?Register_R12_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8C0               BLD     R12, 0
     29          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_A

   \                                 In  segment CODE, align 2, keep-with-next
     30          void BUTTON_1_ON(void)
   \                     BUTTON_1_ON:
     31          {BUTTON_A.Bit1=0;
   \   00000000                      REQUIRE ?Register_R12_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8C1               BLD     R12, 1
     32          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_A

   \                                 In  segment CODE, align 2, keep-with-next
     33          void BUTTON_2_ON(void)
   \                     BUTTON_2_ON:
     34          {BUTTON_A.Bit2=0;
   \   00000000                      REQUIRE ?Register_R12_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8C2               BLD     R12, 2
     35          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_A

   \                                 In  segment CODE, align 2, keep-with-next
     36          void BUTTON_3_ON(void)
   \                     BUTTON_3_ON:
     37          {BUTTON_A.Bit3=0;
   \   00000000                      REQUIRE ?Register_R12_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8C3               BLD     R12, 3
     38          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_A

   \                                 In  segment CODE, align 2, keep-with-next
     39          void BUTTON_4_ON(void)
   \                     BUTTON_4_ON:
     40          {BUTTON_A.Bit4=0;
   \   00000000                      REQUIRE ?Register_R12_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8C4               BLD     R12, 4
     41          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_A

   \                                 In  segment CODE, align 2, keep-with-next
     42          void BUTTON_5_ON(void)
   \                     BUTTON_5_ON:
     43          {BUTTON_A.Bit5=0;
   \   00000000                      REQUIRE ?Register_R12_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8C5               BLD     R12, 5
     44          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_A

   \                                 In  segment CODE, align 2, keep-with-next
     45          void BUTTON_6_ON(void)
   \                     BUTTON_6_ON:
     46          {BUTTON_A.Bit6=0;
   \   00000000                      REQUIRE ?Register_R12_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8C6               BLD     R12, 6
     47          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_A

   \                                 In  segment CODE, align 2, keep-with-next
     48          void BUTTON_7_ON(void)
   \                     BUTTON_7_ON:
     49          {BUTTON_A.Bit7=0;
   \   00000000                      REQUIRE ?Register_R12_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8C7               BLD     R12, 7
     50          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_A
     51         

   \                                 In  segment CODE, align 2, keep-with-next
     52          void BUTTON_8_ON(void)
   \                     BUTTON_8_ON:
     53          {BUTTON_B.Bit0=0;
   \   00000000                      REQUIRE ?Register_R13_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8D0               BLD     R13, 0
     54          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_B

   \                                 In  segment CODE, align 2, keep-with-next
     55          void BUTTON_9_ON(void)
   \                     BUTTON_9_ON:
     56          {BUTTON_B.Bit1=0;
   \   00000000                      REQUIRE ?Register_R13_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8D1               BLD     R13, 1
     57          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_B

   \                                 In  segment CODE, align 2, keep-with-next
     58          void BUTTON_10_ON(void)
   \                     BUTTON_10_ON:
     59          {BUTTON_B.Bit2=0;
   \   00000000                      REQUIRE ?Register_R13_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8D2               BLD     R13, 2
     60          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_B

   \                                 In  segment CODE, align 2, keep-with-next
     61          void BUTTON_11_ON(void)
   \                     BUTTON_11_ON:
     62          {BUTTON_B.Bit3=0;
   \   00000000                      REQUIRE ?Register_R13_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8D3               BLD     R13, 3
     63          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_B

   \                                 In  segment CODE, align 2, keep-with-next
     64          void BUTTON_12_ON(void)
   \                     BUTTON_12_ON:
     65          {BUTTON_B.Bit4=0;
   \   00000000                      REQUIRE ?Register_R13_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8D4               BLD     R13, 4
     66          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_B

   \                                 In  segment CODE, align 2, keep-with-next
     67          void BUTTON_13_ON(void)
   \                     BUTTON_13_ON:
     68          {BUTTON_B.Bit5=0;
   \   00000000                      REQUIRE ?Register_R13_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8D5               BLD     R13, 5
     69          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_B

   \                                 In  segment CODE, align 2, keep-with-next
     70          void BUTTON_14_ON(void)
   \                     BUTTON_14_ON:
     71          {BUTTON_B.Bit6=0;
   \   00000000                      REQUIRE ?Register_R13_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8D6               BLD     R13, 6
     72          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_B

   \                                 In  segment CODE, align 2, keep-with-next
     73          void BUTTON_15_ON(void)
   \                     BUTTON_15_ON:
     74          {BUTTON_B.Bit7=0;
   \   00000000                      REQUIRE ?Register_R13_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8D7               BLD     R13, 7
     75          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_B
     76         

   \                                 In  segment CODE, align 2, keep-with-next
     77          void BUTTON_16_ON(void)
   \                     BUTTON_16_ON:
     78          {BUTTON_C.Bit0=0;
   \   00000000                      REQUIRE ?Register_R14_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8E0               BLD     R14, 0
     79          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_C

   \                                 In  segment CODE, align 2, keep-with-next
     80          void BUTTON_17_ON(void)
   \                     BUTTON_17_ON:
     81          {BUTTON_C.Bit1=0;
   \   00000000                      REQUIRE ?Register_R14_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8E1               BLD     R14, 1
     82          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_C

   \                                 In  segment CODE, align 2, keep-with-next
     83          void BUTTON_18_ON(void)
   \                     BUTTON_18_ON:
     84          {BUTTON_C.Bit2=0;
   \   00000000                      REQUIRE ?Register_R14_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8E2               BLD     R14, 2
     85          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_C

   \                                 In  segment CODE, align 2, keep-with-next
     86          void BUTTON_19_ON(void)
   \                     BUTTON_19_ON:
     87          {BUTTON_C.Bit3=0;
   \   00000000                      REQUIRE ?Register_R14_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8E3               BLD     R14, 3
     88          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_C

   \                                 In  segment CODE, align 2, keep-with-next
     89          void BUTTON_20_ON(void)
   \                     BUTTON_20_ON:
     90          {BUTTON_C.Bit4=0;
   \   00000000                      REQUIRE ?Register_R14_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8E4               BLD     R14, 4
     91          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_C

   \                                 In  segment CODE, align 2, keep-with-next
     92          void BUTTON_21_ON(void)
   \                     BUTTON_21_ON:
     93          {BUTTON_C.Bit5=0;
   \   00000000                      REQUIRE ?Register_R14_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8E5               BLD     R14, 5
     94          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_C

   \                                 In  segment CODE, align 2, keep-with-next
     95          void BUTTON_22_ON(void)
   \                     BUTTON_22_ON:
     96          {BUTTON_C.Bit6=0;
   \   00000000                      REQUIRE ?Register_R14_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8E6               BLD     R14, 6
     97          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_C

   \                                 In  segment CODE, align 2, keep-with-next
     98          void BUTTON_23_ON(void)
   \                     BUTTON_23_ON:
     99          {BUTTON_C.Bit7=0;
   \   00000000                      REQUIRE ?Register_R14_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8E7               BLD     R14, 7
    100          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_C
    101         

   \                                 In  segment CODE, align 2, keep-with-next
    102          void BUTTON_24_ON(void)
   \                     BUTTON_24_ON:
    103          {BUTTON_D.Bit0=0;
   \   00000000                      REQUIRE ?Register_R15_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8F0               BLD     R15, 0
    104          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_D

   \                                 In  segment CODE, align 2, keep-with-next
    105          void BUTTON_25_ON(void)
   \                     BUTTON_25_ON:
    106          {BUTTON_D.Bit1=0;
   \   00000000                      REQUIRE ?Register_R15_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8F1               BLD     R15, 1
    107          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_D

   \                                 In  segment CODE, align 2, keep-with-next
    108          void BUTTON_26_ON(void)
   \                     BUTTON_26_ON:
    109          {BUTTON_D.Bit2=0;
   \   00000000                      REQUIRE ?Register_R15_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8F2               BLD     R15, 2
    110          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_D

   \                                 In  segment CODE, align 2, keep-with-next
    111          void BUTTON_27_ON(void)
   \                     BUTTON_27_ON:
    112          {BUTTON_D.Bit3=0;
   \   00000000                      REQUIRE ?Register_R15_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8F3               BLD     R15, 3
    113          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_D

   \                                 In  segment CODE, align 2, keep-with-next
    114          void BUTTON_28_ON(void)
   \                     BUTTON_28_ON:
    115          {BUTTON_D.Bit4=0;
   \   00000000                      REQUIRE ?Register_R15_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8F4               BLD     R15, 4
    116          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_D

   \                                 In  segment CODE, align 2, keep-with-next
    117          void BUTTON_29_ON(void)
   \                     BUTTON_29_ON:
    118          {BUTTON_D.Bit5=0;
   \   00000000                      REQUIRE ?Register_R15_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8F5               BLD     R15, 5
    119          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_D

   \                                 In  segment CODE, align 2, keep-with-next
    120          void BUTTON_30_ON(void)
   \                     BUTTON_30_ON:
    121          {BUTTON_D.Bit6=0;
   \   00000000                      REQUIRE ?Register_R15_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8F6               BLD     R15, 6
    122          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_D

   \                                 In  segment CODE, align 2, keep-with-next
    123          void BUTTON_31_ON(void)
   \                     BUTTON_31_ON:
    124          {BUTTON_D.Bit7=0;
   \   00000000                      REQUIRE ?Register_R15_is_global_regvar
   \   00000000   94E8               CLT
   \   00000002   F8F7               BLD     R15, 7
    125          }
   \   00000004   9508               RET
   \   00000006                      REQUIRE BUTTON_D
    126         

   \                                 In  segment CODE, align 2, keep-with-next
    127          void main(void)
   \                     main:
    128          {
   \   00000000                      REQUIRE ?Register_R12_is_global_regvar
   \   00000000                      REQUIRE ?Register_R13_is_global_regvar
   \   00000000                      REQUIRE ?Register_R14_is_global_regvar
   \   00000000                      REQUIRE ?Register_R15_is_global_regvar
    129          while(1)
    130            {
    131            if (BUTTON_A.Bit0) BUTTON_0_ON();
   \                     ??main_0:
   \   00000000   FAC0               BST     R12, 0
   \   00000002   F40E               BRTC    ??main_1
   \   00000004   ....               RCALL   BUTTON_0_ON
    132            if (BUTTON_A.Bit1) BUTTON_1_ON();
   \                     ??main_1:
   \   00000006   FAC1               BST     R12, 1
   \   00000008   F40E               BRTC    ??main_2
   \   0000000A   ....               RCALL   BUTTON_1_ON
    133            if (BUTTON_A.Bit2) BUTTON_2_ON();
   \                     ??main_2:
   \   0000000C   FAC2               BST     R12, 2
   \   0000000E   F40E               BRTC    ??main_3
   \   00000010   ....               RCALL   BUTTON_2_ON
    134            if (BUTTON_A.Bit3) BUTTON_3_ON();
   \                     ??main_3:
   \   00000012   FAC3               BST     R12, 3
   \   00000014   F40E               BRTC    ??main_4
   \   00000016   ....               RCALL   BUTTON_3_ON
    135            if (BUTTON_A.Bit4) BUTTON_4_ON();
   \                     ??main_4:
   \   00000018   FAC4               BST     R12, 4
   \   0000001A   F40E               BRTC    ??main_5
   \   0000001C   ....               RCALL   BUTTON_4_ON
    136            if (BUTTON_A.Bit5) BUTTON_5_ON();
   \                     ??main_5:
   \   0000001E   FAC5               BST     R12, 5
   \   00000020   F40E               BRTC    ??main_6
   \   00000022   ....               RCALL   BUTTON_5_ON
    137            if (BUTTON_A.Bit6) BUTTON_6_ON();
   \                     ??main_6:
   \   00000024   FAC6               BST     R12, 6
   \   00000026   F40E               BRTC    ??main_7
   \   00000028   ....               RCALL   BUTTON_6_ON
    138            if (BUTTON_A.Bit7) BUTTON_7_ON();
   \                     ??main_7:
   \   0000002A   FAC7               BST     R12, 7
   \   0000002C   F40E               BRTC    ??main_8
   \   0000002E   ....               RCALL   BUTTON_7_ON
    139         
    140            if (BUTTON_B.Bit0) BUTTON_8_ON();
   \                     ??main_8:
   \   00000030   FAD0               BST     R13, 0
   \   00000032   F40E               BRTC    ??main_9
   \   00000034   ....               RCALL   BUTTON_8_ON
    141            if (BUTTON_B.Bit1) BUTTON_9_ON();
   \                     ??main_9:
   \   00000036   FAD1               BST     R13, 1
   \   00000038   F40E               BRTC    ??main_10
   \   0000003A   ....               RCALL   BUTTON_9_ON
    142            if (BUTTON_B.Bit2) BUTTON_10_ON();
   \                     ??main_10:
   \   0000003C   FAD2               BST     R13, 2
   \   0000003E   F40E               BRTC    ??main_11
   \   00000040   ....               RCALL   BUTTON_10_ON
    143            if (BUTTON_B.Bit3) BUTTON_11_ON();
   \                     ??main_11:
   \   00000042   FAD3               BST     R13, 3
   \   00000044   F40E               BRTC    ??main_12
   \   00000046   ....               RCALL   BUTTON_11_ON
    144            if (BUTTON_B.Bit4) BUTTON_12_ON();
   \                     ??main_12:
   \   00000048   FAD4               BST     R13, 4
   \   0000004A   F40E               BRTC    ??main_13
   \   0000004C   ....               RCALL   BUTTON_12_ON
    145            if (BUTTON_B.Bit5) BUTTON_13_ON();
   \                     ??main_13:
   \   0000004E   FAD5               BST     R13, 5
   \   00000050   F40E               BRTC    ??main_14
   \   00000052   ....               RCALL   BUTTON_13_ON
    146            if (BUTTON_B.Bit6) BUTTON_14_ON();
   \                     ??main_14:
   \   00000054   FAD6               BST     R13, 6
   \   00000056   F40E               BRTC    ??main_15
   \   00000058   ....               RCALL   BUTTON_14_ON
    147            if (BUTTON_B.Bit7) BUTTON_15_ON();
   \                     ??main_15:
   \   0000005A   FAD7               BST     R13, 7
   \   0000005C   F40E               BRTC    ??main_16
   \   0000005E   ....               RCALL   BUTTON_15_ON
    148         
    149            if (BUTTON_C.Bit0) BUTTON_16_ON();
   \                     ??main_16:
   \   00000060   FAE0               BST     R14, 0
   \   00000062   F40E               BRTC    ??main_17
   \   00000064   ....               RCALL   BUTTON_16_ON
    150            if (BUTTON_C.Bit1) BUTTON_17_ON();
   \                     ??main_17:
   \   00000066   FAE1               BST     R14, 1
   \   00000068   F40E               BRTC    ??main_18
   \   0000006A   ....               RCALL   BUTTON_17_ON
    151            if (BUTTON_C.Bit2) BUTTON_18_ON();
   \                     ??main_18:
   \   0000006C   FAE2               BST     R14, 2
   \   0000006E   F40E               BRTC    ??main_19
   \   00000070   ....               RCALL   BUTTON_18_ON
    152            if (BUTTON_C.Bit3) BUTTON_19_ON();
   \                     ??main_19:
   \   00000072   FAE3               BST     R14, 3
   \   00000074   F40E               BRTC    ??main_20
   \   00000076   ....               RCALL   BUTTON_19_ON
    153            if (BUTTON_C.Bit4) BUTTON_20_ON();
   \                     ??main_20:
   \   00000078   FAE4               BST     R14, 4
   \   0000007A   F40E               BRTC    ??main_21
   \   0000007C   ....               RCALL   BUTTON_20_ON
    154            if (BUTTON_C.Bit5) BUTTON_21_ON();
   \                     ??main_21:
   \   0000007E   FAE5               BST     R14, 5
   \   00000080   F40E               BRTC    ??main_22
   \   00000082   ....               RCALL   BUTTON_21_ON
    155            if (BUTTON_C.Bit6) BUTTON_22_ON();
   \                     ??main_22:
   \   00000084   FAE6               BST     R14, 6
   \   00000086   F40E               BRTC    ??main_23
   \   00000088   ....               RCALL   BUTTON_22_ON
    156            if (BUTTON_C.Bit7) BUTTON_23_ON();
   \                     ??main_23:
   \   0000008A   FAE7               BST     R14, 7
   \   0000008C   F40E               BRTC    ??main_24
   \   0000008E   ....               RCALL   BUTTON_23_ON
    157         
    158            if (BUTTON_D.Bit0) BUTTON_24_ON();
   \                     ??main_24:
   \   00000090   FAF0               BST     R15, 0
   \   00000092   F40E               BRTC    ??main_25
   \   00000094   ....               RCALL   BUTTON_24_ON
    159            if (BUTTON_D.Bit1) BUTTON_25_ON();
   \                     ??main_25:
   \   00000096   FAF1               BST     R15, 1
   \   00000098   F40E               BRTC    ??main_26
   \   0000009A   ....               RCALL   BUTTON_25_ON
    160            if (BUTTON_D.Bit2) BUTTON_26_ON();
   \                     ??main_26:
   \   0000009C   FAF2               BST     R15, 2
   \   0000009E   F40E               BRTC    ??main_27
   \   000000A0   ....               RCALL   BUTTON_26_ON
    161            if (BUTTON_D.Bit3) BUTTON_27_ON();
   \                     ??main_27:
   \   000000A2   FAF3               BST     R15, 3
   \   000000A4   F40E               BRTC    ??main_28
   \   000000A6   ....               RCALL   BUTTON_27_ON
    162            if (BUTTON_D.Bit4) BUTTON_28_ON();
   \                     ??main_28:
   \   000000A8   FAF4               BST     R15, 4
   \   000000AA   F40E               BRTC    ??main_29
   \   000000AC   ....               RCALL   BUTTON_28_ON
    163            if (BUTTON_D.Bit5) BUTTON_29_ON();
   \                     ??main_29:
   \   000000AE   FAF5               BST     R15, 5
   \   000000B0   F40E               BRTC    ??main_30
   \   000000B2   ....               RCALL   BUTTON_29_ON
    164            if (BUTTON_D.Bit6) BUTTON_30_ON();
   \                     ??main_30:
   \   000000B4   FAF6               BST     R15, 6
   \   000000B6   F40E               BRTC    ??main_31
   \   000000B8   ....               RCALL   BUTTON_30_ON
    165            if (BUTTON_D.Bit7) BUTTON_31_ON();
   \                     ??main_31:
   \   000000BA   FAF7               BST     R15, 7
   \   000000BC   F00E               BRTS    $+2+2
   \   000000BE   CFA0               RJMP    ??main_0
   \   000000C0   ....               RCALL   BUTTON_31_ON
   \   000000C2   CF9E               RJMP    ??main_0
   \   000000C4                      REQUIRE BUTTON_A
   \   000000C4                      REQUIRE BUTTON_B
   \   000000C4                      REQUIRE BUTTON_C
   \   000000C4                      REQUIRE BUTTON_D
    166         
    167            }
    168          }

   Maximum stack usage in bytes:

     Function          CSTACK RSTACK
     --------          ------ ------
     BUTTON_0_ON           0      2
     BUTTON_10_ON          0      2
     BUTTON_11_ON          0      2
     BUTTON_12_ON          0      2
     BUTTON_13_ON          0      2
     BUTTON_14_ON          0      2
     BUTTON_15_ON          0      2
     BUTTON_16_ON          0      2
     BUTTON_17_ON          0      2
     BUTTON_18_ON          0      2
     BUTTON_19_ON          0      2
     BUTTON_1_ON           0      2
     BUTTON_20_ON          0      2
     BUTTON_21_ON          0      2
     BUTTON_22_ON          0      2
     BUTTON_23_ON          0      2
     BUTTON_24_ON          0      2
     BUTTON_25_ON          0      2
     BUTTON_26_ON          0      2
     BUTTON_27_ON          0      2
     BUTTON_28_ON          0      2
     BUTTON_29_ON          0      2
     BUTTON_2_ON           0      2
     BUTTON_30_ON          0      2
     BUTTON_31_ON          0      2
     BUTTON_3_ON           0      2
     BUTTON_4_ON           0      2
     BUTTON_5_ON           0      2
     BUTTON_6_ON           0      2
     BUTTON_7_ON           0      2
     BUTTON_8_ON           0      2
     BUTTON_9_ON           0      2
     main                  0      2
       -> BUTTON_0_ON      0      2
       -> BUTTON_1_ON      0      2
       -> BUTTON_2_ON      0      2
       -> BUTTON_3_ON      0      2
       -> BUTTON_4_ON      0      2
       -> BUTTON_5_ON      0      2
       -> BUTTON_6_ON      0      2
       -> BUTTON_7_ON      0      2
       -> BUTTON_8_ON      0      2
       -> BUTTON_9_ON      0      2
       -> BUTTON_10_ON     0      2
       -> BUTTON_11_ON     0      2
       -> BUTTON_12_ON     0      2
       -> BUTTON_13_ON     0      2
       -> BUTTON_14_ON     0      2
       -> BUTTON_15_ON     0      2
       -> BUTTON_16_ON     0      2
       -> BUTTON_17_ON     0      2
       -> BUTTON_18_ON     0      2
       -> BUTTON_19_ON     0      2
       -> BUTTON_20_ON     0      2
       -> BUTTON_21_ON     0      2
       -> BUTTON_22_ON     0      2
       -> BUTTON_23_ON     0      2
       -> BUTTON_24_ON     0      2
       -> BUTTON_25_ON     0      2
       -> BUTTON_26_ON     0      2
       -> BUTTON_27_ON     0      2
       -> BUTTON_28_ON     0      2
       -> BUTTON_29_ON     0      2
       -> BUTTON_30_ON     0      2
       -> BUTTON_31_ON     0      2


   Segment part sizes:

     Function/Label Bytes
     -------------- -----
     BUTTON_A          1
     BUTTON_B          1
     BUTTON_C          1
     BUTTON_D          1
     BUTTON_0_ON       6
     BUTTON_1_ON       6
     BUTTON_2_ON       6
     BUTTON_3_ON       6
     BUTTON_4_ON       6
     BUTTON_5_ON       6
     BUTTON_6_ON       6
     BUTTON_7_ON       6
     BUTTON_8_ON       6
     BUTTON_9_ON       6
     BUTTON_10_ON      6
     BUTTON_11_ON      6
     BUTTON_12_ON      6
     BUTTON_13_ON      6
     BUTTON_14_ON      6
     BUTTON_15_ON      6
     BUTTON_16_ON      6
     BUTTON_17_ON      6
     BUTTON_18_ON      6
     BUTTON_19_ON      6
     BUTTON_20_ON      6
     BUTTON_21_ON      6
     BUTTON_22_ON      6
     BUTTON_23_ON      6
     BUTTON_24_ON      6
     BUTTON_25_ON      6
     BUTTON_26_ON      6
     BUTTON_27_ON      6
     BUTTON_28_ON      6
     BUTTON_29_ON      6
     BUTTON_30_ON      6
     BUTTON_31_ON      6
     ??main_0        196


388 bytes in segment CODE
   4 bytes in segment REGVAR_AN

388 bytes of CODE memory
   0 bytes of DATA memory (+ 4 bytes shared)

Errors: none
Warnings: none
回帖提示: 反政府言论将被立即封锁ID 在按“提交”前,请自问一下:我这样表达会给举报吗,会给自己惹麻烦吗? 另外:尽量不要使用Mark、顶等没有意义的回复。不得大量使用大字体和彩色字。【本论坛不允许直接上传手机拍摄图片,浪费大家下载带宽和论坛服务器空间,请压缩后(图片小于1兆)才上传。压缩方法可以在微信里面发给自己(不要勾选“原图),然后下载,就能得到压缩后的图片】。另外,手机版只能上传图片,要上传附件需要切换到电脑版(不需要使用电脑,手机上切换到电脑版就行,页面底部)。
您需要登录后才可以回帖 登录 | 注册

本版积分规则

手机版|Archiver|amobbs.com 阿莫电子技术论坛 ( 粤ICP备2022115958号, 版权所有:东莞阿莫电子贸易商行 创办于2004年 (公安交互式论坛备案:44190002001997 ) )

GMT+8, 2024-4-29 12:20

© Since 2004 www.amobbs.com, 原www.ourdev.cn, 原www.ouravr.com

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