发新帖我要提问
123下一页
返回列表
打印

EMC单片机的宏定义学习手记（前辈们来拍拍砖）

[复制链接]
楼主: etual
手机看帖
扫描二维码
随时随地手机跟帖
21楼
zhaoyu2005| | 2007-10-13 09:29 | 只看该作者 回帖奖励 |倒序浏览

强！

俺短时间接触过EMC单片机，谈不熟练，但是会编简单的程序，实在佩服楼主

使用特权

评论回复 赏
22楼
myturkey| | 2007-10-13 10:36 | 只看该作者

看过就顶

如题,呵呵

使用特权

评论回复 赏
23楼
sch_l| | 2007-10-16 22:21 | 只看该作者

很精彩！做个记号，部分已经这样用了！

谢谢楼主！

使用特权

评论回复 赏
24楼
hq_y| | 2007-10-16 22:23 | 只看该作者

路过~~~~~~~~~~~~~~

乱顶一下

使用特权

评论回复 赏
25楼
szsfy| | 2007-10-16 22:27 | 只看该作者

学习ing!

使用特权

评论回复 赏
26楼
turlip8| | 2007-10-18 11:00 | 只看该作者

不懂装懂也来顶

使用特权

评论回复 赏
27楼
ttneil| | 2007-10-18 15:52 | 只看该作者

支持一下。宏定义的确很好用。

其实我觉得奇怪，为什么MACRO会翻译成宏呢？我记得我第一次看到宏是在word里面看到的，完全不明白它是什么意思。为什么不用一个更容易理解一点的词语呢？

使用特权

评论回复 赏
28楼
谈的元| | 2007-10-18 19:31 | 只看该作者

EMC的叫“巨集义定义”，而我们一般称之为宏定义

其实还是比较好理解的。楼主说的很好。

而汇编还有很多好的功能是可以被开发出来（节约很多编程时间）

没被搞编译器的软件朋友发掘

或是由于种种原因而没有那样做。

使用特权

评论回复 赏
29楼
hxtg| | 2007-10-25 09:52 | 只看该作者

调试麻烦

在调试的时候，有时候要知道那个REGISTER的值的话，那不就要一个一个的找了

使用特权

评论回复 赏
30楼
ayb_ice| | 2007-10-25 10:04 | 只看该作者

还是C好

使用特权

评论回复 赏
31楼
fengyeu| | 2007-10-28 22:35 | 只看该作者

风也过

风也过

使用特权

评论回复 赏
32楼
etual|  楼主 | 2007-10-29 00:35 | 只看该作者

感谢支持，嘿嘿～～

回29楼的朋友
“在调试的时候，有时候要知道那个REGISTER的值的话，那不就要一个一个的找了 ”

其实，不是有一个显示寄存器的宏了么?我们直接用就OK了，
例如我分配了一个 TEMP 的寄存器，现在要找它。
只需要在源程序加多一条：
ADDR_DISP      TEMP

那么编译之后，在output窗口就可以看到这个寄存器的地址了，很是方便。
知道TEMP的地址之后，那么TEMP前后的寄存器也知道了吧？
当然，硬要说不方便的话，那也没有办法了，hoho～～
TMP   EQU 0X10 没有任何指令比这个方便的。

当然，自动分配这东西有利也有弊，如果寄存器比较紧缺，需要对某个
寄存器复用的话，那么就变得非常郁闷了。

使用特权

评论回复 赏
33楼
dcp| | 2007-10-29 00:50 | 只看该作者

反正是要顶的

使用特权

评论回复 赏
34楼
hotpower| | 2007-10-29 01:10 | 只看该作者

俺也懂些~~~以前做的PIC的宏的效果和C几乎一样~~~

