recv.c

c语言写的用于单片机mps430的底层通信协议

//  no crc, for exe (7.19 24:00)
//( 7.20 15:00)  can trans out " 20 FF FF FF FF FF FF 14 00 84 C5 96 E0 00 01"
//every one second.
//721
// CRC added!
//成品3 交织,解交织编码测试2字节长度。。。
//pc端发送交织后的码， 430将这段码解码以后，在编码发出
//IN: 20 FF FF FF FF FF FF 02 DA 9B 00 21
//OUT:20 FF FF FF FF FF FF 02 DA 9B 00 21
//STRAN FOR: 20 FF FF FF FF FF FF 02 13 14
//BCH:20 FF FF FF FF FF FF 02 BB 04 C5 01

/********************************************************************************************
**********************************************************************************************/

#include "msp430x14x.h"
#include "RECV.h"



int main( void )
{
   
  WDTCTL=WDTPW+WDTHOLD;
  _DINT();
  //PXDIR控制I/O方向,PXSEL为功能选择
  //PXIN为读取I/O输入数据，写PXOUT为控制I/O输出电平
  //Lights port 6.2
  P6DIR=0;      //初始化所有P6为输入
  P6SEL=0;      //p6为一般I/O口
  P6DIR|=BIT2;  //P6.2 为输出
  P6DIR|=BIT0;
   
  //Initialize UART0 and UART1
  Init_UART0(); 
  Init_UART1(); 
  Init_TimerB(); 
  _EINT();
  
  /************************* START ****************************/
  P6OUT|=BIT2;        //Light P6.2
  P6OUT|=BIT0;
  //Send data  
  //Send_UART0(ch,7);
  //Send_UART1(ch,7);
  
  
  TBCCR0=TIMES;           //设置定时时间TimerB
  TBCTL |= MC_1 +TBCLR;   //  打开定时器
  
  //Receive data
  #ifdef RECEIVE
 while(1)
  {   
     whole1==0;
 //     if(whole==0&&whole1==0)
 //     {
  //      Send_UART0(ch,7);
//      whole1=1;
//       }
 //     if(whole1==1)
 //      {     while(1)
  //          {
  //          if(whole==1)
  //           break;
   //         }
 //Send_UART0(ch,12);  //////////---------------------------------
   // } 
     if(uart0_rx_flag==1)
     {
     uart0_rx_flag=0;
      whole=1;
    //Send_UART1(uart0_rx_buf,uart0_rx_length);    
//     Send_UART0_TEST(uart0_rx_buf,uart0_rx_length);    
    //        Send_UART0_TEST(out,2);    
 
 //  Send_UART0(uart0_rx_buf,uart0_rx_length);    
      Send_UART1(uart0_rx_buf,uart0_rx_length);    
 
    }
 }  
  #endif
  
  return 0;
}
void Init_UART0(void)
{
  U0CTL = 0X00;	      // clear U1CTL
  U0CTL += CHAR;      // data 8bit length
    
  U0TCTL = 0X00;	   // clear U1TCTL
  U0TCTL += SSEL0;	   // UCLK = ACLK
  
  UBR0_0 = 0x03;          // baud rate 9600
  UBR1_0 = 0x00;
  UMCTL_0 = 0x4A;
  
  ME1 |= UTXE0 + URXE0;       //enable UART1 TXD and RXD
  IE1 |= URXIE0;	      //enable UART1 RX interrupt
  //IE1 |= UTXIE0;	      //enable UART1 TX interrupt
  
  P3SEL |= BIT4;	      //set P3.4 as UART1 TXD
  P3SEL |= BIT5;	      //set P3.5 as UART1 RXD
  
  P3DIR |= BIT4;	      //set P3.4 as out  
}

void Init_UART1(void)
{
  U1CTL = 0X00;	      // clear U1CTL
  U1CTL += CHAR;      // data 8bit length
    
  U1TCTL = 0X00;	   // clear U1TCTL
  U1TCTL += SSEL0;	   // UCLK = ACLK
  
  UBR0_1 = 0x03;          // baud rate 9600
  UBR1_1 = 0x00;
  UMCTL_1 = 0x4A;
  
  ME2 |= UTXE1 + URXE1;     //enable UART1 TXD and RXD
  IE2 |= URXIE1;	      //enable UART1 RX interrupt
  //IE2 |= UTXIE1;	      //enable UART1 TX interrupt
  
  P3SEL |= 0x40;	      //set P3.6 as UART1 TXD
  P3SEL |= 0x80;	      //set P3.7 as UART1 RXD
  
  P3DIR |= 0x40;	      //set P3.4 as out 
}

void Init_TimerB(void)
{
  TBCTL=TBSSEL_1+TBCLR+MC_0;  //选择时钟源ACLK, 清除TAR,增计数方式
  TBCCTL0=CCIE;               //允许定时器中断
}

