MD，highgear绝对是故意的，我都已经**过一次了

只看该作者 · 2009-4-16 10:05

如果要把计数器T0中16位数据传到int i;中，用C51的话，有什么简单高效的方法？

  i=TH0*256+TL0;

显然不好。编译出来（如下）比汇编复杂多了，C显然有更简洁的写法？

C:0x0003    AF8C     MOV      R7,TH0(0x8C)
C:0x0005    EF       MOV      A,R7
C:0x0006    FE       MOV      R6,A
C:0x0007    AD8A     MOV      R5,TL0(0x8A)
C:0x0009    7C00     MOV      R4,#0x00
C:0x000B    E4       CLR      A
C:0x000C    2D       ADD      A,R5
C:0x000D    F509     MOV      0x09,A
C:0x000F    EC       MOV      A,R4
C:0x0010    3E       ADDC     A,R6
C:0x0011    F508     MOV      0x08,A
    21: }

2万 · 2009-4-16 10:08

2万 · 2009-4-16 10:11

然后采用向变量传值的方式，估计这样最省代码，但带来的问题就是看起来麻烦。

1万 · 2009-4-16 10:21

((unsigned char *)i)[0]=TH0;
((unsigned char *)i)[1]=TL0;

只看该作者 · 2009-4-16 10:40

只看该作者 · 2009-4-16 10:49

    12:  x=(TH0<<8)+TL0;
    13:
C:0x0003    AF8C     MOV      R7,TH0(0x8C)
C:0x0005    EF       MOV      A,R7
C:0x0006    FE       MOV      R6,A
C:0x0007    AD8A     MOV      R5,TL0(0x8A)
C:0x0009    7C00     MOV      R4,#0x00
C:0x000B    E4       CLR      A
C:0x000C    2D       ADD      A,R5
C:0x000D    F509     MOV      0x09,A
C:0x000F    EC       MOV      A,R4
C:0x0010    3E       ADDC     A,R6
C:0x0011    F508     MOV      0x08,A
    14: }

只看该作者 · 2009-4-16 10:59

    12: ((unsigned char *)i)[0]=TH0;
C:0x0003    AA08     MOV      R2,0x08
C:0x0005    A909     MOV      R1,0x09
C:0x0007    7B00     MOV      R3,#0x00
C:0x0009    E58C     MOV      A,TH0(0x8C)
C:0x000B    120000   LCALL    C:0000
    13: ((unsigned char *)i)[1]=TL0;
    14:
C:0x000E    900001   MOV      DPTR,#0x0001
C:0x0011    E58A     MOV      A,TL0(0x8A)
C:0x0013    120000   LCALL    C:0000
    15: }

2万 · 2009-4-16 11:03

2万 · 2009-4-16 11:05

俺是先编译完，查反汇编，然后再修改成嵌汇编滴。。。把+-*/ 还有数据搬运，先编译，再反汇编修改成嵌汇编了

2万 · 2009-4-16 11:07

2万 · 2009-4-16 11:10

union {
      int i;
      struct {
             uchar   j;
             uchar   k;
             }
      }

然后，可以j=TH0 ; k=TL0;执行完后，就可以使用i了。

要注意大小端的问题，也可能是反过来给值的。

只看该作者 · 2009-4-16 11:11

俺总觉得C没那么差，用嵌入式汇编是迫不得已。

这么简单的常用数据传输，真的迫不得已了吗？

记得在哪里看过简单写法，一时记不起来了，找找。

1万 · 2009-4-16 11:12

void main(void)
{
     unsigned int i;
     ((unsigned char data *)i)[0]=TH0;
     ((unsigned char data *)i)[1]=TL0;
}

编译后的汇编代码：

    22: void main(void)
    23: {
    24:         unsigned int i;
    25:         ((unsigned char data *)i)[0]=TH0;
C:0x000F    A809     MOV      R0,0x09
C:0x0011    A68C     MOV      @R0,TH0(0x8C)
    26:         ((unsigned char data *)i)[1]=TL0;
C:0x0013    E8       MOV      A,R0
C:0x0014    04       INC      A
C:0x0015    F8       MOV      R0,A
C:0x0016    A68A     MOV      @R0,TL0(0x8A)
    27: }
C:0x0018    22       RET

2万 · 2009-4-16 11:12

也更难维护，基本等于不合理的做法。

所以个人认为绝不应该采用小黄的做法。

2万 · 2009-4-16 11:16

后面，俺不知道为什么RP这么差，keil莫名其妙出了很多灵异现象，挺晕的，干脆嵌汇编，这下总保险了。

只看该作者 · 2009-4-16 11:18

https://bbs.21ic.com/club/bbs/list.asp?boardid=11&t=3264388&tp=ANSI%20C%u4E2D%u5982%u4F55%u80FD%u5C06%u4E24%u4E2Achar%u62FC%u5408%u6210%u4E00%u4E2Ashort%20int%uFF1F%u4F7F%u7528%u6307%u9488%u53EF%u4EE5%u5417%uFF1F
相关链接:https://bbs.21ic.com/club/bbs/list.asp?boardid=11&t=3264388&tp=ANSI%20C%u4E2D%u5982%u4F55%u80FD%u5C06%u4E24%u4E2Achar%u62FC%u5408%u6210%u4E00%u4E2Ashort%20int%uFF1F%u4F7F%u7528%u6307%u9488%u53EF%u4EE5%u5417%uFF1F

