demon.c

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

//*********************************************************
// demo #4 : 26P I/O testing
//
//                    designed by Pei-Chong Tang, Dec. 2005
// ********************************************************
#include <msp430x16x.h>
#include <signal.h>
                                //***** common memory *****
#define RAM_LEDon    (*((unsigned *)0x1100))
#define RAM_nMS      (*((unsigned *)0x1102))
#define RAM_nSEC     (*((unsigned *)0x1104))
#define RAM_nMIN     (*((unsigned *)0x1106))
#define RAM_FPGA     (*((unsigned *)0x1108))
#define RAM_user     (*((unsigned *)0x110a))
#define RAM_doloop   (*((unsigned *)0x110c))
#define RAM_doloopP  (*((unsigned *)0x110e))

//*********************************************************
// parameters for demo process
// ********************************************************
                                 //***** DEMO control *****
#define RAM_DEMO_sts  (*((unsigned char *)0x1140))
#define RAM_DEMO_sel  (*((unsigned char *)0x1141))
#define RAM_DEMO_p1   (*((unsigned      *)0x1142))
#define RAM_DEMO_p2   (*((unsigned      *)0x1144))
#define RAM_DEMO_p3   (*((unsigned      *)0x1146))
#define RAM_DEMO_p4   (*((unsigned      *)0x1148))
#define RAM_DEMO_p5   (*((unsigned      *)0x114A))
#define RAM_DEMO_p6   (*((unsigned      *)0x114C))
#define RAM_FPGA_sts  (*((unsigned char *)0x114F))

static void PGAstatus(void);
static void PGAputMEM(unsigned,unsigned,unsigned char *,int);
static void PGAgetMEM(unsigned,unsigned,unsigned char *,int);
static void PGAputRAM(unsigned,unsigned *,int);
static void PGAgetRAM(unsigned,unsigned *,int);
static void PGAputIO(unsigned,unsigned *,int);
static void PGAgetIO(unsigned,unsigned *,int);

//********************************************************
// functions about FPGA interface
//
// PGAputMEM() : put n-byte to   FPGA memory
// PGAgetMEM() : get n-byte from FPGA memory
// PGAputRAM() : put n-word to   internal RAM
// PGAgetRAM() : get n-word from internal RAM
// PGAputIO()  : put n-word to   FPGA I/O
// PGAgetIO()  : get n-word from FPGA I/O
// PGAputI2C() : put n-word to I2C register
//********************************************************
                            //***** basic SPI command *****
#define SPItx(x);   {U1TXBUF=x;}
#define SPIrx(x);   {x=U1RXBUF;}
#define csPGAon();  {P5OUT&=~0x01;}
#define csPGAoff(); {P5OUT|=0x01;}
static void SPIdelay() {int i;for(i=8;i;i--)_NOP();}
                   //***** get status of FPGA program *****
static void PGAstatus(void)
{    unsigned char x;
     csPGAon();
     x=0x00; SPItx(x); SPIdelay(); SPIrx(x); RAM_FPGA_sts=x;
     csPGAoff();
}
                    //***** put n-byte to FPGA memory *****
static void PGAputMEM(unsigned page,unsigned addr,unsigned char *dat,int len)
{    unsigned char x; int i;
     csPGAon();
     x=0x80+page; SPItx(x); SPIdelay();
     x=(addr>>8); SPItx(x); SPIdelay();
     x= addr;     SPItx(x); SPIdelay();
     for (i=0; i<len; i++) {x=*dat++; SPItx(x); SPIdelay();}
     csPGAoff();
}
                  //***** get n-byte from FPGA memory *****
static void PGAgetMEM(unsigned page,unsigned addr,unsigned char *dat,int len)
{    unsigned char x; int i;
     csPGAon();
     x=0x00+page; SPItx(x); SPIdelay();
     x=(addr>>8); SPItx(x); SPIdelay();
     x= addr;     SPItx(x); SPIdelay();
     for (i=0; i<len; i++)   {SPItx(0); SPIdelay(); SPIrx(x); *dat++=x;}
     csPGAoff();
}
                   //***** put n-word to internal RAM *****
static void PGAputRAM(unsigned addr,unsigned *dat,int len)
{    PGAputMEM(0x40,addr,(unsigned char *)dat,len*2);
}
                 //***** get n-word from internal RAM *****
