equll.c

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

     }
}

//*********************************************************
// read/write functions about MSP430
//
// Pxx.n : bit  format
// Pxx.B : byte format
// Pxx.W : word format
// Pxx.L : long format
//*********************************************************
                                     //***** get data *****
unsigned MSPgetWord(long addr) {return((unsigned)MSPgetData(addr));}
void     MSPgetProg(long addr,unsigned *p,unsigned nw)
                   {int i;for (i=0;i<nw;i++,addr+=2) *p++=*(unsigned *)((unsigned)addr);}
long     MSPgetData(long addr)
{    long d; unsigned s,type,bits;
     type=PLCgetType(addr);
     bits=((unsigned)(addr>>16))&0x07;
     s=(unsigned)addr;
     switch (type)
     {
     case dBITS: d=(long)(((*(unsigned *)s)&bitMask[bits])?1:0); break;
     case dBYTE: d=(long)  (*(unsigned char *)s);                break;
     case dWORD: d=(long)  (*(unsigned      *)s);                break;
     case dLONG: d=         *(long          *)s;                 break;
     default   : d=0L;                                           break;
     }
     return(d);
}
                              //***** put single data *****
void MSPputWord(long addr,unsigned d)
               {MSPputData(addr,(long)d);}
void MSPputData(long addr,long d)
{    unsigned x,s,type,bits;
     type=PLCgetType(addr);
     bits=((unsigned)(addr>>16))&0x07;
     s=(unsigned)addr;
     switch (type)
     {
     case dBYTE: *(unsigned char *)s=(unsigned char)d; break;
     case dWORD: *(unsigned      *)s=(unsigned     )d; break;
     case dLONG: *(long          *)s=(long         )d; break;
     case dBITS: x=*(unsigned *)s;
                 if (d) x|=  bitMask[bits];
                 else   x&=(~bitMask[bits]);
                 *(unsigned *)s=x;                     break;
     }
}
void MSPputProg(long addr,unsigned *p,unsigned nw)
{    unsigned *s,*d,i,n,a,err,len;
     a=(unsigned)addr;
     if (a>=0x1000 && a<0x1100)        //**FlashROM data
     {    for (i=0,s=(unsigned *)a,err=0; i<nw; i++,s++)
               if ((~(*s))&p[i]) err++;
          if (err)                     //**erase and then program
          {    s=(unsigned *)(a&0xff80); d=(unsigned *)RAM_TXtask;
               for (i=0; i<64; i++) *d++=*s++;
               s=p;           d=(unsigned *)(RAM_TXtask+(a&0xfe));
               for (i=0; i<nw; i++) *d++=*s++;
               len=64; s=(unsigned *)RAM_TXtask; d=(unsigned *)(a&0xff80);
               FlashProgram(d,s,0);    //**erase segment
          } else                       //**program directly
          {    len=nw; s=p; d=(unsigned *)a;
          }
     } else if (a>=0x4000)             //**FlashROM area
     {    return;
     } else                            //**RAM area
     {    for (i=0,s=(unsigned *)a; i<nw; i++,s++) *s=p[i];
          return;
     }
     for (i=0; i<len; i+=n,s+=n,d+=n)
     {    if ((n=len-i)>8) n=8;        //**program 8-word per cycle
          FlashProgram(d,s,n);
     }
}

//*********************************************************
// read/write functions about I/O port
//
// Xxx.n : bit  format
// Xxx.W : word format
// Xxx.L : long format
//*********************************************************
                              //***** get single data *****
unsigned IOPgetWord(long addr) {return((unsigned)IOPgetData(addr));}
void     IOPgetProg(long addr,unsigned *p,unsigned nw)
                   {int i; for (i=0;i<nw;i++,addr++) *p++=DSPgetIO((unsigned)addr);}
long     IOPgetData(long addr)
{    long d; unsigned type,bits;
     type=PLCgetType(addr);
     bits=((unsigned)(addr>>16))&0x0f;
     switch (type)
     {
     case dBITS: IOPgetProg(addr,(unsigned *)&d,1);
                 d=(long)((((unsigned)d)&bitMask[bits])?1:0);   break;
     case dLONG: IOPgetProg(addr,(unsigned *)&d,2);             break;
     default :   IOPgetProg(addr,(unsigned *)&d,1); d&=0xffffL; break;
     }
     return(d);
}
                                     //***** put data *****