;For演示程序,宏和C对比示例~~~ 
 #include <p16f877.inc>
 #include <HotPower.inc>
 #include <HotMath.inc>
 #include <Hot16877.inc>P16F877函数库文件
  Main(Void); main(void){//主程序开始
    Var(i,0x20,TByte); unsigned char i;
    Var(j,0x30,TByte); unsigned char j;
    Var(k,0x40,TWord); unsigned int k;
    Var(t,0x48,TWord); unsigned int t;
    Var(m,0x50,TByte); unsigned char m;
    Var(n,0x60,TByte); unsigned char n;
    WordVal(t,0); t = 0;
    ByteVal(m,0); m = 0;
    ByteVal(n,0); n = 0;
    nop
    For_ByteVal(i,1,10); for(i = 1; i <= 10; i++){
      nop
      IncByte(m); m++;
      nop
      For_ByteVal(j,10,1); for(j = 10; j >= 1; j--){
        nop
        IFGT_ByteVal(n,0); if(n > 0){
          nop
          LoopFor_ByteVal; continue;
          nop
        ENDIFGT_ByteVal; }
        nop
        IncByte(n); n++;
        nop
      ENDFor_ByteVal; }   
      nop
      For_WordVal(k,1,10000); for(k = 1; k <= 10000; k++){
        nop
        IncByte(n); n++;
        IFEQ_ByteVal(n,128); if(n == 128){
          nop
          ExitFor_WordVal; break;
          nop
        ENDIFEQ_ByteVal; }
        nop
      ENDFor_WordVal; } 
      nop
      AddWordByte(t,m); t += m;
      nop
      AddWordByte(t,n); t += n;
      nop
    ENDFor_ByteVal; }
    nop
  MainEnd; }//主程序结束
 
;HPL--DOCASE(switch)演示程序,宏和C对比示例~~~ 
 #include <p16f877.inc>
 #include <HotPower.inc>
 #include <HotMath.inc>
 #include <Hot16877.inc>P16F877函数库文件
  Main(Void); main(){//主程序开始
    Var(i,0x20,TByte); unsigned char i;
    Var(j,0x30,TByte); unsigned char j;
    Var(k,0x40,TByte); unsigned char k;
    Var(m,0x50,TByte); unsigned char m;
    Var(n,0x60,TByte); unsigned char n;
    ByteVal(i,2); i = 2;
    ByteVal(j,3); j = 3;
    ByteVal(k,0); k = 0;
    DoCase(k); switch(k){
      nop;
      Case 10; case 10:
        nop; //HPL语言同Delphi等语言一样,不需要加break语句
      Case 8; case 8:
        nop
      ExecCase;//该语句为HPL语言特有的,其他语言中没有
;-----ExecCase执行CASE比较成立的语句--------------------
       nop
    ELSECase; default:
;-----ElseCase执行CASE比较不成立的语句------------------
      nop;
      IncByte(k); k++;
      nop
      IFEQ_ByteVal(k,6); if(k == 6){
        nop
        ExitCase; break;
        nop
      ENDIFEQ_ByteVal; }
      nop;
      LoopCase; continue;
      nop
    ENDCase; }
    nop
    DoCase(i); switch(i){
      Case 1; case 1:
        nop
        ExitCase; break;
      Case 2; case 2:
        nop
        DoCase(j); switch(j){
          Case 1; case 1:
            nop;
          Case 2; case 2:
            nop;
          Case 3; case 3:
            ByteVal(k,88); k = 88;
            nop
            IFEQ_ByteVal(k,88); if(k == 88){
              ByteVal(m,3); m = 3;
              nop
              DoCase(m); switch(m){
                Case 1; case 1:
                  nop
                Case 2; case 2:
                  nop
                Case 3; case 3:
                  ByteVal(n,0x99); n = 99;
                  nop;
                  IFEQ_ByteVal(n,88); if(n == 88){
                    nop
                  ELSEIFEQ_ByteVal; }else{
                    ByteVal(i,2); i = 2;
                    nop;
                    DoCase(i); switch(i){
                      Case 1; case 1:
                        nop
                      Case 2; case 2:
                        ByteVal(j,8); j = 8;
                        nop
                        IFLE_ByteVal(j,88); if(j <= 88){
                          nop
                        ELSEIFLE_ByteVal; }else{
                          ByteVal(j,3); j = 3;
                          nop
                          DoCase(j); switch(j){
                            Case 1; case 1:
                              nop;
                            Case 2; case 2:
                              nop
                            ELSECase; default:
                              nop;
                          ENDCase; }
                          nop
                          ByteVal(k,3); k = 3;
                          nop
                          DoCase(k); switch(k){
                            Case 1; case 1:
                              nop;
                            Case 2; case 2:
                              nop
                            ELSECase; default:
                              nop;
                          ENDCase; }
                          nop
                        ENDIFLE_ByteVal; }
                        nop
                      ELSECase; default:
                        nop
                    ENDCase; }
                    nop
                  ENDIFEQ_ByteVal; }
                  nop;
                ELSECase; default:
                  nop;
              ENDCase; }
              nop
            ELSEIFEQ_ByteVal; }else{
              nop
            ENDIFEQ_ByteVal; }
            nop
          ELSECase; }
            nop
        ENDCase; }
        nop
      Case 3; case 3:
        nop
      Case 4; case 4:
        ByteVal(j,8); j = 8;
        nop
        DoCase(j); switch(j){
          Case 1; case 1:
            nop;
          Case 2; case 2:
            nop
          ELSECase; default:
            nop;
        ENDCase; }
        nop;
        nop
      Case 5; case 5:
        nop
      ELSECase; default:
        ByteVal(j,1); j = 1;
        nop
        DoCase(j); switch(j){
          Case 1; case 1:
            nop;
          Case 2; case 2:
            nop
          ELSECase; default:
            nop;
        ENDCase; }
        nop;
    ENDCase; }
    nop
  MainEnd;}//主程序结束