static void PGAgetRAM(unsigned addr,unsigned *dat,int len)
{    PGAgetMEM(0x40,addr,(unsigned char *)dat,len*2);
}
                       //***** put n-word to FPGA I/O *****
static void PGAputIO(unsigned addr,unsigned *dat,int len)
{    PGAputMEM(0x60,addr,(unsigned char *)dat,len*2);
}
                     //***** get n-word from FPGA I/O *****
static void PGAgetIO(unsigned addr,unsigned *dat,int len)
{    PGAgetMEM(0x60,addr,(unsigned char *)dat,len*2);
}

//*********************************************************
// standard structure of DEMO process
//*********************************************************
static void key_process(void);
static void demo1(void);
                                 //***** DEMO initial *****
void DEMO_initial(void)
{    RAM_DEMO_sts=1; RAM_DEMO_sel=1;
     RAM_DEMO_p1=0xffff;           //06.6.20
	 //RAM_DEMO_p1=0x3fff;         //06.6.21
}
                                 //***** DEMO process *****
void DEMO_process(void)
{    static int init=1;
     if (init)                         //**initial condition
     {    init=0; DEMO_initial();
     }
     PGAstatus();                      //**check FPGA
     key_process();                    //**check RESET key
     if (RAM_DEMO_sts==0) return;      //**nop if stop
     switch (RAM_DEMO_sel)
     {
     case 1 : demo1();        break;   //**demo #1
     default: RAM_DEMO_sts=0; break;
     }
}
                              //***** check RESET key *****
static void key_process(void)
{    static unsigned t0=0,old=0,cnt=0; int key;
     if ((RAM_nMS-t0)<50)    return;
     t0=RAM_nMS;                       //**for every 50ms
     key=(RAM_FPGA_sts&0x1)?0:1;
key=0;
     if (key!=old) {old=key; return;}  //**debouncing
     if      (cnt>=10)      RAM_LEDon=16;
     else if (RAM_DEMO_sts) RAM_LEDon=(RAM_DEMO_sts&0x3)+16;
     else if (RAM_DEMO_sel) RAM_LEDon= RAM_DEMO_sel;
     if (key) {if (cnt<100) cnt++; return;}      //**key press
     if (cnt<2)            {cnt=0; return;}      //**key release
     if         (RAM_DEMO_sts>0)  RAM_DEMO_sts=99; //**stop  process
     else if    (cnt>10)          RAM_DEMO_sts=1;  //**start process
     else if ((++RAM_DEMO_sel)>8) RAM_DEMO_sel=1;  //**demo  select
     cnt=0;
}

//*********************************************************
// demo #1 : PCB test
//
// p1: map of test pins
// p2: map of open  circuit
// p3: map of short circuit
// p4: test result, 0=wait, 1=okay, 2=open, 3=short
//*********************************************************
static unsigned LED;
static unsigned tabOUT[]=
    {0x0001,0x0002,0x0004,0x0008,0x0010,0x0020,0x0040,0x0080,
    0x0100,0x0200,0x0400,0x0800,0x1000,0x2000,0x4000,0x8000,0x0000};    //06.6.20
         static unsigned tabIN[]=
//      {0x0001,0x0002,0x0004,0x0008,0x0010,0x0020,0x0040,0x0080,
 //      0x0100,0x0200,0x0400,0x0800,0x1000,0x2000,0x4000,0x8000};//original
     {0x5001,0x5002,0x5004,0x5008,0x5010,0x5020,0x5040,0x5080,
      0x5100,0x5200,0x5400,0x5800,0x7000,0xd000,0x7000,0xd000,0x5000};   //06.6.20
                                   //***** put test signals ******
static void PCB_put(int idx)
{    unsigned cmd,dat[7],sts[2]; int i;
//     if (idx>=0 && idx<16) cmd=~(1<<idx);
    // if (idx>=0 && idx<16) cmd=~tabOUT[idx];//06.6.20
      if (idx>=0 && idx<17) cmd=~tabOUT[idx];
     else                  cmd=0;
     dat[0]=0x00ff;
     dat[1]=cmd&0x00ff; dat[2]=(cmd>>8)&0x00ff; dat[3]=(cmd>>8)&0x00ff;
     dat[4]=0x00ff;
      dat[5]=0x00ff;
     dat[6]=LED;
     PGAputIO(0x11,dat,7);

}
                             //***** get test signals *****