void Send_UART0_TEST(char *pdata,char length)
{
  char i;
  
  _DINT();
  TXBUF0=*pdata++;
  for(i=1;i<length;i++)
  {    
    while((IFG1&UTXIFG0)==0);
    TXBUF0=*pdata++;
  }
  _EINT();
}
void Send_UART0(char *pdata,char lengtharg)
{
  char i,rk;
 // char firstbyte;
/////0//  _DINT();
   //********************
 CRC_check(pdata,lengtharg);
// for ( i=0;i<length;i++)
//   {
//   ch0[i]=ch[i];
//   if (i==1)
 //   ch0[i]=ch[i]+2;
 //  }
 //  ch0[i]=CRCHighByte;
  // ch0[i+1]=CRCLowByte;
  *(pdata+lengtharg)=CRCHighByte;
    *(pdata+lengtharg+1)=CRCLowByte;

  //********************
                         // TXBUF0=*pdata++ ;
                ///    for(i=0;i<length+2;i++)
                ///      {    
               ///            while((IFG1&UTXIFG0)==0);
              ///         //TXBUF0=*pdata++;
              ///          TXBUF0=ch0[i];
              ///         }
 // firstbyte=ch0[0];//出现问题，ch0+1的值为1而不是FF
  //firstbyte=*pdata;
  // rk=bch_to_send((ch0+1),length+1);
rk=bch_to_send((pdata+8),lengtharg-8+2);
  // while((IFG1&UTXIFG0)==0);       //------------------------------------------------------------
          //TXBUF0=*pdata++;
cross16(*trans,rk*4,trans2);
_DINT();
        for(i=0;i<7;i++)
                    {    
                        while((IFG1&UTXIFG0)==0);    //--------------------------
                        TXBUF0=*pdata++;
   //                   TXBUF0=*(*trans+i);
                    }  
            while((IFG1&UTXIFG0)==0);    //--------------------------
            TXBUF0=*pdata+2;
            pdata++;    
 //TXBUF0=firstbyte;
      for(i=0;i<4*rk;i++)
                    {    
                    while((IFG1&UTXIFG0)==0);    //--------------------------
                        //TXBUF0=*pdata++;
                       // TXBUF0=*(*trans+i);
                          TXBUF0=*(trans2+i);
                    }         
  _EINT();
}

void Send_UART1(char *pdata,char length)
{
  char i;
  _DINT();

  TXBUF1=*pdata++ ;
  for(i=1;i<length;i++)
  {    
    while((IFG2&UTXIFG1)==0);
    TXBUF1=*pdata++;
  }
  
  _EINT();
  
}

/******* Interrupt receive from UART0 *******
**  buffer: uart0_rx_buf[]
**  length: uart0_rx_length
**  flag:   uart0_rx_flag
**  format: 0x50 length .. .. .. .. .. 
*/

#pragma vector=UART0RX_VECTOR
__interrupt void UART0_RX(void)
{  
  //asm("bic.b	#0D0H,0(SP)");
 int len,rank; 
  if(uart0_rx_length_temp>7)
  uart0_rx_cross[uart0_rx_length_temp-8]=RXBUF0;
  else
       uart0_rx_buf[uart0_rx_length_temp]=RXBUF0;

  uart0_rx_length_temp++;
// bit 0-7 saved in uart0-buf
//bit afterwards in   uart0-cross
  if(uart0_rx_buf[0]==0x20)
  {
    if(uart0_rx_length_temp==9)
    {       //len is the value of data length byte, and len make to rk,
    len=uart0_rx_buf[7];   /// "7 " is "20 FF FF FF FF FF FF [xx]"
      if( (len*8)%21==0)
                    rank= (len+1)*8/21;
       else rank=(len*8 ) /21 +1;
       uart0_rx_length=rank*4+8;
      
    }
     // uart0_rx_length=8+uart0_rx_buf[7];
      if(uart0_rx_length_temp==uart0_rx_length)
      {  
             len=uart0_rx_buf[7];
             if( (len*8)%21==0)
                     rank= (len+1)*8/21;
             else rank=(len*8 ) /21 +1;
             uart0_rx_length=rank*4+8;
            anticross16(uart0_rx_cross,4*rank,uart0_rx_bch);

             recv_of_bch(uart0_rx_bch,4*rank,uart0_rx_buf+8);
             uart0_rx_flag=1;
             
             uart0_rx_length_temp=0;
             uart0_rx_length=uart0_rx_buf[7]+8-2;  
             // uart0_rx_length  is the length of original length
               //8 is 7 add 1;
  
                uart0_rx_buf[7]-=2;
                  CRC_check(uart0_rx_buf,uart0_rx_length);
                   if(CRCHighByte==uart0_rx_buf[uart0_rx_length_temp-1]
                    &&CRCLowByte==uart0_rx_buf[uart0_rx_length_temp])
                             { CRCResult=1;}
           }
  
  }
  else
  {
    uart0_rx_length_temp=0;
  }

}


#pragma vector=UART1RX_VECTOR
__interrupt void UART1_RX(void)
{  
  //asm("bic.b	#0D0H,0(SP)");
  
  uart1_rx_buf[uart1_rx_length_temp]=RXBUF1;
  uart1_rx_length_temp++;
  
  if(uart1_rx_buf[0]==0x50)
  {
    if(uart1_rx_length_temp>=2)
    {
      uart1_rx_length=2+uart1_rx_buf[1];
      if(uart1_rx_length_temp==uart1_rx_length)
      {
        uart1_rx_flag=1;
        uart1_rx_length_temp=0;
      }
    }
  }
  else
  {
    uart1_rx_length_temp=0;
  }

}



#pragma vector=TIMERB0_VECTOR
__interrupt void Timer_B0(void)
{
if(P6OUT&BIT0)
   {
   whole=0;
    P6OUT&=~BIT0;
  }
  else
    {P6OUT|=BIT0;
   whole=1;
   }
//Send_UART0(ch,10+2);//----------------------------
 // Send_UART1(ch,7);
}
////////////////////////////////////////////////////