C8051F121在天线测试系统中的应用源码

原创 2011年01月12日 19:10:00

MAIN.C

 

#include "stddef.h"

 ex_ void    Init_Config (void);

 EX_ ULONG     AZ_CP_COUNT ;
 EX_ ULONG     EL_CP_COUNT ;
 EX_ ULONG    RV_CP_COUNT ;
 EX_ ULONG    SD_CP_COUNT ;

UCHAR   UART_BUFFER[14]  = {0xff,0,0,0,0,0,0,0,0,0,0,0,0,0xfe};
UCHAR   UART_SOUT_BIT    = 15;
 
 

 


/*********************************************************************************** 
* 函数名称:delay; 

* 函数功能描述:定时器延时子函数; 
*               
* 输入参数:none; 

* 返回数据:none; 

* 注意:    none; 
************************************************************************************/ 

void delay(unsigned int time)
{
 while(time--);
}

/*********************************************************************************** 
* 函数名称:WatchDog; 

* 函数功能描述:UART_SOUT_BIT 
*               
* 输入参数:NONE; 

* 返回数据:none; 

* 注意:   none; 
************************************************************************************/ 
void WatchDog()
{
   DOG=~DOG;
   delay(200);
   DOG=~DOG;
    delay(200);
}

 

/*********************************************************************************** 
* 函数名称:UART_SBUF0(); 

* 函数功能描述:串口0发送数据; 
*               
* 输入参数:发送数据; 

* 返回数据:none; 

* 注意:   none; 
************************************************************************************/ 


void UART_SBUF0()
{
    uchar SFRPAGE_save = SFRPAGE;       // Save the current SFRPAGE
 ULONG pCOUNT=0;
 uchar pD=0;
 uchar i =0;
 uchar EndFlag=0xfe;
 char * pStr=UART_BUFFER;
    SFRPAGE=UART0_PAGE;

 /**************方位***************/


 if(UART_SOUT_BIT&0x01)
 {
  pCOUNT=AZ_CP_COUNT;
  
  UART_BUFFER[pD+1]=0;
  if(AZ_LIMIT_CW) //顺限位
   UART_BUFFER[pD+1]|=0x40;
  if(AZ_LIMIT_CC) //逆限位
   UART_BUFFER[pD+1]|=0x80;
  
  i=pCOUNT&0xff ;
  if(i>0xfd)
   {
    UART_BUFFER[pD+3]=0xff-i;
    UART_BUFFER[pD+1] |=0x10;
    }
    else
    UART_BUFFER[pD+3]=i;
  i=(pCOUNT>>8)&0xff ;
   if(i>0xfd)
   {
    UART_BUFFER[pD+2]=0xff-i;
    UART_BUFFER[pD+2]|=0x20;
    }
    else
    UART_BUFFER[pD+2]=i;

  UART_BUFFER[pD+1]|=((pCOUNT>>16)&0x0f);
  pD+=3;
 }


/**************府仰***************/
 if(UART_SOUT_BIT&0x02)
 {
  pCOUNT=EL_CP_COUNT;
  
  UART_BUFFER[pD+1]=0;
  if(EL_LIMIT_UP) //方位限位
   UART_BUFFER[pD+1]|=0x40;
     
  if(EL_LIMIT_DN) //方位限位
   UART_BUFFER[pD+1]|=0x80;

  i=pCOUNT&0xff ;
  if(i>0xfd)
   {
    UART_BUFFER[pD+3]=0xff-i;
    UART_BUFFER[pD+1] |=0x10;
    }
    else
    UART_BUFFER[pD+3]=i;
  i=(pCOUNT>>8)&0xff ;
   if(i>0xfd)
   {
    UART_BUFFER[pD+2]=0xff-i;
    UART_BUFFER[pD+2]|=0x20;
    }
    else
    UART_BUFFER[pD+2]=i;
 
  UART_BUFFER[pD+1]|=((pCOUNT>>16)&0x0f);
  pD+=3;
   }
/**************接收***************/
 if(UART_SOUT_BIT&0x04)
 {
  pCOUNT=RV_CP_COUNT;
  
  UART_BUFFER[pD+1]=0;
  if(RV_LIMIT_CW) //方位限位
   UART_BUFFER[pD+1]|=0x40;
    
  if(RV_LIMIT_CC) //方位限位
   UART_BUFFER[pD+1]|=0x80;


  i=pCOUNT&0xff ;
  if(i>0xfd)
   {
    UART_BUFFER[pD+3]=0xff-i;
    UART_BUFFER[pD+1] |=0x10;
    }
    else
    UART_BUFFER[pD+3]=i;
  i=(pCOUNT>>8)&0xff ;
   if(i>0xfd)
   {
    UART_BUFFER[pD+2]=0xff-i;
    UART_BUFFER[pD+2]|=0x20;
    }
    else
    UART_BUFFER[pD+2]=i;
 
  UART_BUFFER[pD+1]|=((pCOUNT>>16)&0x0f);
  pD+=3;
  }
/**************发射***************/
 if(UART_SOUT_BIT&0x08)
 {
  pCOUNT=SD_CP_COUNT;

     UART_BUFFER[pD+1]=0;
  if(SD_LIMIT_CW) //方位限位
   UART_BUFFER[pD+1]|=0x40;
  if(SD_LIMIT_CC) //方位限位
   UART_BUFFER[pD+1]|=0x80;

  i=pCOUNT&0xff ;
  if(i>0xfd)
   {
    UART_BUFFER[pD+3]=0xff-i;
    UART_BUFFER[pD+1] |=0x10;
    }
    else
    UART_BUFFER[pD+3]=i;
  i=(pCOUNT>>8)&0xff ;
   if(i>0xfd)
   {
    UART_BUFFER[pD+2]=0xff-i;
    UART_BUFFER[pD+2]|=0x20;
    }
    else
    UART_BUFFER[pD+2]=i;         
 
  UART_BUFFER[pD+1]|=((pCOUNT>>16)&0x0f);
  pD+=3;
   }
 
  UART_BUFFER[++pD]|=0xfe;
/***************************结束*******************************/
 
   do
  { 
   
     SBUF0=*pStr;
     while(TI0==0);
     TI0=0;
  
   }
   while(EndFlag!=*pStr++);
  
 
 SFRPAGE = SFRPAGE_save;             // Restore the SFRPAGE   


}

