equll.c

非常重要的嵌入式单片机开发语言 是美国德州仪器的MSP430系列的系统语言

          case nGREAT_EQUAL+CHR : r1.c=(r2.c>=r1.c)?255:0; break;
          case nGREAT_EQUAL+INT : r1.c=(r2.i>=r1.i)?255:0; break;
          case nGREAT_EQUAL+LNG : r1.c=(r2.l>=r1.l)?255:0; break;
                                   //***** less equal *****
          case nLESS_EQUAL+BIT : r1.c=(r2.c<=r1.c)?255:0; break;
          case nLESS_EQUAL+CHR : r1.c=(r2.c<=r1.c)?255:0; break;
          case nLESS_EQUAL+INT : r1.c=(r2.i<=r1.i)?255:0; break;
          case nLESS_EQUAL+LNG : r1.c=(r2.l<=r1.l)?255:0; break;
                                        //***** equal *****
          case nEQUAL+BIT : r1.c=(r2.c==r1.c)?255:0; break;
          case nEQUAL+CHR : r1.c=(r2.c==r1.c)?255:0; break;
          case nEQUAL+INT : r1.c=(r2.i==r1.i)?255:0; break;
          case nEQUAL+LNG : r1.c=(r2.l==r1.l)?255:0; break;
                                    //***** not equal *****
          case nNOT_EQUAL+BIT :                          break;
          case nNOT_EQUAL+CHR : r1.c=(r2.c!=r1.c)?255:0; break;
          case nNOT_EQUAL+INT : r1.c=(r2.i!=r1.i)?255:0; break;
          case nNOT_EQUAL+LNG : r1.c=(r2.l!=r1.l)?255:0; break;
                              //***** logic operation *****
          case nAND_LOGIC : r1.c=(r1.c&&r2.c)?255:0; break;
          case  nOR_LOGIC : r1.c=(r1.c||r2.c)?255:0; break;
          case nNOT_LOGIC : r1.c=(r1.c)?0:255;       break;
                                      //***** minimum *****
          case nMIN+BIT : r1.c=(r1.c<r2.c)?r1.c:r2.c; break;
          case nMIN+CHR : r1.c=(r1.c<r2.c)?r1.c:r2.c; break;
          case nMIN+INT : r1.i=(r1.i<r2.i)?r1.i:r2.i; break;
          case nMIN+LNG : r1.l=(r1.l<r2.l)?r1.l:r2.l; break;
                                      //***** maximum *****
          case nMAX+BIT : r1.c=(r1.c>r2.c)?r1.c:r2.c; break;
          case nMAX+CHR : r1.c=(r1.c>r2.c)?r1.c:r2.c; break;
          case nMAX+INT : r1.i=(r1.i>r2.i)?r1.i:r2.i; break;
          case nMAX+LNG : r1.l=(r1.l>r2.l)?r1.l:r2.l; break;
                                     //***** absolute *****
          case nABS+BIT : r1.c=(r1.c)?0:255;             break;
          case nABS+CHR : r1.c=(r1.c<128)?r1.c:256-r1.c; break;
          case nABS+INT : r1.i=(r1.i>=0)?r1.i:-r1.i;     break;
          case nABS+LNG : r1.l=(r1.l>=0L)?r1.l:-r1.l;    break;
                                 //***** swap bitwise *****
          case nSWAP+BIT : break;
          case nSWAP+CHR : break;
          case nSWAP+INT : break;
          case nSWAP+LNG : break;
                                //***** binary to BCD *****
          case nBCD+BIT  : break;
          case nBCD+CHR  : break;
          case nBCD+INT  : break;
          case nBCD+LNG  : break;
                                //***** BCD to binary *****
          case nBINARY+BIT : break;
          case nBINARY+CHR : break;
          case nBINARY+INT : break;
          case nBINARY+LNG : break;
                                       //***** parity *****
          case nPARITY+BIT : break;
          case nPARITY+CHR : break;
          case nPARITY+INT : break;
          case nPARITY+LNG : break;
                           //***** floating functions *****