;while演示程序,宏和C对比示例~~~ 
 #include <p16f877.inc>
 #include <HotPower.inc>
 #include <HotMath.inc>
 #include <Hot16877.inc>P16F877函数库文件
  Main(Void); main(void){//主程序开始
    Var(i,0x20,TByte); unsigned char i;
    Var(j,0x30,TByte); unsigned char j;
    Var(k,0x40,TByte); unsigned char k;
    Var(m,0x50,TByte); unsigned char m;
    Var(n,0x60,TByte); unsigned char n;
    ByteVal(i,10); i = 10;
    ByteVal(j,3); j = 3;
    ByteVal(k,8); k = 8;
    nop
    WhileET_Bit(PORTB,BIT7);
      nop
    EndWhileET_Bit;
    nop
    DnWhileET_Bit;
      nop
;      ExitDnWhileET_Bit;
      nop
    EndDnWhileET_Bit(PORTB,BIT7);
    nop
    DnWhileNT_Bit;
      nop
      ExitDnWhileNT_Bit;
      nop
    EndDnWhileNT_Bit(PORTB,BIT7);
    nop
    WhileEQ_ByteVal(i,10); while(i == 10){
      nop
      ByteVal(m,1); m = 1;
      nop;
      WhileNE_ByteVal(m,10); while(m != 10){
        nop;
        IncByte(m); m++;
        nop;
      ENDWhileNE_ByteVal; }
      nop;
      ByteVal(m,1); m = 1;
      nop;
      WhileLT_ByteVal(m,10); while(m < 10){
        nop;
        ExitWhileLT_ByteVal; break;
        nop
        IncByte(m); m++;
        nop;
      ENDWhileLT_ByteVal; }
      nop;
      ByteVal(m,18); m = 18;
      nop;
      WhileGT_ByteVal(m,10); while(m > 10){
        nop;
        IncByte(m); m++;
        nop
        LoopWhileGT_ByteVal; continue;
        nop;
      ENDWhileGT_ByteVal; }
      nop;
      ByteVal(m,1); m = 1;
      nop;
      WhileLE_ByteVal(m,10); while(m <= 10){
        nop;
        IncByte(m); m++;
        nop;
      ENDWhileLE_ByteVal; }
      nop;
      ByteVal(m,18); m = 18;
      nop;
      WhileGE_ByteVal(m,10); while(m >= 10){
        nop;
        IncByte(m); m++;
        nop;
      ENDWhileGE_ByteVal; }
      nop;
    ENDWhileEQ_ByteVal; }
    nop
  MainEnd; }//主程序结束
 
 
 