void IOPputWord(long addr,unsigned d)
               {IOPputData(addr,(long)d);}
void IOPputProg(long addr,unsigned *p,unsigned nw)
               {int i; for (i=0;i<nw;i++,addr++) DSPputIO((unsigned)addr,*p++);}
void IOPputData(long addr,long d)
{    unsigned x,type,bits;
     type=PLCgetType(addr);
     bits=((unsigned)(addr>>16))&0x0f;
     switch (type)
     {
     case dBITS: IOPgetProg(addr,(unsigned *)&x,1);
                 if (d) x|=  bitMask[bits];
                 else   x&=(~bitMask[bits]);
                 IOPputProg(addr,(unsigned *)&x,1); break;
     case dLONG: IOPputProg(addr,(unsigned *)&d,2); break;
     default:    IOPputProg(addr,(unsigned *)&d,1); break;
     }
}

//*********************************************************
// read/write functions about Extened SRAM
//
// Mxx.n : bit  format
// Mxx.W : word format
// Mxx.L : long format
//*********************************************************
                                     //***** get data *****
unsigned MEMgetWord(long addr)
                   {return((unsigned)MEMgetData(addr));}
void     MEMgetProg(long addr,unsigned *p,unsigned nw)
                   {DSPgetRAM((unsigned)addr,p,nw);}
long     MEMgetData(long addr)
{    long d; unsigned type,bits;
     type=PLCgetType(addr);
     bits=((unsigned)(addr>>16))&0x0f;
     switch (type)
     {
     case dBITS: MEMgetProg(addr,(unsigned *)&d,1);
                 d=(long)((((unsigned)d)&bitMask[bits])?1:0);   break;
     case dLONG: MEMgetProg(addr,(unsigned *)&d,2);             break;
     default :   MEMgetProg(addr,(unsigned *)&d,1); d&=0xffffL; break;
     }
     return(d);
}
                                     //***** put data *****
void MEMputWord(long addr,unsigned d)
               {MEMputData(addr,(long)d);}
void MEMputProg(long addr,unsigned *p,unsigned nw)
               {DSPputRAM((unsigned)addr,p,nw);}
void MEMputData(long addr,long d)
{    unsigned x,type,bits;
     type=PLCgetType(addr);
     bits=((unsigned)(addr>>16))&0x0f;
     switch (type)
     {
     case dBITS: MEMgetProg(addr,(unsigned *)&x,1);
                 if (d) x|=  bitMask[bits];
                 else   x&=(~bitMask[bits]);
                 MEMputProg(addr,(unsigned *)&x,1); break;
     case dLONG: MEMputProg(addr,(unsigned *)&d,2); break;
     default:    MEMputProg(addr,(unsigned *)&d,1); break;
     }
}

//*********************************************************
// read/write functions about System SRAM
//
// Sxx.n : bit  format
// Sxx.W : word format
// Sxx.L : long format
//*********************************************************
                                     //***** get data *****
unsigned SYSgetWord(long addr)
                   {return((unsigned)SYSgetData(addr));}
void     SYSgetProg(long addr,unsigned *p,unsigned nw)
                   {DSPgetSYS((unsigned)addr,p,nw);}
long     SYSgetData(long addr)
{    long d; unsigned type,bits;
     type=PLCgetType(addr);
     bits=((unsigned)(addr>>16))&0x0f;
     switch (type)
     {
     case dBITS: SYSgetProg(addr,(unsigned *)&d,1);
                 d=(long)((((unsigned)d)&bitMask[bits])?1:0);   break;
     case dLONG: SYSgetProg(addr,(unsigned *)&d,2);             break;
     default   : SYSgetProg(addr,(unsigned *)&d,1); d&=0xffffL; break;
     }
     return(d);
}
                                     //***** put data *****
void SYSputWord(long addr,unsigned d)
               {SYSputData(addr,(long)d);}
void SYSputProg(long addr,unsigned *p,unsigned nw)
               {DSPputSYS((unsigned)addr,p,nw);}
