main.c

用单片机实现(载波监听/冲突检测)的功能

        {
          TotalProTemp[ii][j]=0;                                          //临时数组初始化
        }
      }
      while(ReceviceBuff[ii++] != '~') ;                                  //获取接收数据指令的长度
      j = 0;
      for(Counter=4; Counter<(ii-4); Counter++)                           //截取数据字符
      {
        CheckSum += ReceviceBuff[Counter];
        if((ReceviceBuff[Counter] != ','))                                //获取ASCII数据
        {            
          {
            TotalProTemp[k][j++] = ReceviceBuff[Counter];
          }
        }
        else
        {
          k++;
          j = 0;
        }
      }
      CheckSum += ReceviceBuff[3]; 
      CheckSum = CheckSum & 0X0F;                                             //校验和
      CheckSum |= 0X20;
      if(CheckSum == ReceviceBuff[ii-2])                                      //发送正确数据指令接收完毕
      {
        while((IFG1 & UTXIFG0) == 0);
        TXBUF0 = AddressIndex[SelfAddress];
        while((IFG1 & UTXIFG0) == 0);
        TXBUF0 = AddressIndex[SelfAddress];
        SendData(CorrectCode,2);
        UartCount = 0;
        Flag &= ~ReceiveDataFlg;
        for(ii=0; ii<10; ii++)
        {
          TotalPro[ii]=0;
        }
        
        for(ii=0; ii<9; ii++)                                                 //将ASCII数据转换成数值数据
        {
          Counter = 0;
          for(j=3; j>=0; j--)
          {
             switch(TotalProTemp[ii][j])
             {
                case '0':
                  Counter++;
                  digital = 0;
                  break;
                case '1':
                  Counter++;
                  digital = 1;
                  break;
                case '2':
                  Counter++;
                  digital = 2;
                  break;
                case '3':
                  Counter++;
                  digital = 3;
                  break;
                case '4':
                  Counter++;
                  digital = 4;
                  break;
                case '5':
                  Counter++;
                  digital = 5;
                  break;
                case '6':
                  Counter++;
                  digital = 6;
                  break;
                case '7':
                  Counter++;
                  digital = 7;
                  break;
                case '8':
                  Counter++;
                  digital=8;
                  break;
                case '9':
                  Counter++;
                  digital = 9;
                  break;
              }
          
              switch(Counter)
              {
                case 1:
                  k = 1;
                  TotalPro[ii+1] += digital * k;
                  break;
                case 2:
                 k = 10;
                 TotalPro[ii+1] += digital * k;
                 break;
                case 3:
                 k = 100;
                 TotalPro[ii+1] += digital * k;
                 break;
                case 4:
                 k = 1000;
                 TotalPro[ii+1] += digital * k;
                 break;
              }
            }
          }
          if(ReceviceBuff[3] == 'k')
            Plan = TotalPro[1];
          else if(ReceviceBuff[3] == 'l')
            Target = TotalPro[1];
          else if(ReceviceBuff[3] == 'm')
            Real = TotalPro[1]; 
      }
      else 
      {
          while((IFG1 & UTXIFG0) == 0);  
          TXBUF0 = AddressIndex[SelfAddress];
          while((IFG1 & UTXIFG0) == 0); 
          TXBUF0 = AddressIndex[SelfAddress];
          SendData(ReTxdData,2);                                            //要求重新发送
          UartCount = 0;
          Flag &= ~ReceiveDataFlg;
          CommunicationErr = ReSendErr;                                      //记录发送指令
      } 
       _EINT();
    }*/
    _NOP();
    _NOP();
    _NOP();
  }
  
}

void Init(void)
{
  //利用P2、P3口实现按键扫描
     _DINT();
     SysInit();                        //打开主震荡器
     P1IE  = 0X70;                     //允许P1.4中断
     P1SEL = 0X00;                 
     P1IES = 0X70;                     //下降沿触发
     P1IFG = 0X00;
     P1DIR = 0X80;                     //P1口设置为键盘输入口，可中断
     P1OUT |= P1OUT_7;                 //  八脚拉高。置位输出
     
     P3DIR = 0X1F;                     //输出端口驱动LED
     P3OUT = 0X10;
     P3SEL = 0X30;                     //使用外部模块用于UART串行口通信
   
     P5DIR = 0XFF;                     //输出端口驱动LED 
     P5OUT = 0X00;
     
     P6DIR = 0X00;                     //监测p6.4电源端状态
     
                           
     TACTL   = TASSEL_1 + MC_1;                          //定时器A 32768HZ 中断
     TACCTL0 = CCIE;                                     //允许定时器A中断
     TACCR0  = 819;                                     //定时时间为25ms  
     
     /*TBCTL   = TBSSEL_1 + MC_1;                          //定时器A 32768HZ 中断
     TBCCTL0 = CCIE;                                     //允许定时器A中断
     TBCCR0  = 32;                                       //定时时间为1ms*/
     
     U0CTL  &= ~SWRST;                                   // Release USART
     ME1    |= UTXE0 + URXE0;                            //使能RX TX
     U0CTL   = 0; 
     U0CTL   = CHAR+PENA;                                //一位停止位\8位数据位\奇校验允许
     U0TCTL  = 0;
     U0TCTL  = SSEL1;                                    //主时钟选择MCLK, 4MHZ  
     U0RCTL  = URXEIE;                                   //发送错误允许中断
      
     IE1    |= URXIE0 ;                                  //允许RX TX中断

     U0BR0   = BaudRate[BaudDefault][0];                 //默认波特率为 9600
     U0BR1   = BaudRate[BaudDefault][1];
     UMCTL0  = BaudRate[BaudDefault][2];
     
     //Index = BaudDefault;                                //波特率索引
     DisplayFlg     |= FirstFlg;                 
     Flag            = SwitchOff;                                   //启动标志
     ConflictFlag   |= SENDENABLE;    
     Plan   =0;                                          //计划
     //Target =0;                                          //目标
     Real   =0;                                          //实绩
     CounterForNumber = 0;                         
     Counter = 0;
     ScaleClock= -1;                                    //标尺置位
     _EINT();  
}