一．HPL语言跳转类

1.比较相等跳转类

IFEQ_ByteVal(Const Byte: Addr,Val Byte: val);

IFEQ_WordVal(Const Byte: Addr,Val Word: val);

IFEQ_HWordVal(Const Byte: Addr,Val HWord: val);

IFEQ_DWordVal(Const Byte: Addr,Val DWord: val);

ELSEIFEQ_ByteVal(Void);

ELSEIFEQ_WordVal(Void);

ELSEIFEQ_HwordVal(Void);

ELSEIFEQ_DwordVal(Void);

ENDIFEQ_ByteVal(Void);

ENDIFEQ_WordVal(Void);

ENDIFEQ_HwordVal(Void);

ENDIFEQ_DwordVal(Void);

 

2.比较不相等跳转类

IFNE_ByteVal(Const Byte: Addr,Val Byte: val);

IFNE_WordVal(Const Byte: Addr,Val Word: val);

IFNE_HWordVal(Const Byte: Addr,Val HWord: val);

IFNE_DWordVal(Const Byte: Addr,Val DWord: val);

ELSEIFNE_ByteVal(Void);

ELSEIFNE_WordVal(Void);

ELSEIFNE_HwordVal(Void);

ELSEIFNE_DwordVal(Void);

ENDIFNE_ByteVal(Void);

ENDIFNE_WordVal(Void);

ENDIFNE_HwordVal(Void);

ENDIFNE_DwordVal(Void);

 

3.比较小于相等跳转类

IFLE_ByteVal(Const Byte: Addr,Val Byte: val);

IFLE_WordVal(Const Byte: Addr,Val Word: val);

IFLE_HWordVal(Const Byte: Addr,Val HWord: val);

IFLE_DWordVal(Const Byte: Addr,Val DWord: val);

ELSEIFLE_ByteVal(Void);

ELSEIFLE_WordVal(Void);

ELSEIFLE_HwordVal(Void);

ELSEIFLE_DwordVal(Void);

ENDIFLE_ByteVal(Void);

ENDIFLE_WordVal(Void);

ENDIFLE_HwordVal(Void);

ENDIFLE_DwordVal(Void);

 

4.比较大于相等跳转类

IFGE_ByteVal(Const Byte: Addr,Val Byte: val);

IFGE_WordVal(Const Byte: Addr,Val Word: val);

IFGE_HWordVal(Const Byte: Addr,Val HWord: val);

IFGE_DWordVal(Const Byte: Addr,Val DWord: val);

ELSEIFGE_ByteVal(Void);

ELSEIFGE_WordVal(Void);

ELSEIFGE_HwordVal(Void);

ELSEIFGE_DwordVal(Void);

ENDIFGE_ByteVal(Void);

ENDIFGE_WordVal(Void);

ENDIFGE_HwordVal(Void);

ENDIFGE_DwordVal(Void);

 

5.比较小于跳转类

IFLT_ByteVal(Const Byte: Addr,Val Byte: val);

IFLT_WordVal(Const Byte: Addr,Val Word: val);

IFLT_HWordVal(Const Byte: Addr,Val HWord: val);

IFLT_DWordVal(Const Byte: Addr,Val DWord: val);

ELSEIFLT_ByteVal(Void);

ELSEIFLT_WordVal(Void);

ELSEIFLT_HwordVal(Void);

ELSEIFLT_DwordVal(Void);

ENDIFLT_ByteVal(Void);

ENDIFLT_WordVal(Void);

ENDIFLT_HwordVal(Void);

ENDIFLT_DwordVal(Void);

 

6.比较大于跳转类

IFGT_ByteVal(Const Byte: Addr,Val Byte: val);

IFGT_WordVal(Const Byte: Addr,Val Word: val);

IFGT_HWordVal(Const Byte: Addr,Val HWord: val);

IFGT_DWordVal(Const Byte: Addr,Val DWord: val);

ELSEIFGT_ByteVal(Void);

ELSEIFGT_WordVal(Void);

ELSEIFGT_HwordVal(Void);

ELSEIFGT_DwordVal(Void);