static int PCB_get(int idx)
{    static unsigned nc,no; unsigned cmd,old,dat[2]; int i;
     for (i=0,old=0; i<100; i++)
     {
		  PGAgetIO(0x06,dat,1);             //**6=P1D0
          PGAgetIO(0x01,dat+1,1);           //**1=PXA
          dat[0]=~dat[0]; dat[1]=~dat[1];             //**inverse
          dat[0]=((dat[1]<<8)&0xff00)|(dat[0]&0x00ff);//**dat[0]=~input
          if (dat[0]==old) break;
          old=dat[0];
     }

RAM_DEMO_p5=dat[0];
RAM_DEMO_p6=idx;

     if        (idx<0)                           //**wait to test
     {    if (((dat[0]&(~0x5000))&RAM_DEMO_p1)>0) idx=0;//0.6.8.12
          //else idx=-1;
               RAM_DEMO_p4=0;
     //} else if (idx>=17)                         //**wait to off 06.6.20
      } else if (idx>=18)                         //**wait to off
     //{    if ((dat[0]&RAM_DEMO_p1)==0) idx=-1;
     {    if (((dat[0]&(~0x5000))&RAM_DEMO_p1)==0) idx=-1;
     //} else if (idx>=16)                         //**wait to finish 06.6.20
     } else if (idx>=17)                         //**wait to finish
     //{    if ((dat[0]&RAM_DEMO_p1)==0) idx=-1;
   {    if (((dat[0]&(~0x5000))&RAM_DEMO_p1)==0) idx=-1;
          else                                     idx=0;
          if (RAM_DEMO_p2==no && RAM_DEMO_p3==nc)
          {    if      (no>0)  RAM_DEMO_p4=2;
               else if (nc>0)  RAM_DEMO_p4=3;
               //else          { RAM_DEMO_p4=1; idx=17;} //06.6.20
                else          { RAM_DEMO_p4=1; idx=18;}
          }
          RAM_DEMO_p2=no; RAM_DEMO_p3=nc;
     } else
     {    if (idx==0) {no=0; nc=0;}
//          cmd=1<<idx; idx++;
          cmd=tabIN[idx]; idx++;
          if ((((~dat[0])&cmd)&RAM_DEMO_p1)>0) no|=cmd;
          if (((dat[0]&(~cmd))&RAM_DEMO_p1)>0) nc|=cmd;
	 }
	 return(idx);
}
                          //***** display test result *****

static void LED_display()
{	 static unsigned okay[2]={0xe7,0xd7};
     static unsigned wait[8]={0xef,0xdf,0xbf,0x7f,0x7f,0xbf,0xdf,0xef};
     unsigned i,n,dat[2];
     n=(RAM_nMS>>7)&0x7;
    switch (RAM_DEMO_p4)                        //**p4=test result
     {
     case 1 : dat[0]=okay[n&0x1]; break;         //**test OK
     case 2 : dat[0]=0xe8;        break;         //**something open
     case 3 : dat[0]=0xc8;        break;         //**something short
     default: dat[0]=wait[n];     break;         //**wait next PCB
     }
     LED=dat[0];
}

static void demo1(void)
{    static unsigned t0; static int idx;
     unsigned dat[10]; int i;
     switch (RAM_DEMO_sts)
     {
     case 1 :                //**start process
          for (i=0; i<9; i++) dat[i]=0xffff;
          PGAputIO(0x11,dat,9);                  //**all GPIO=input
          RAM_DEMO_p2=RAM_DEMO_p3=RAM_DEMO_p4=0;
          RAM_DEMO_sts++; idx=-1;     break;
     case 2 :                //**put PCB test signals
          if ((RAM_nMS-t0)<50 && idx==0) break;
          PCB_put(idx);
          RAM_DEMO_sts++; t0=RAM_nMS;    break;
     case 3 :                //**get PCB test signals
          if ((RAM_nMS-t0)<5)         break;     //**wait 10ms
          idx=PCB_get(idx);
          LED_display();                         //**LED display
          RAM_DEMO_sts--; t0=RAM_nMS; break;
     default:                //**stop process
          for (i=0; i<9; i++) dat[i]=0xffff;
          PGAputIO(0x11,dat,9);                  //**all GPIO=input
          RAM_DEMO_sts=0; break;
     }
}