void SysInit(void)
{
   unsigned int iq0;
   BCSCTL1 &= ~XT2OFF;     				//打开XT2振荡器
   do
   {
      IFG1 &= ~OFIFG;				        // 清除振荡器失效标志
      for(iq0=0xFF; iq0>0; iq0--);    	                // 延时，等待XT2起振
   }
   while((IFG1 & OFIFG) != 0);			        // 判断XT2是否起振
   BCSCTL2 = SELM_2 + SELS;		                //选择MCLK为XT2
} 


//*****************************************************************************
//  设置波特率程序,参数band为可以选择的波特率的编号
//  默认的波特率为119200bps
//
//*****************************************************************************
void SetBaud(int baud)
{
  UCTL0 &= ~SWRST;                              // Release USART
  
  if((baud & 0X10) == 0X10)
  {
    baud = 0X05;                                //9600bps
  }
  else
  {
    baud = 0X04;                                //19200bps
  }
  
  ME1 &= ~(UTXE0 + URXE0);                      // Disable USART operation
  ME1 |= UTXE0 + URXE0;                         // Re-enable USART operation
  IE1 |= URXIE0;    

  UBR00  = BaudRate[baud][0];                   // Set configuration for
  UBR10  = BaudRate[baud][1];                   // new baud rate
  UMCTL0 = BaudRate[baud][2];

  RXBUF0;                                       // Empty RX buffer and clear flags
}



#pragma vector = PORT1_VECTOR 
__interrupt void GetKeyCode(void)
{
     _DINT();
     //Delay10ms(2);  
   
     if((P1IFG & P1IFG_6) == P1IFG_6)              //Start
     {
       if((P1IFG & P1IFG_6) == P1IFG_6)
       {
          ConflictFlag |= NEEDCOMM;                       //有通信需求
         // P3OUT    &= ~P3OUT_1;                       //解除异常灯
          Flag     &= ~SwitchOn;                      //异常开关关闭
          Flag     |= SwitchOff;                     //异常开关解除
       }
     }
     
     if((P1IFG & P1IFG_7) == P1IFG_7)                 //解除异常灯
     {
        if((Flag & SwitchOn) == SwitchOn)
          ConflictFlag |= NEEDCOMM;                         //有通信需求
        else if((Flag & SwitchOff) == SwitchOff)
          ConflictFlag &= ~NEEDCOMM;                        //无通信需求
        Flag     |= SwitchOff;                             //解除开关打开
        Flag     &= ~SwitchOn;                           
     }
     
     if((P1IFG & P1IFG_5) == P1IFG_5)
     {
       if((Flag & SwitchOff) == SwitchOff)
         ConflictFlag  |= NEEDCOMM;                        //有通信需求
       else if((Flag & SwitchOn) == SwitchOn)
         ConflictFlag  &= ~NEEDCOMM;                      //无通信需求
       Flag |= SwitchOn;                                  //异常开关打开
       Flag &= ~SwitchOff;
     }
     P1IFG = 0X00;                                     //P1口标志清零
     _EINT();
  /*_DINT();                                                          //关闭中断
  if((P1IFG & P1IFG_4) == P1IFG_4)                                  //中断触发状态位
  {
    KeyTemp = P1IN & 0X0F;                                          //获取按键编码
    _NOP();                                                         //延迟处理
    _NOP();
    _NOP();
    _NOP();
    KeyTemp = P1IN & 0X0F;                                          //再次获取按键信息
    if((P1IN & 0X0F) == KeyTemp)
    {
      Key  =  KeyTemp;                                              //如果按键和上次的按键相同，确定按键
    }
  

  
  if(((Key == 0X0C) || (Key == 0X08) || (Key == 0X01) 
      || (Key == 0X0A) || (Key == 0X06) || (Key == 0X00)
      || (Key == 0X0B)) 
      && ((Flag & StartFlg) == StartFlg)
      && ((DisplayFlg & ErrFlg) !=ErrFlg))                          //0键和1.2键被按下
  {
     if(Key == 0X0C)                                                 //工数设定(0键)
     {
       Flag |= ResetFlg;                                              //设定状态
       Flag &= ~LCJ;
       Flag &= ~RUNFlg;