1万 · 2009-4-16 11:21

unsigned int i;
void main(void)
{
((unsigned char *)&i)[0]=TH0;
((unsigned char *)&i)[1]=TL0;
}

这个汇编结果才是最爽的……我说怎么一直不对呢……

    21: void main(void)
    22: {
    23: ((unsigned char *)&i)[0]=TH0;
C:0x000F    858C08   MOV      i(0x08),TH0(0x8C)
    24: ((unsigned char *)&i)[1]=TL0;
C:0x0012    858A09   MOV      0x09,TL0(0x8A)
    25: }
C:0x0015    22       RET

2万 · 2009-4-16 11:24

#include <REG52.H>
#include <intrins.h>

#define uchar unsigned char
#define uint  unsigned int
#define ulong unsigned long

union Union_tow{                     //
uchar uc;
uint ui;
uchar mem[2];
}unBuf;

uint i;

void main(void)
{
    TR0=1;
    while(1)
    {
        TR0=0;
        unBuf.mem[0]=TH0;
        unBuf.mem[1]=TL0;
        *((unsigned char *)(&i))=TH0;
        *((unsigned char *)(&i) +1)=TL0;
        TR0=1;
    }
}

Keil生成的代码：（看，Keil还是蛮聪明的嘛~）
    18: void main(void)
    19: {
    20:         TR0=1;
C:0x0003    D28C     SETB     TR0(0x88.4)
    21:         while(1)
    22:         {
    23:                 TR0=0;
C:0x0005    C28C     CLR      TR0(0x88.4)
    24:                 unBuf.mem[0]=TH0;
C:0x0007    858C08   MOV      unBuf(0x08),TH0(0x8C)
    25:                 unBuf.mem[1]=TL0;
C:0x000A    858A09   MOV      0x09,TL0(0x8A)
    26:                 *((unsigned char *)(&i))=TH0;
C:0x000D    858C0A   MOV      i(0x0A),TH0(0x8C)
    27:                 *((unsigned char *)(&i) +1)=TL0;
C:0x0010    858A0B   MOV      0x0B,TL0(0x8A)
    28:                 TR0=1;
C:0x0013    D28C     SETB     TR0(0x88.4)
    29:         }
C:0x0015    80EE     SJMP     C:0005
C:0x0017    787F     MOV      R0,#0x7F
C:0x0019    E4       CLR      A
C:0x001A    F6       MOV      @R0,A
C:0x001B    D8FD     DJNZ     R0,C:001A
C:0x001D    75810B   MOV      SP(0x81),#0x0B
C:0x0020    020003   LJMP     main(C:0003)

注意：

读取定时器值时如果不能一次读出，则一定要先停掉定时器！

否则很容易临界数据错误！

1万 · 2009-4-16 11:26

只看该作者 · 2009-4-16 11:27

圈圈能不能给我讲讲为什么下面的写法可以：

int i;
i=TH0;  //  这里应该没有疑问。
(char)i=TH0;  //关键这里得到了简化。

    11: int i;
    12: i=TL0;
C:0x000F    AF8A     MOV      R7,TL0(0x8A)
    13: (char)i=TH0;
    14:
C:0x0011    AE8C     MOV      R6,TH0(0x8C)
    15: }

这样完全跟汇编一样简了。

(char)i=TH0;  //有什么理论可以？谢谢大家。

MD，highgear绝对是故意的，我都已经**过一次了

相关下载

相关帖子

i=TH0<<8+TL0;

或者是用结构+联合

直接对内存地址赋值

学习了！

2楼说的我试过 x=(TH0<<8)+TL0; 没得到化简。

圈圈4楼说的编译结果如下，没达到预期效果。如何解决？

结构+联合的办法就是对内存直接操作了

俺也遇到了，无刷电机控制，对速度要求特高

比较不喜欢看联合，整的n长一串东东

大致描述

谢谢9楼和楼上。

哦，看来没有自动识别变量地址，自己强制指定一下。

反汇编比结构+联合更罗嗦，更没有通用性

呵呵，老叶，俺开始也是和蛋蛋一样 指针弄的，

这已有讨论。

抱歉，俺搞错了，忘记取地址了，应该是这样的：

给你两种方法，结果完全一样：

读取定时器值时如果不能一次读出，则一定要先停掉定时器！

个人觉得用联合太麻烦，另外定义一个联合，直接用指针爽

谢谢圈圈，跟几位大侠学到一些方法。

终身成就奖章

坚毅之洋流

十世金身

技术领袖奖章

永恒之光奖章

技术导师奖章

七世轮回

突出贡献奖章

沉静之湖泊

技术高手奖章

呵呵，老叶，俺开始也是和蛋蛋一样指针弄的，