ENDIFGT_ByteVal(Void);

ENDIFGT_WordVal(Void);

ENDIFGT_HwordVal(Void);

ENDIFGT_DwordVal(Void);

 

7.CASE散转类(Switch类)

CASE_ByteVal(Const Byte: Addr,Val Byte: val);

CASE_WordVal(Const Byte: Addr,Val Word: val);

CASE_HWordVal(Const Byte: Addr,Val HWord: val);

CASE_DWordVal(Const Byte: Addr,Val DWord: val);

 

8.FOR类

FOR_ByteVal(Const Byte:start, Const Byte: Addr,Val Byte: val);

FOR_WordVal(Const Byte:start, Const Word: Addr,Val Byte: val);

FOR_HWordVal(Const Byte:start, Const HWord: Addr,Val Byte: val);

FOR_DordVal(Const Byte:start, Const DWord: Addr,Val Byte: val);

 

9.While类

WHILE_ByteVal(Const Byte: Addr,Val Byte: val);

WHILE_WordVal(Const Byte: Addr,Val Word: val);

WHILE_HWordVal(Const Byte: Addr,Val HWord: val);

WHILE_DWordVal(Const Byte: Addr,Val DWord: val);

 

10.无条件类

Break_ByteVal(Void);

Break_WordVal(Void);

Break_HWordVal(Void);

Break_DWordVal(Void);

 

Contiue_ByteVal(Void);

Contiue_WordVal(Void);

Contiue_HWordVal(Void);

Contiue_DWordVal(Void);

 

Break;

Contiue;

Exit;

 

二. HPL语言位控制类

Bit(Const Byte: Addr,Const Bit:Bit,Val Bit:val);

SetBit(Const Byte: Addr,Const Bit:Bit);

ClrBit(Const Byte: Addr,Const Bit:Bit);

Bits(Const Byte: Addr,Const Bit:Bit,Val Bit:val);

ArrayBit(Const Byte: Addr,Const Bit:Bit,Val Bit:val);

PortBit(Val Bit: pin,Val Bit: onoff);

SetPortBit(Val Bit: pin);

ClrPortBit(Val Bit: pin);

 

三. HPL语言数组类

SetArrayByteVal(Const Array: Addr,Val Byte: val);

SetArrayWordVal(Const Array: Addr,Val Word: val);

SetArrayHWordVal(Const Array: Addr,Val HWord: val);

SetArrayDWordVal(Const Array: Addr,Val DWord: val);

 

SetArrayByteVar(Const Array: Addr,Const Byte: var);

SetArrayWordVar(Const Array: Addr,Const Word: var);

SetArrayHWordVar(Const Array: Addr,Const HWord: var);

SetArrayDWordVar(Const Array: Addr,Const DWord: var);

GetArrayByteVar(Const Array: Addr,Var Byte: var);

GetArrayWordVar(Const Array: Addr,Var Word: var);

GetArrayHWordVar(Const Array: Addr,Var HWord: var);

GetArrayDWordVar(Const Array: Addr,Var DWord: var);

 

SetArrayValByteVar(Const Array: Addr,Val Byte: val,Const Byte: var);

SetArrayValWordVar(Const Array: Addr,Val Byte: val,Const Word: var);

SetArrayValHWordVar(Const Array: Addr,Val Byte: val,Const HWord: var);

SetArrayValDWordVar(Const Array: Addr,Val Byte: val,Const DWord: var);

GetArrayValByteVar(Const Array: Addr,Val Byte: val,Var Byte: var);

GetArrayValWordVar(Const Array: Addr,Val Byte: val,Var Word: var);

GetArrayValHWordVar(Const Array: Addr,Val Byte: val,Var HWord: var);

GetArrayValDWordVar(Const Array: Addr,Val Byte: val,Var DWord: var);

 

 

四.HPL语言指针类

 

1.指针赋值宏指令(C++: int *ptr,i;  ptr = &i;)

Pointer(Var Void: ptr,Val Byte: val);无类型指针赋值宏指令

PByte(Var Byte: ptr,Val Byte: val);单字节指针赋值宏指令