void SYSputData(long addr,long d)
{    unsigned x,type,bits;
     type=PLCgetType(addr);
     bits=((unsigned)(addr>>16))&0x0f;
     switch (type)
     {
     case dBITS: SYSgetProg(addr,(unsigned *)&x,1);
                 if (d) x|=  bitMask[bits];
                 else   x&=(~bitMask[bits]);
                 SYSputProg(addr,(unsigned *)&x,1); break;
     case dLONG: SYSputProg(addr,(unsigned *)&d,2); break;
     default:    SYSputProg(addr,(unsigned *)&d,1); break;
    }
}

//*********************************************************
// read/write functions about DRAM
//
// Dxx.W : word format only
//*********************************************************
                                     //***** get data *****
long     RAMgetData(long addr)
                   {return((long)RAMgetWord(addr));}
void     RAMgetProg(long addr,unsigned *p,unsigned len)
                   {int i; for(i=0;i<len;i++,addr++) *p++=RAMgetWord(addr);}
unsigned RAMgetWord(long addr)
{    unsigned H,L;
     H=((unsigned)(addr>>16))&0xff;
     L= (unsigned) addr;
     return(getDRAM(H,L));
}
                                     //***** put data *****
void RAMputData(long addr,long d)
               {RAMputWord(addr,(unsigned)d);}
void RAMputProg(long addr,unsigned *p,unsigned len)
               {int i; for(i=0;i<len;i++,addr++) RAMputWord(addr,*p++);}
void RAMputWord(long addr,unsigned d)
{    unsigned H,L;
     H=((unsigned)(addr>>16))&0xff;
     L= (unsigned) addr;
     putDRAM(H,L,d);
}

//*********************************************************
// read/write functions about FlashROM
//
// Fxx.W : word format only
//*********************************************************
                       //***** get data from FlashROM *****
unsigned ROMgetWord(long addr)
                   {return((unsigned)ROMgetData(addr));}
long     ROMgetData(long addr)         //**word only
                   {long d; ROMgetProg(addr,(unsigned *)&d,1); return(d&0xffffL);}
void     ROMgetProg(long addr,unsigned *dat,unsigned nw)
{    unsigned H,L;
     H=((unsigned)(addr>>16))&0x7;
     L= (unsigned) addr;
     ROMgetBytes(H,L,(unsigned char *)dat,nw*2);
}
                         //***** put data to FlashROM *****
void ROMputWord(long addr,unsigned d)
               {ROMputData(addr,(long)d);}
void ROMputData(long addr,long d)  //**word only
               {ROMputProg(addr,(unsigned *)&d,1);}
void ROMputProg(long addr,unsigned *dat,unsigned nw)
{    unsigned H,L,n,k;
     H=((unsigned)(addr>>16))&0x7;
     L= (unsigned) addr;
     n=nw*2; k=0x100-(L&0x0ff);
     if (n>k)                          //**over [256B] boundary
     {    ROMputBytes(H,L,   (unsigned char *)dat,     k); msDelay(2);
          ROMputBytes(H,L+k,((unsigned char *)dat)+k,n-k);
     } else                            //**normal condition
          ROMputBytes(H,L,(unsigned char *)dat,n);
     msDelay(2);
}

//*********************************************************
// read/write functions about DSP and fiber network
//
// RAxx.W : word format only
//*********************************************************
                            //***** get data from DSP *****
unsigned DSPgetWord(long addr)
                   {return((unsigned)ROMgetData(addr));}
long     DSPgetData(long addr)         //**word only
                   {long d; DSPgetProg(addr,(unsigned *)&d,1); return(d&0xffffL);}
void     DSPgetProg(long addr,unsigned *dat,unsigned nw)
{    unsigned H,L;
     H=((unsigned)(addr>>16))&0x1f;
     L= (unsigned) addr;
     NETgetWords(H,L,dat,nw);
}
                              //***** put data to DSP *****
void DSPputWord(long addr,unsigned d)
               {DSPputData(addr,(long)d);}
void DSPputData(long addr,long d)  //**word only
               {DSPputProg(addr,(unsigned *)&d,1);}
void DSPputProg(long addr,unsigned *dat,unsigned nw)
{    unsigned H,L,n,k;
     H=((unsigned)(addr>>16))&0x7;
     L= (unsigned) addr;
     NETputWords(H,L,dat,nw);
}

//*********************************************************
// read/write functions about CNC program
//
// #xx.n : bit  format
// #xx.W : word format
// #xx.L : long format
//*********************************************************


//*********************************************************
// read/write functions about PLC program
//
// xx    : word format only
//*********************************************************