//          case nACOS  : r1.f=(float) acos((double)r1.f); break;
//          case nASIN  : r1.f=(float) asin((double)r1.f); break;
//          case nATAN  : r1.f=(float) atan((double)r1.f); break;
//          case nATAN2 : r1.f=(float)atan2((double)r2.f,(double)r1.f); break;
//          case nCOSH  : r1.f=(float) cosh((double)r1.f); break;
//          case nCOS   : r1.f=(float)  cos((double)r1.f); break;
//          case nEXP   : r1.f=(float)  exp((double)r1.f); break;
//          case nLOG   : r1.f=(float)  log((double)r1.f); break;
//          case nLOG10 : r1.f=(float)log10((double)r1.f); break;
//          case nPOW10 : r1.f=(float)pow10((double)r1.f); break;
//          case nSIN   : r1.f=(float)  sin((double)r1.f); break;
//          case nSINH  : r1.f=(float) sinh((double)r1.f); break;
//          case nSQRT  : r1.f=(float) sqrt((double)r1.f); break;
//          case nTAN   : r1.f=(float)  tan((double)r1.f); break;
                             //***** table function *****
          case nTC    : r1.c=*(unsigned char *)(r1.i); break;
          case nTI    : r1.i=*(int           *)(r1.i); break;
          case nTL    : r1.l=*(long          *)(r1.i); break;

          case nTIME  : if (r1.i==0) r1.i= nINTR|0x8000;
                        else         r1.i=(nINTR-r1.i)&0x7fff;
                        break;
          case nRANDOM: rand=rand*16807; r1.i=rand;    break;

          default     : return;
          }
     }
}
                        //***** get byte from pointer *****
static unsigned char getByte(unsigned char *p)
{    return(*p);
}
                        //***** get word from pointer *****
static unsigned      getWord(unsigned char *p)
{    int i; unsigned char *s; unsigned d;
     for (i=0,s=(unsigned char *)&d; i<2; i++) *s++=*p++;
     return(d);
}
                        //***** get long from pointer *****
static long          getLong(unsigned char *p)
{    int i; unsigned char *s; long d;
     for (i=0,s=(unsigned char *)&d; i<4; i++) *s++=*p++;
     return(d);
}
                          //***** put byte to pointer *****
static void putByte(unsigned char *p, unsigned char c)
{    *p=c;
}
                          //***** put word to pointer *****
static void putWord(unsigned char *p, unsigned d)
{    int i; unsigned char *s;
     for (i=0,s=(unsigned char *)&d; i<2; i++) *p++=*s++;
}
                          //***** put long to pointer *****
static void putLong(unsigned char *p, long d)
{    int i; unsigned char *s;
     for (i=0,s=(unsigned char *)&d; i<4; i++) *p++=*s++;
}

//*********************************************************
// basic functions about PLC variable
//
// PLCgetMode(addr)   : get mode
// PLCgetType(addr)   : get type
// PLCgetK   (addr)   : get constant
// PLCgetNext(addr,n) : get n'th address
// PLCgetNode(addr)   : get node
// PLCgetAddr(addr)   : get address
//
// variable format (32-bit)
//   [1][type:2][k:29]   : constant
//   'D'[addr:24]        : DRAM     address, word only
//   'F'[addr:24]        : FlashROM address, word only
//   'X'[type:8][addr:16]: I/O      address
//   'M'[type:8][addr:16]: extRAM   address
//   'S'[type:8][addr:16]: sysRAM   address
//   'R'[node:8][addr:16]: DSP#n    address, word only
//   'P'[type:8][addr:16]: MSP430   address
//   'T'[type:8][addr:16]: MSP430   pointer
//   '#'[type:8][addr:16]: CNC      address
//*********************************************************
static unsigned bitMask[]={0x0001,0x0002,0x0004,0x0008,
                           0x0010,0x0020,0x0040,0x0080,
                           0x0100,0x0200,0x0400,0x0800,
                           0x1000,0x2000,0x4000,0x8000};
                     //***** get mode of PLC variable *****