PWord(Var Word: ptr,Val Byte: val);单字指针赋值宏指令

PHWord(Var HWord: ptr,Val Byte: val);三字节指针赋值宏指令

PDWord(Var DWord: ptr,Val Byte: val);双字指针赋值宏指令

  

2.指针+1宏指令(C++: char * ptr; ptr++;)

IncPointer(Var Void: ptr);无类型指针+1宏指令

IncPByte(Var Byte: ptr);单字节指针+1宏指令

IncPWord(Var Word: ptr);单字指针+1宏指令

IncPHWord(Var HWord: ptr);三字节指针+1宏指令

IncPDWord(Var DWord: ptr);双字指针+1宏指令

 

3.指针-1宏指令(C++: char * ptr; ptr--;)

DecPointer(Var Void: ptr);无类型指针-1宏指令

DecPByte(Var Byte: ptr);单字节指针-1宏指令

DecPWord(Var Word: ptr);单字指针-1宏指令

DecPHWord(Var HWord: ptr);三字节指针-1宏指令

DecPDWord(Var DWord: ptr);双字指针-1宏指令

 

4.指针变量赋值宏指令(C++: int* ptr; *ptr=0x1234;)

PByteVal(Var PByte: ptr,Val Byte: val);单字节指针变量赋值宏指令

PWordVal(Var PWord: ptr,Val Word: val);单字指针变量赋值宏指令

PHWordVal(Var PHWord: ptr,Val HWord: val);三字节指针变量赋值宏指令

PDWordVal(Var PDWord: ptr,Val DWord: val);双字指针变量赋值宏指令

 

3.变量+1宏指令(C++: int i; i++;)

IncByte(Var Byte: reg);单字节变量+1宏指令

IncWord(Var Word: reg);单字变量+1宏指令

IncHWord(Var HWord: reg);三字节变量+1宏指令

IncDWord(Var DWord: reg);双字变量+1宏指令

 

4.变量-1宏指令(C++: char i; i--;)

DecByte(Var Byte: reg);单字节变量-1宏指令

DecWord(Var Word: reg);单字变量-1宏指令

DecHWord(Var HWord: reg);三字节变量-1宏指令

DecDWord(Var DWord: reg);双字变量-1宏指令

 

5.变量赋值宏指令

(C++: long i; i=0x12345678;)

 DWordVal(i,0x12345678);

 movlw 0x78

 movwf i

 movlw 0x56

 movwf i+1

 movlw 0x34

 movwf i+2

 movlw 0x12

 movwf i+3

ByteVal(Var Byte: reg,Val Byte: val);单字节变量赋值宏指令

WordVal(Var Word: reg,Val Word: val);单字变量赋值宏指令

HWordVal(Var HWord: reg,Val HWord: val);三字节变量赋值宏指令

DWordVal(Var DWord: reg,Val DWord: val);双字变量赋值宏指令

 

8.指针变量传送宏指令(C++: int *i,j; *i=j;)

PByteVar(Var PByte: ptr,Const Byte; addr);单字节指针变量传送宏指令

PWordVar(Var PWord: ptr,Const Word: addr);单字指针变量传送宏指令

PHWordVar(Var PHWord: ptr,Const HWord: addr);三字节指针变量传送宏指令

PDWordVar(Var PDWord: ptr,Const DWord: addr);双字指针变量传送宏指令

 

9.双指针变量传送宏指令(C++: int *i,*j; *i=*j;)

PPByteVar(Var PByte: ptr,Const PByte; addr);单字节双指针变量传送宏指令

PPWordVar(Var PWord: ptr,Const PWord: addr);单字双指针变量传送宏指令

PPHWordVar(Var PHWord: ptr,Const PHWord: addr);三字节双指针变量传送宏指令

PPDWordVar(Var PDWord: ptr,Const PDWord: addr);双字双指针变量传送宏指令

 

10.变量传送宏指令

(C++: int i,j; i=j;)

 WordVar(i,j);  

ByteVar(Var Byte: reg,Const Byte: var);单字节变量传送宏指令

WordVar(Var Word: reg,Const Word: var)单字变量传送宏指令