void main()

  Init_Config ();                       // 初始化硬件

 EA = 1;                               // 允许全局中断
   

 while(1)
 {


  if(UART_SOUT_BIT)UART_SBUF0();      /*向上位机发送角度*/
  if(ASK)UART_SOUT_BIT=0;             /*角度返回 0自动返回 1问答返回*/

      delay(40000);
    delay(10000);
     delay(10000);
     WatchDog();
 }


}

 

STDDEF.H

 

 

#ifndef __CONFIG_C__
#define __CONFIG_C__

#include "c8051f120.h"
#include "intrins.h"
#include "stdio.h"
#include "STRING.H"
#include "math.h"
#include "stdlib.h"

/************custom**********/

#define uchar unsigned char
#define uint  unsigned  int
#define ulong unsigned long
#define UCHAR unsigned char
#define UINT  unsigned  int
#define ULONG unsigned long
#define EX_   extern
#define ex_   extern

/************SETUP 看门狗端口**********/

sbit DOG=   P1^0;

/************SETUP 问答模式************/

#define ASK    1                              /*角度返回 0自动返回 1问答返回*/

/************SETUP CP DR **************/

sbit CPAZ = P3^0;
sbit CPEL = P3^1;
sbit CPRV = P3^2;
sbit CPSD = P3^3;

sbit DRAZ = P3^6;
sbit DREL = P3^7;
sbit DRRV = P2^0;
sbit DRSD = P2^1;

  /***********限位端口*********/