unsigned char PLCgetMode(long addr)
{    unsigned char mode;
     mode=(unsigned char)(addr>>24);
     if (mode&0x80) mode=0x80;
     return(mode);
}
                     //***** get type of PLC variable *****
unsigned char PLCgetType(long addr)
{    unsigned char mode,type;
     mode=PLCgetMode(addr);
     type=((unsigned char)(addr>>16))&0x30;
     switch (mode)
     {
     case 0x80: type=((unsigned char)(addr>>25))&0x30; break;
     case dRAM: case dROM: case dDSP:      type=dWORD; break;
     }
     return(type);
}
                 //***** get constant of PLC variable *****
long PLCgetK(long addr)
{    unsigned char type;
     if (!(addr&0x80000000L)) return(0L);
     type=((unsigned char)(addr>>25))&0x30;
     switch (type)
     {
     case dBIT :           return(addr&0x00000001L);
     case dBYTE:           return(addr&0x000000ffL);
     }
     if (addr&0x10000000L) return(addr|0xf0000000L);
     else                  return(addr&0x0fffffffL);
}
                    //***** get next N of PLC address *****
long PLCgetNext(long addr,int n)
{    unsigned char mode,type;
     mode=PLCgetMode(addr);
     type=PLCgetType(addr);
     switch (mode)
     {
     case dROM: case 0x80:   //**byte-address for word-data only
          addr+=(n<<1);
          break;
     case dRAM:              //**word-address for word-data only
          addr+= n;
          break;
     case dMSP:              //**byte address
          if      (type==dLONG) addr+=(n<<2);
          else if (type==dWORD) addr+=(n<<1);
          else                  addr+= n;
          break;
     default :               //**word address
          if      (type==dLONG) addr+= (n<<1);
          else if (type==dWORD) addr+=  n;
          else                  addr+=((n+1)>>1);
          break;
     }
     return(addr);
}
                     //***** get node of PLC variable *****
int PLCgetNode(long addr)
{    unsigned char mode;
     mode=PLCgetMode(addr);
     if (mode!=dDSP)           return(0);
     return(((unsigned)(addr>>16))&0x1f);
}
                  //***** get address of PLC variable *****
long PLCgetAddr(long addr)
{    unsigned char mode;
     mode=PLCgetMode(addr);
     if      (mode==0x80) addr= addr    &0x01ffffffL;
     else if (mode==dRAM) addr=(addr<<1)&0x01ffffffL;
     else if (mode==dROM) addr= addr    &0x0007ffffL;
     else if (mode==dDSP) addr= addr    &0x001fffffL;
     else                 addr= addr    &0x0000ffffL;
     return(addr|0xc0000000L);
}

//*********************************************************
// basic read/write functions
//
// PLCgetWord() : get  single data in word   format
// PLCputWord() : put  single data in word   format
// PLCgetData() : get  single data in long   format
// PLCputData() : put  single data in long   format
// PLCgetProg() : get  array  data in word[] format
// PLCputProg() : put  array  data in word[] format
// PLCmovProg() : move array  data in word[] format
//*********************************************************
unsigned PLCgetWord(long addr)  {return((unsigned)PLCgetData(addr));}
void     PLCputWord(long addr,unsigned d){PLCputData(addr,(long)d);}
                          //***** get single PLC data *****
long PLCgetData(long addr)
{    long d; unsigned char mode;
     mode=PLCgetMode(addr);
     if (mode==dTAB) {addr=*(long *)((unsigned)addr); mode=PLCgetMode(addr);}
     if (mode==0x80)
     {    if      (addr&0x1ff00000L) {mode=dRAM; addr>>=1;}
          else if (addr&0x000f0000L) {mode=dROM;}
          else                       {mode=dMSP; addr|=0x200000L;}
     }
     switch (mode)
     {
     case dRAM : d=RAMgetData(addr); break;       //**DRAM
     case dROM : d=ROMgetData(addr); break;       //**FlashROM
     case dIOP : d=IOPgetData(addr); break;       //**MSP430
     case dMEM : d=MEMgetData(addr); break;       //**IOport
     case dSYS : d=SYSgetData(addr); break;       //**extRAM
     case dDSP : d=DSPgetData(addr); break;       //**sysRAM
     case dMSP : d=MSPgetData(addr); break;       //**netRAM
     default   : d=0L;               break;
     }
     return(d);
}
                          //***** put single PLC data *****