HWordVar(Var HWord: reg,Const HWord: var);三字节变量传送宏指令

DWordVar(Var DWord: reg,Const DWord: var);双字变量传送宏指令

 

11.指针变量符号取反宏指令(C++: int * i; *i=-(*i);)

NegPByte(Var PByte: ptr);单字节指针变量符号取反宏指令

NegPWord(Var PWord: ptr);单字指针变量符号取反宏指令

 

12.变量符号取反宏指令(C++: int i; i=-i;)

NegByte(Var Byte: reg);单字节变量符号取反宏指令

NegWord(Var Word: reg);单字变量符号取反宏指令

 

13.变量与值宏指令(C++: int i; i&=0x1234;)

AndByteVal(Var Byte: reg,Val Byte: val);单字节变量与值宏指令

AndWordVal(Var Word: reg,Val Word: val);单字变量与值宏指令

AndHWordVal(Var HWord: reg,Val HWord: val);三字节变量与值宏指令

AndDWordVal(Var DWord: reg,Val DWord: val);双字变量与值宏指令

 

14.变量或值宏指令(C++: int i; i|=0x1234;)

OrByteVal(Var Byte: reg,Val Byte: val);单字节变量或值宏指令

OrWordVal(Var Word: reg,Val Word: val);单字变量或值宏指令

OrHWordVal(Var HWord: reg,Val HWord: val);三字节变量或值宏指令

OrDWordVal(Var DWord: reg,Val DWord: val);双字变量或值宏指令

 

15.变量异或宏指令(C++: int i; i^=0x1234;)

XorByteVal(Var Byte: reg,Val Byte: val);单字节变量异或宏指令

XorWordVal(Var Word: reg,Val Word: val);单字变量异或宏指令

XorHWordVal(Var HWord: reg,Val HWord: val)三字节变量异或宏指令

XorDWordVal(Var DWord: reg,Val DWord: val)双字变量异或宏指令

 

16.指针变量取反宏指令(C++: int *i; *i=!(*i);)

NotPByte(Var PByte: ptr);单字节指针变量取反宏指令

NotPWord(Var PWord: ptr);单字指针变量取反宏指令

NotPHWord(Var PHWord: ptr);三字节指针变量取反宏指令

NotPDWordVal(Var PDWord: ptr);双字指针变量取反宏指令

 

17.变量取反宏指令(C++: int i; i=!i;)

NotByte(Var Byte: reg);单字节变量取反宏指令

NotWord(Var Word: reg);单字变量取反宏指令

NotHWord(Var HWord: reg)三字节变量取反宏指令

NotDWordVal(Var DWord: reg)双字变量取反宏指令

 

六．HPL语言移动类

1.变量右移位宏指令(C++: int i; i>>=10;)

ShrByteVal(Var Byte: reg,Val Byte: val);单字节变量右移位宏指令

ShrWordVal(Var Word: reg,Val Byte: val);单字变量右移位宏指令

ShrHWordVal(Var HWord: reg,Val Byte: val);三字节变量右移位宏指令

ShrDWordVal(Var DWord: reg,Val Byte: val);双字变量右移位宏指令

 

2.变量左移位宏指令(C++: int i; i<<=10;)

ShlByteVal(Var Byte: reg,Val Byte: val);单字节变量左移位宏指令

ShlWordVal(Var Word: reg,Val Byte: val);单字变量左移位宏指令

ShlHWordVal(Var HWord: reg,Val Byte: val);三字节变量左移位宏指令

ShlDWordVal(Var DWord: reg,Val Byte: val);双字变量左移位宏指令

 

3.指针变量右移位宏指令(C++: int *i; *i<<=10;)

ShrPByteVal(Var PByte: reg,Val Byte: val);单字节指针变量右移位宏指令

ShrPWordVal(Var PWord: reg,Val Byte: val);单字指针变量右移位宏指令

ShrPHWordVal(Var PHWord: reg,Val Byte: val);三字节指针变量右移位宏指令

ShrPDWordVal(Var PDWord: reg,Val Byte: val);双字指针变量右移位宏指令

 