#define  AZ_LIMIT_CC     0
#define  AZ_LIMIT_CW     0
sbit      ``` EL_LIMIT_UP    = P2^4;
sbit          EL_LIMIT_DN    = P2^5;
#define  RV_LIMIT_CW    0
#define  RV_LIMIT_CC     0
#define    SD_LIMIT_CC     0
#define    SD_LIMIT_CW     0

  /***********限位端口*********/
 
#define DEFAULT_AZ_START_SPEED 0x0333
#define DEFAULT_EL_START_SPEED 0x0333
#define DEFAULT_RV_START_SPEED 0x0333
#define DEFAULT_SD_START_SPEED 0x0333


/********************CMD 命令集************************/

#define CMD_CW        0x01
#define CMD_CC        0x02
#define CMD_STOP       0x03
#define CMD_TARGET     0x04
#define CMD_SOUT      0x05
#define CMD_SPEED      0x06
#define CMD_COUNT      0x07
#endif

 


#include "stddef.h"

 EX_ UCHAR   UART_SOUT_BIT;
 
 /***************调速******************/

 UINT AZ_SPEED_NEW =   0xd333;
 UINT EL_SPEED_NEW =   0xd333;
 UINT RV_SPEED_NEW =   0xd333;
 UINT SD_SPEED_NEW =   0xd333;

 UINT AZ_SPEED_OLD =   0x0333;
 UINT EL_SPEED_OLD =   0xE333;
 UINT RV_SPEED_OLD =   0x0333;
 UINT SD_SPEED_OLD =   0xe333;

 


/*************1 定位 2 顺转 3 疙转 **********/

 UCHAR  AZ_CMD_FLAG =  0;
 UCHAR  EL_CMD_FLAG =  0;
 UCHAR  RV_CMD_FLAG =  0;
 UCHAR  SD_CMD_FLAG =  0;

  ULONG  AZ_CP_TOTAL =  160000;//2000*80
 ULONG  EL_CP_TOTAL =  160000;//
 ULONG  SD_CP_TOTAL =  160000;//
 ULONG  DN_CP_TOTAL =  160000;//
 ULONG  RV_CP_TOTAL =  160000;//

    ULONG  AZ_CP_COUNT   = 0;
  ULONG  EL_CP_COUNT   = 0;
 ULONG  RV_CP_COUNT   = 0;
  ULONG  SD_CP_COUNT   = 0;


 ULONG  AZ_TARGET_COUNT  = 0;
 ULONG  EL_TARGET_COUNT  = 0; 
 ULONG  RV_TARGET_COUNT  = 0;
 ULONG  SD_TARGET_COUNT  = 0;
 
   
void Interrupt_int0 (void)  interrupt 0 using 0  /********* 外部中断INIT0 *************/
{
    
}

void Interrupt_Int1 (void)  interrupt 2 using 0  /********* 外部中断INIT1 *************/

{
 
}
void Interrupt_Time0 (void)  interrupt 1 using 1  /********* 定时器0TIME0 *************/

{
     uchar SFRPAGE_save = SFRPAGE;       // Save the current SFRPAGE 
  
  SFRPAGE=TIMER01_PAGE;     

    TF0=0;
    //是否需要调整
     if(AZ_SPEED_NEW!=AZ_SPEED_OLD)
       (AZ_SPEED_NEW>AZ_SPEED_OLD)?AZ_SPEED_OLD++:AZ_SPEED_OLD--;
  
   


     switch(AZ_CMD_FLAG) //定位
  {
   case 1:
   {
     if(AZ_TARGET_COUNT>AZ_CP_COUNT)
      {
                  if(AZ_LIMIT_CW)break;
                  DRAZ=1;
             CPAZ=~CPAZ;
                  AZ_CP_COUNT++;
          // if(AZ_CP_TOTAL==AZ_CP_COUNT)AZ_CP_COUNT=0;
       }
       else
       {
        if(AZ_TARGET_COUNT<AZ_CP_COUNT)
        {
                    if(AZ_LIMIT_CC)break;
                    DRAZ=0;
                    CPAZ=~CPAZ;     
            AZ_CP_COUNT--;
           //  if(0==AZ_CP_COUNT)AZ_CP_COUNT=AZ_CP_TOTAL;
        }
        else
          AZ_CMD_FLAG&=0;
       }       
    }
    break;
    case 2:
    
             //顺转
      {
                 if(AZ_LIMIT_CW)break;
                  DRAZ=1;
             CPAZ=~CPAZ;
                  AZ_CP_COUNT++;
                  if(AZ_CP_TOTAL==AZ_CP_COUNT)AZ_CP_COUNT=0;
      }
      break;
    case 3:
     
             //悄转
      {
                if(AZ_LIMIT_CC)break;
                DRAZ=0;
                CPAZ=~CPAZ;     
          AZ_CP_COUNT--;
           if(0==AZ_CP_COUNT)AZ_CP_COUNT=AZ_CP_TOTAL;
  
      }
      break;
    default :
     break;
        
  }


    TH0=AZ_SPEED_OLD>>8;
    TL0=AZ_SPEED_OLD&0x00ff;
    TR0=1;
    SFRPAGE = SFRPAGE_save;             // Restore the SFRPAGE  
 
}
void Interrupt_Time1 (void)  interrupt 3 using 1  /********* 定时器1TIME1 *************/

{
     uchar SFRPAGE_save = SFRPAGE;       // Save the current SFRPAGE 
  
  SFRPAGE=TIMER01_PAGE;     

  TF1=0;
       
    //是否需要调整
     if(EL_SPEED_NEW!=EL_SPEED_OLD)
       (EL_SPEED_NEW>EL_SPEED_OLD)?EL_SPEED_OLD++:EL_SPEED_OLD--;
  
   


     switch(EL_CMD_FLAG) //定位
  {
   case 1:
   {
     if(EL_TARGET_COUNT>EL_CP_COUNT)
      {
                 
                  if(EL_LIMIT_UP)break;
                  DREL=1;
             CPEL=~CPEL;
                  EL_CP_COUNT++;
          // if(EL_CP_TOTAL==EL_CP_COUNT)EL_CP_COUNT=0;
       }
       else
       {
        if(EL_TARGET_COUNT<EL_CP_COUNT)
        {
                    
                      if(EL_LIMIT_DN)break;
                      DREL=0;
                      CPEL=~CPEL;     
                      EL_CP_COUNT--;
           //  if(0==EL_CP_COUNT)EL_CP_COUNT=EL_CP_TOTAL;
        }
        else
          EL_CMD_FLAG&=0;
       }       
    }
    break;
    case 2:
    
             //顺转
        {
                  if(EL_LIMIT_UP)break;
                  DREL=1;
             CPEL=~CPEL;
                  EL_CP_COUNT++;
                  if(EL_CP_TOTAL==EL_CP_COUNT)EL_CP_COUNT=0;
      }
      break;
    case 3:
     
      {
                if(EL_LIMIT_DN)break;
                DREL=0;
                CPEL=~CPEL;     
          EL_CP_COUNT--;
           if(0==EL_CP_COUNT)EL_CP_COUNT=EL_CP_TOTAL;
  
      }
      break;
    default :
     break;
        
  }

  TH1=EL_SPEED_OLD>>8;
  TL1=EL_SPEED_OLD&0x00ff;
  TR1=1;  
 
  SFRPAGE = SFRPAGE_save;             // Restore the SFRPAGE  

}
void Interrupt_Time3 (void)  interrupt 14 using 1  /********* 定时器3TIME3 *************/

{
  uchar SFRPAGE_save = SFRPAGE;       // Save the current SFRPAGE 
  
  SFRPAGE=TMR3_PAGE;     

  TF3=0;
       
    //是否需要调整
     if(RV_SPEED_NEW!=RV_SPEED_OLD)
       (RV_SPEED_NEW>RV_SPEED_OLD)?RV_SPEED_OLD++:RV_SPEED_OLD--;
  
   


     switch(RV_CMD_FLAG) //定位
  {
   case 1:
   {
     if(RV_TARGET_COUNT>RV_CP_COUNT)
      {
                  if(RV_LIMIT_CW)break;
                  DRRV=1;
             CPRV=~CPRV;
                  RV_CP_COUNT++;
          // if(RV_CP_TOTAL==RV_CP_COUNT)RV_CP_COUNT=0;
       }
       else
       {
        if(RV_TARGET_COUNT<RV_CP_COUNT)
        {
                    if(RV_LIMIT_CC)break;
                    DRRV=0;
                    CPRV=~CPRV;     
            RV_CP_COUNT--;
           //  if(0==RV_CP_COUNT)RV_CP_COUNT=RV_CP_TOTAL;
        }
        else
          RV_CMD_FLAG&=0;
       }       
    }

    break;
    case 2:
    
             //顺转
      {
                  if(RV_LIMIT_CW)break;
                  DRRV=1;
             CPRV=~CPRV;
                  RV_CP_COUNT++;
                  if(RV_CP_TOTAL==RV_CP_COUNT)RV_CP_COUNT=0;
      }
      break;
    case 3:
     
             //悄转
      {
                if(RV_LIMIT_CC)break;
                DRRV=0;
                CPRV=~CPRV;     
          RV_CP_COUNT--;
           if(0==RV_CP_COUNT)RV_CP_COUNT=RV_CP_TOTAL;
  
      }
      break;
    default :
     break;
        
  }
  RCAP3H=RV_SPEED_OLD>>8;
   RCAP3L=RV_SPEED_OLD&0x00ff;
    TR3=1;  
 
  SFRPAGE = SFRPAGE_save;             // Restore the SFRPAGE  
 
}
void Interrupt_Time4 (void)  interrupt 16 using 1  /********* 定时器4TIME4 *************/

{
     uchar SFRPAGE_save = SFRPAGE;       // Save the current SFRPAGE 
  
  SFRPAGE=TMR4_PAGE;     

  TF4=0;
       
    //是否需要调整
     if(SD_SPEED_NEW!=SD_SPEED_OLD)
       (SD_SPEED_NEW>SD_SPEED_OLD)?SD_SPEED_OLD++:SD_SPEED_OLD--; 


     switch(SD_CMD_FLAG) //定位
  {
   case 1:
   {
     if(SD_TARGET_COUNT>SD_CP_COUNT)
      {
                  if(SD_LIMIT_CW)break;
                  DRSD=1;
             CPSD=~CPSD;
                  SD_CP_COUNT++;
          // if(SD_CP_TOTAL==SD_CP_COUNT)SD_CP_COUNT=0;
       }
       else
       {
        if(SD_TARGET_COUNT<SD_CP_COUNT)
        {
                    if(SD_LIMIT_CC)break;
                    DRSD=0;
                    CPSD=~CPSD;     
                    SD_CP_COUNT--;
           //  if(0==SD_CP_COUNT)SD_CP_COUNT=SD_CP_TOTAL;
        }
        else
          SD_CMD_FLAG&=0;
       }       
    }

    break;
    case 2:
    
            
      {
                  if(SD_LIMIT_CW)break;
                  DRSD=1;
             CPSD=~CPSD;
                  SD_CP_COUNT++;
                  if(SD_CP_TOTAL==SD_CP_COUNT)SD_CP_COUNT=0;
      }
      break;
    case 3:
     
            
      {
                if(SD_LIMIT_CC)break;
                DRSD=0;
                CPSD=~CPSD;
           if(0==SD_CP_COUNT)SD_CP_COUNT=SD_CP_TOTAL;            
          SD_CP_COUNT--;

  
      }
      break;
    default :
     break;
        
  }
  RCAP4H=SD_SPEED_OLD>>8;
  RCAP4L=SD_SPEED_OLD&0x00ff;
       TR4=1;  
 
  SFRPAGE = SFRPAGE_save;             // Restore the SFRPAGE  
 
}

 


/*********************************************************************************** 
* 函数名称:UART0; UART1;

* 函数功能描述:串口0中断,接收PC机命令,并向PC机返回角度; 
*               
* 输入参数:发送数据; 

* 返回数据:none; 

* 注意:   none;
    
************************************************************************************/ 

UCHAR UART0_BUFFER[20]={'/0'};
UCHAR UART0_BUFFER_COUNT=0;
UCHAR UART0_FLAG=0;


void Interrupt_UART0(void) interrupt 4 using 2  /********* 串口中断0UART0 *************/
{
    UCHAR SFRPAGE_save = SFRPAGE; // Save the current SFRPAGE 
    UCHAR rv=0;
    SFRPAGE=UART0_PAGE;
 
 if(RI0)
 {
 
  rv = SBUF0; 
   
  if(rv==0xFF)
  {
   UART0_FLAG=1;UART0_BUFFER_COUNT = 0;
  }
  if(rv==0xFE)
  {
   UART0_BUFFER_COUNT=0;
   UART0_FLAG=0;
   
     switch(UART0_BUFFER[1]&0x0F)
     {
      case CMD_CW:
      
     switch(UART0_BUFFER[2])
     {
      case 0x01:
              AZ_SPEED_OLD=DEFAULT_AZ_START_SPEED;
       AZ_CMD_FLAG=2;
      break;
      case 0x02:
              EL_SPEED_OLD=DEFAULT_EL_START_SPEED;
       EL_CMD_FLAG=2;
      break;
      case 0x03:
              RV_SPEED_OLD=DEFAULT_RV_START_SPEED;
       RV_CMD_FLAG=2;
      break;
      case 0x04:
              SD_SPEED_OLD=DEFAULT_SD_START_SPEED;
       SD_CMD_FLAG=2;
      break;

     }
      break;
      case CMD_CC:
     switch(UART0_BUFFER[2])
     {
      case 0x01:
              AZ_SPEED_OLD=DEFAULT_AZ_START_SPEED;
       AZ_CMD_FLAG=3;
      break;
      case 0x02:
              EL_SPEED_OLD=DEFAULT_EL_START_SPEED;
       EL_CMD_FLAG=3;
      break;
      case 0x03:
              RV_SPEED_OLD=DEFAULT_RV_START_SPEED;
       RV_CMD_FLAG=3;
      break;
      case 0x04:
              SD_SPEED_OLD=DEFAULT_SD_START_SPEED;
       SD_CMD_FLAG=3;
      break;

     }

      break;
      case CMD_STOP:
     switch(UART0_BUFFER[2])
     {
      case 0x01:
       AZ_CMD_FLAG=0;
      break;
      case 0x02:
       EL_CMD_FLAG=0;
      break;
      case 0x03:
       RV_CMD_FLAG=0;
      break;
      case 0x04:
       SD_CMD_FLAG=0;
      break;
      default:
       AZ_CMD_FLAG=0;
       EL_CMD_FLAG=0;
       RV_CMD_FLAG=0;
       SD_CMD_FLAG=0;
      break;
     }
   break;
   case CMD_TARGET:
    if(UART0_BUFFER[2]&0x80)
    {
     UART0_BUFFER[3]=0xff-UART0_BUFFER[3];
    }
    if(UART0_BUFFER[2]&0x40)
    {
     UART0_BUFFER[4]=0xff-UART0_BUFFER[4];
    }
    switch(UART0_BUFFER[1]&0xf0)
     {
      case 0x10:
       AZ_TARGET_COUNT &=0x0f;
       AZ_TARGET_COUNT &=UART0_BUFFER[2];
       AZ_TARGET_COUNT <<=8;
       AZ_TARGET_COUNT |=UART0_BUFFER[3];
       AZ_TARGET_COUNT <<=8;
       AZ_TARGET_COUNT |=UART0_BUFFER[4];
              AZ_SPEED_OLD=DEFAULT_AZ_START_SPEED;
       AZ_CMD_FLAG=1;
      break;
      case 0x20:
       EL_TARGET_COUNT &=0x0f;
       EL_TARGET_COUNT &=UART0_BUFFER[2];
       EL_TARGET_COUNT <<=8;
       EL_TARGET_COUNT |=UART0_BUFFER[3];
       EL_TARGET_COUNT <<=8;
       EL_TARGET_COUNT |=UART0_BUFFER[4];
              EL_SPEED_OLD=DEFAULT_EL_START_SPEED;
       EL_CMD_FLAG=1;
      break;
      case 0x40:
       RV_TARGET_COUNT &=0x0f;
       RV_TARGET_COUNT &=UART0_BUFFER[2];
       RV_TARGET_COUNT <<=8;
       RV_TARGET_COUNT |=UART0_BUFFER[3];
       RV_TARGET_COUNT <<=8;
       RV_TARGET_COUNT |=UART0_BUFFER[4];
       RV_SPEED_OLD=DEFAULT_RV_START_SPEED;
       RV_CMD_FLAG=1;
      break;
      case 0x80:
       SD_TARGET_COUNT &=0x0f;
       SD_TARGET_COUNT &=UART0_BUFFER[2];
       SD_TARGET_COUNT <<=8;
       SD_TARGET_COUNT |=UART0_BUFFER[3];
       SD_TARGET_COUNT <<=8;
       SD_TARGET_COUNT |=UART0_BUFFER[4];
       SD_SPEED_OLD=DEFAULT_SD_START_SPEED;
       SD_CMD_FLAG=1;
      break;
      default:

      break;
     }
   break;
   case CMD_SOUT:
    
     UART_SOUT_BIT= UART0_BUFFER[2];

   break;

   case CMD_SPEED:
    if(UART0_BUFFER[2]&0x80)
    {
     UART0_BUFFER[3]=0xff-UART0_BUFFER[3];
    }
    if(UART0_BUFFER[2]&0x40)
    {
     UART0_BUFFER[4]=0xff-UART0_BUFFER[4];
    }
    switch(UART0_BUFFER[1]&0xf0)
     {
      case 0x10:
       
       AZ_SPEED_NEW &=UART0_BUFFER[3];
       AZ_SPEED_NEW <<=8;      
       AZ_SPEED_NEW |=UART0_BUFFER[4];

      break;
      case 0x20:
       EL_SPEED_NEW &=UART0_BUFFER[3];
       EL_SPEED_NEW <<=8;      
       EL_SPEED_NEW |=UART0_BUFFER[4];


      break;
      case 0x40:
       RV_SPEED_NEW &=UART0_BUFFER[3];
       RV_SPEED_NEW <<=8;      
       RV_SPEED_NEW |=UART0_BUFFER[4];
       
      break;
      case 0x80:
       SD_SPEED_NEW &=UART0_BUFFER[3];
       SD_SPEED_NEW <<=8;      
       SD_SPEED_NEW |=UART0_BUFFER[4];
       
      break;
      default:

      break;
     }

 

   break;
   case CMD_COUNT:
    if(UART0_BUFFER[2]&0x80)
    {
     UART0_BUFFER[3]=0xff-UART0_BUFFER[3];
    }
    if(UART0_BUFFER[2]&0x40)
    {
     UART0_BUFFER[4]=0xff-UART0_BUFFER[4];
    }
    switch(UART0_BUFFER[1]&0xf0)
     {
      case 0x10:
       AZ_CP_COUNT &=0x0f;
       AZ_CP_COUNT &=UART0_BUFFER[2];
       AZ_CP_COUNT <<=8;
       AZ_CP_COUNT |=UART0_BUFFER[3];
       AZ_CP_COUNT <<=8;
       AZ_CP_COUNT |=UART0_BUFFER[4];

      break;
      case 0x20:
       EL_CP_COUNT &=0x0f;
       EL_CP_COUNT &=UART0_BUFFER[2];
       EL_CP_COUNT <<=8;
       EL_CP_COUNT |=UART0_BUFFER[3];
       EL_CP_COUNT <<=8;
       EL_CP_COUNT |=UART0_BUFFER[4];


      break;
      case 0x40:
       RV_CP_COUNT &=0x0f;
       RV_CP_COUNT &=UART0_BUFFER[2];
       RV_CP_COUNT <<=8;
       RV_CP_COUNT |=UART0_BUFFER[3];
       RV_CP_COUNT <<=8;
       RV_CP_COUNT |=UART0_BUFFER[4];
       
      break;
      case 0x80:
       SD_CP_COUNT &=0x0f;
       SD_CP_COUNT &=UART0_BUFFER[2];
       SD_CP_COUNT <<=8;
       SD_CP_COUNT |=UART0_BUFFER[3];
       SD_CP_COUNT <<=8;
       SD_CP_COUNT |=UART0_BUFFER[4];
       
      break;
      default:

      break;
     }
   break;
     }
   
  }

  if(UART0_FLAG)
  {
   
   
    UART0_BUFFER[UART0_BUFFER_COUNT]=rv;
    if(++UART0_BUFFER_COUNT>20)
    {
          UART0_FLAG=0;
          UART0_BUFFER_COUNT=0;
        }
  }

  RI0=0;

 }

  
   SFRPAGE = SFRPAGE_save;             // Restore the SFRPAGE   
 }

 

 

 

 

 

 

 

 
 #include "stddef.h"

 void SYSCLK_Init (void);
 void PLL_Init (void);
 void PORT_Init();
 void Init_Config (void);
 void Watchdog_Init (void);
 void UART0_Init (void) ;
/***********************************************************************************
* 函数名称:SYSCLK_Init;
*
* 函数功能描述:系统时钟初始化,使用外部22.1184MHz晶振作为时钟源;
*              
* 输入参数:none;
*
* 返回数据:none;
*
* 注意:    none;
************************************************************************************/
void SYSCLK_Init (void)
{  
 
  int i;                                // 延时计数器
 uchar SFRPAGE_save = SFRPAGE;         // Save the current SFRPAGE 
 SFRPAGE = CONFIG_PAGE;                // 地址页为F 
 OSCXCN = 0x67;                        // 起动外部振荡器晶体为 22.1184MHz    初使为1100111
 for (i=0; i < 12256; i++) ;           // 等待振荡器启动(>1ms)
 while (!(OSCXCN & 0x80)) ;            // 等待晶体振荡器稳定 
 CLKSEL=0x01;                          // 选择外部振荡器作为系统时钟源并使能
 SFRPAGE = SFRPAGE_save;               // Restore the SFRPAGE

}
/***********************************************************************************
* 函数名称:PLL_Init;
*
* 函数功能描述:系统锁相环倍频初始化,
*              
* 输入参数:none;
*
* 返回数据:none;
*
* 注意:    none;
************************************************************************************/

void PLL_Init (void)              
{    
  uchar SFRPAGE_save = SFRPAGE;       // Save the current SFRPAGE   
 unsigned int ui=0;
 SFRPAGE=PLL0_PAGE;


 PLL0CN=0x04;                        // PLL 控制寄存器使用外部振档器

 SFRPAGE=LEGACY_PAGE;
 FLSCL=0xf0;                         // FLASH 读时间禁止FLASH 写/擦除11110000
 SFRPAGE=PLL0_PAGE;
 
 PLL0CN=0x05;                        // PLL 参考时钟源为外部振荡器。:PLL 偏置发生器被使能
 PLL0DIV=0x01;                       // 参考时钟除于1
 PLL0FLT=0x01;                       // 环路滤波器控制位。
 PLL0MUL=0x08;                       // 4倍频
 for(ui=0;ui<200;ui++)
 {
  _nop_();                          // NOP是一个周期 所以 20M下 1S/(20M/12)=0.6US     0.011us
 }
 PLL0CN=0x07;                        //PPL使能
// while (!(PLL0CN & 0x10)) ;
    CLKSEL=0x02;                        //使用CLKSEL 寄存器将系统时钟源切换到PLL。
 
 
 SFRPAGE = SFRPAGE_save;             // Restore the SFRPAGE

}

/*********************************************************************************** 
* 函数名称:PORT_Init; 

* 函数功能描述:配置端口初始化,配置交叉开关和端口; 
*               
* 输入参数:none; 

* 返回数据:none; 

* 注意:    none; 
************************************************************************************/  

void PORT_Init(void)
{
    uchar SFRPAGE_save = SFRPAGE;           // Save the current SFRPAGE   
    SFRPAGE = CONFIG_PAGE;                  // Switch to the necessary SFRPAGE   

 

 P0MDOUT=0xff;          //P0口为推挽输出
 P1MDOUT=0xff;          //P1口为推挽输出
 P2MDOUT=0xff;          //P3口为推挽输出
 P3MDOUT=0xff;          //P3口为推挽输出

 

    XBR0 = 0x05;                       //分配串口0  SDASCL 
    XBR1 = 0x14;                       //分配外部中断0和1
    XBR2 = 0x44;                       // 分配串口1,允许数据交叉开关和弱上拉
 
    
    SFRPAGE = SFRPAGE_save;                 // Restore the SFRPAGE   

}
/*********************************************************************************** 
* 函数名称:TIMER_Init; 

* 函数功能描述:SPI初始化函数; 主方式
*               
* 输入参数:none; 

* 返回数据:none; 

* 注意:   none; 
************************************************************************************/  
 void TIMER_Init()
 {
    uchar SFRPAGE_save = SFRPAGE;           // Save the current SFRPAGE   

 
// PCA0MD = 0x00; // 禁止CF中断
                // PCA时基 = SYSCLK

  SFRPAGE=TIMER01_PAGE;//寄存器页
 CKCON=0x19;//时基为系统时钟
 TMOD = 0x11;  //21
 TH0=0X00;//定时器0设置
 TL0=0X10;
 TR0=1;

    TH1 = 0X00;                               //-(SYSCLK/BAUDRATE/16/2); // 按波特率设置定时器1重装值
    TL1 = 0Xa0;
    TR1=1;                                    //启动定时器1
 
  
 /*
 SFRPAGE=TMR2_PAGE;//定时器2设置
 TMR2CF=0X08;//时基为系统时钟
 TMR2H=0X00;
 TMR2L=0X10;
 TMR2CN=0X04;
 */

 SFRPAGE=TMR3_PAGE;//定时器3设置
 TMR3CF=0X08;//时基为系统时钟
 TMR3H=0X00; //(65535-0010H)是定时器的起始数据,
 TMR3L=0X10;// 然后每隔一个系统时钟周期减一来完成定时计数
 TMR3CN=0X04;

 SFRPAGE=TMR4_PAGE;//定时器4设置
 TMR4CF=0X08;//时基为系统时钟
 TMR4H=0X00;
 TMR4L=0X05;
 TMR4CN=0X04;

 //中断设置

 ET0=1;     //开定时器0中断 
 ET1=1;     //开定时器1中断  
// ET2=1;     //开定时器2中断
 EIE2|=0X05;//开定时器3和4中断
   
 SFRPAGE = SFRPAGE_save;                 // Restore the SFRPAGE   

 } 

/*********************************************************************************** 
* Watchdog_Init; 

* 函数功能描述:看门狗初使化。
*               
* 输入参数:none; 

* 返回数据:none; 

* 注意:   none; 
************************************************************************************/ 
 void Watchdog_Init (void)  
{  
   uchar SFRPAGE_save = SFRPAGE; // Save the current SFRPAGE   
  
   SFRPAGE = CONFIG_PAGE;              // Switch to the necessary SFRPAGE   
  
   WDTCN     = 0xDE;                   // Disable the Watchdog Timer   
   WDTCN     = 0xAD;  
  
   SFRPAGE = SFRPAGE_save;             // Restore the SFRPAGE   
}


 /*********************************************************************************** 
* void UART0|1_Init(void) 

* 函数功能描述:串口0|1初始化初使化。
*               
* 输入参数:none; 

* 返回数据:none; 

* 注意:   none; 
************************************************************************************/

void UART0_Init (void)
{
    uchar SFRPAGE_save = SFRPAGE;           // Save the current SFRPAGE   
    SFRPAGE=UART0_PAGE;
 
    SCON0 = 0x50;
    SSTA0=0x05;                             //定时器T2作为通讯拨特率 
 
    TMR2CF=0X08;                            //定时器2工作在系统时钟下 
    TMR2L=0Xe0;                             //重装值b=T2/16,,,T2=TCK/Tn
    TMR2H=0Xfe;                             //

    RCAP2L=0Xe0;
    RCAP2H=0Xfe;                             //重装值
 
    TMR2CN=0X04;                             //启动定时器2
    PCON |= 0x80;                            // SMOD00 = 1
    IE|=0x10;                                //开串口0中断
 
 
    SFRPAGE = SFRPAGE_save;                  // Restore the SFRPAGE   

}


/*********************************************************************************** 
* 函数名称:Init_Config();

* 函数功能描述:SPI初始化函数; 主方式
*               
* 输入参数:none; 

* 返回数据:none; 

* 注意:   none; 
************************************************************************************/
void Init_Config (void)  
{  
 Watchdog_Init ();             // 关掉看门狗  
 SYSCLK_Init ();           //初始化晶振
 PLL_Init();              //锁相环设置 倍频
 PORT_Init ();            //IO端口初始化
 UART0_Init();           //串口0初使化
      
    TIMER_Init();

相关文章推荐

FM31256在C8051F单片机系统中的应用

  • 2012年05月16日 15:46
  • 288KB
  • 下载

UCOS-II在C8051f340上移植源码

  • 2016年07月06日 16:45
  • 251KB
  • 下载

基于嵌入式SoC单片机C8051F120的雕刻机数控系统

随着计算机技术的发展,雕刻机完成了从2D、2.5D到3D的加工变革,功能趋于完善、性能更加稳定,从而在制造业、建材业和广告业等领域得到了广泛应用。与此同时,随着市场竞争的加剧,国产普通雕刻机的价格也降...

C8051F系列单片机源码

  • 2013年04月09日 17:28
  • 13.32MB
  • 下载

C8051F330系列源码

  • 2011年11月04日 16:25
  • 131KB
  • 下载

C8051F340系统时钟配置

//C8051F340包含一个可编程内部高频振荡器,该振荡器在系统内复位后默认为系统时钟。该高频振荡器为12MHz。 //使能外部振荡器后,至少要等待1ms,再来判断外部晶体振荡器是否稳定工作。...

基于C8051F340的USB通信汇编源码

  • 2015年02月04日 09:28
  • 23KB
  • 下载

C8051F020源码

  • 2012年10月25日 15:12
  • 230KB
  • 下载

C8051单片机在交流变频调速系统中的应用(收集)

C8051单片机在交流变频调速系统中的应用  首先,先给大家一个中文的C8051的资料,天天看英文资料,看的人头都大了。下边是中文资料的下载地址: http://www.brsbox.com/fi...

C8051F30系列源码

  • 2011年11月04日 16:24
  • 115KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:C8051F121在天线测试系统中的应用源码
举报原因:
原因补充:

(最多只允许输入30个字)