void PLCputData(long addr,long d)
{    unsigned char mode;
     mode=PLCgetMode(addr);
     if (mode==dTAB) {addr=*(long *)((unsigned)addr); mode=PLCgetMode(addr);}
     if (mode==0x80)
     {    if      (addr&0x1ff00000L) {mode=dRAM; addr>>=1;}
          else if (addr&0x000f0000L) {mode=dROM;}
          else                       {mode=dMSP; addr|=0x200000L;}
     }
     switch (mode)
     {
     case dRAM : RAMputData(addr,d); break;       //**DRAM
     case dROM : ROMputData(addr,d); break;       //**FlashROM
     case dIOP : IOPputData(addr,d); break;       //**MSP430
     case dMEM : MEMputData(addr,d); break;       //**IOport
     case dSYS : SYSputData(addr,d); break;       //**extRAM
     case dDSP : DSPputData(addr,d); break;       //**sysRAM
     case dMSP : MSPputData(addr,d); break;       //**netRAM
     }
}
                    //***** get word[] of  PLC program *****
void PLCgetProg(long addr,unsigned *p,unsigned nw)
{    unsigned char mode;
     mode=PLCgetMode(addr);
     if (mode==dTAB) {addr=*(long *)((unsigned)addr); mode=PLCgetMode(addr);}
     if (mode==0x80)
     {    if      (addr&0x1ff00000L) {mode=dRAM; addr>>=1;}
          else if (addr&0x000f0000L) {mode=dROM;}
          else                       {mode=dMSP; addr|=0x200000L;}
     }
     switch (mode)
     {
     case dRAM : RAMgetProg(addr,p,nw); break;    //**DRAM
     case dROM : ROMgetProg(addr,p,nw); break;    //**FlashROM
     case dIOP : IOPgetProg(addr,p,nw); break;    //**IOport
     case dMEM : MEMgetProg(addr,p,nw); break;    //**extRAM
     case dSYS : SYSgetProg(addr,p,nw); break;    //**sysRAM
     case dDSP : DSPgetProg(addr,p,nw); break;    //**DSP#n
     case dMSP : MSPgetProg(addr,p,nw);   break;    //**MSP430
     }
}
                    //***** put word[] of PLC program *****
void PLCputProg(long addr,unsigned *p,unsigned nw)
{    unsigned char mode;
     mode=PLCgetMode(addr);
     if (mode==dTAB) {addr=*(long *)((unsigned)addr); mode=PLCgetMode(addr);}
     if (mode==0x80)
     {    if      (addr&0x1ff00000L) {mode=dRAM; addr>>=1;}
          else if (addr&0x000f0000L) {mode=dROM;}
          else                       {mode=dMSP; addr|=0x200000L;}
     }
     switch (mode)
     {
     case dRAM : RAMputProg(addr,p,nw); break;    //**DRAM
     case dROM : ROMputProg(addr,p,nw); break;    //**FlashROM
     case dIOP : IOPputProg(addr,p,nw); break;    //**IOport
     case dMEM : MEMputProg(addr,p,nw); break;    //**extRAM
     case dSYS : SYSputProg(addr,p,nw); break;    //**sysRAM
     case dDSP : DSPputProg(addr,p,nw); break;    //**DSP#n
     case dMSP : MSPputProg(addr,p,nw);   break;    //**MSP430
     }
}
                   //***** move word[] of PLC program *****
void PLCmovProg(long s,long d,unsigned nw)
{    unsigned buf[16]; int i,n;
     for (i=0; i<nw; i+=n)
     {    if ((n=nw-i)>16) n=16;
          PLCgetProg(s,buf,n); s=PLCgetNext(s,n);
          PLCputProg(d,buf,n); d=PLCgetNext(d,n);