4.指针变量左移位宏指令(C++: int *i; *i>>=10;)

ShlPByteVal(Var PByte: reg,Val Byte: val);单字节指针变量左移位宏指令

ShlPWordVal(Var PWord: reg,Val Byte: val);单字指针变量左移位宏指令

ShlPHWordVal(Var PHWord: reg,Val Byte: val);三字节指针变量左移位宏指令

ShlPDWordVal(Var PDWord: reg,Val Byte: val);双字指针变量左移位宏指令

 

七．HPL语言数学类

22.无符号加法宏指令(C++: unsigned int i,j; i+=j;)

AddByteVar(Var Byte: addb,Const Byte: addj);单字节无符号加法宏指令 

AddWordVar(Const Word: addb,Const Word: addj);单字无符号加法宏指令 

 

22.无符号减法宏指令(C++: unsigned int i,j; i-=j;)

SubByteVar(Var Byte: subb,Const Byte: subj);单字节无符号减法宏指令 

SubWordVar(Const Word: subb,Const Word: subj);单字无符号减法宏指令 

 

24.乘法函数(C++: unsigned int i,j,k; k=i*j;)

MulByteVar(Const Byte: MULB,Const Byte: MULC,Var Word:MULJ);单字节变量乘法函数

MulWordVar(Const Word: MULB,Const Word: MULC,Var DWord:MULJ);单字变量乘法函数

MulHWordVar(Const HWord: MULB,Const HWord: MULC,Var DHWord:MULJ);三字节变量乘法函数

 

23.除法函数(C++: unsigned int i,j,k; k=i/j;)

DivByteVar(Const Byte: DIVB,Const Byte: DIVC,Var Word: DIVSY);单字节变量除法函数

DivWordVar(Const Word: DIVB,Const Word: DIVC,Var DWord: DIVSY);单字变量除法函数

DivHWordVar(Const HWord: DIVB,Const HWord: DIVC,Var DHWord: DIVSY);三字节变量除法函数

 

24.BCD码转换函数

BcdToBinWord(Word: bcd,Var HWord: bin);5位BCD转换为16位BIN码宏函数

WordBinToBcd(HWord: bin,Var Word: bcd);16位BIN转换为5位BCD码函数

 

八．HPL语言器件类

1.读写eeprom函数

Writeeeprom(Const Byte: ADDR,Const Byte: DATA);写入eeprom函数

Readeeprom(Const Byte: ADDR,Const Byte:Var Byte: DATA);读取eeprom函数

2. 读写Flash函数

WriteFlash(Const Word: ADDR,Const Word: DATA);写入eeprom函数

ReadFlash(Const Word: ADDR,Var Word: DATA);读取eeprom函数

 

使用特权

评论回复 赏
35楼
aihe| | 2007-10-29 11:18 | 只看该作者

好啊，正是想什么来什么

谢谢！

使用特权

评论回复 赏
36楼
凌晨依旧| | 2007-10-29 13:46 | 只看该作者

真的很好

一直想 汇编怎么能象C一样定义宏,现在终于知道了  看了一下编译器资料,原来三星的单片机汇编也可以使用宏的 

使用特权

评论回复 赏
37楼
hkap| | 2007-10-30 10:58 | 只看该作者

MESSAGE " "没见这个定义啊

使用特权

评论回复 赏
38楼
ldyeah| | 2007-10-30 11:29 | 只看该作者

不懂

使用特权

评论回复 赏
39楼
zhhp0113| | 2007-10-30 11:40 | 只看该作者

不错不错

等我哪天层次高了，再来学习

使用特权

评论回复 赏
40楼
etual|  楼主 | 2007-10-30 20:07 | 只看该作者

抛砖引玉了

哦，抛砖引玉了，引来了老农的资料
先收下学习了～～

另外回39楼 hkap 朋友。
MESSAGE 是一个宏，在 WICE 的说明书里面有的，翻翻
（说明书是买仿真器的时候配套的。）

使用特权

评论回复 赏
下一页 »
123下一页
返回列表
发新帖 我要提问
高级模式
B Color Image Link Quote Code 收费 Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则