coded.c

msp430+469的C程序

#include <msp430x14x.h>
#define lamp_rec     0x01;
#define lamp_send    0x02;
#define watdog       0x08;
#define STB          0x01;
#define TX_DATA      0x02;//P1.1
#define PTT          0x04;//P1.2
#define TXEN         0x10;//P1.4
#define CD           0x20;//P1.5
 
unsigned char    TRflag;
unsigned char    max;
unsigned char    RECflag=0,sendflag;
unsigned char    min_bit7;
unsigned char    min;       
unsigned char    rec_end,address; 
unsigned int     i=0,j=0,reclong,sendlong;
unsigned char    recbuff[512]={0x31,0x32,'3','4','5','6','7','8','9','0'};
unsigned char    recbuff1[400]={0x41,0x32,'3','4','5','6','7','8','9','0'};

void Send_Bytetopc(unsigned char  ) ; //函数声明
void recdata(void),rec_byte(void);
void rfinit(void),delay(void),delay(void),init(void);
void send_datatotr(void),send_bytetotr( unsigned char);
//void coded(void),decode(void);

void main(void)
{  unsigned  int m;
    
   init();
  // rfinit();
   P1OUT&=~PTT;   //close PTT
   P1OUT|=TXEN;   //CLOSE PTT
   _EINT();                                 // Enable interrupts 
   while(1)
     {    
       if(RECflag==1)                //接收幀同步
          {  /* if(min_bit7&0x80)
                 {m|=0x80000000;
                  }
              else
                 {m&=0x7fffffff;
                 } 
             if(m==0xabababab)     //0x3b28大吉电台同步码
                { RECflag=0;
               recdata();
                }
               m>>=1;
              */
               if(min_bit7&0x80)
                 {m|=0x0001;
                  }
              else
                 {m&=0xfffe;
                 } 
             if(m==0x3b28)     //0x3b28大吉电台同步码
                { RECflag=0;
               recdata();
                }
               m<<=1;
              RECflag=0;
          }
             
       if(sendlong>=1)
           {          
           if(sendlong==0x03)
                {P1OUT|=PTT;   //open PTT
            
                }
              j++;
          if((sendlong>=3)&&(j>=500))               //PC send data to 430 end
              { j=P1IN&CD; 
                while(j>0)  //CD inspect
                    {j=P1IN&CD; 
                    }
                 P1OUT&=~TXEN;   //open TXEN  
                 P2OUT&=~lamp_send;//open lamp
                 send_datatotr();  //send data
                 sendlong=0; j=0; //clear 
                 P1OUT&=~PTT;   //close PTT
                 P1OUT|=TXEN;   //CLOSE PTT
                 P2OUT|=lamp_send;//close lamp
               }
           }
     }
}

//*******************************************************
void recdata(void)  //receive transifer all dataes
{ unsigned int ii;
          P2OUT &=~lamp_rec;//open lamp
            for(ii=0;ii<20;ii++)//rec data
                 {  rec_byte();
                 recbuff[ii]=min;
                 }
               P2OUT |=lamp_rec;//close lamp
               rec_end=1;
         //  if(rec_end==1)   //send data to PC
         //     {_DINT();
              
               for(ii=0;ii<reclong;ii++)
                  {Send_Bytetopc(recbuff1[ii]);//send data to pc
                  }
              rec_end=0;
         //    _EINT();
              
 }

void rec_byte(void)//   receive transifer 1B data
{ unsigned char i=0;
    for(i=0;i<8;i++)//rec 8 bit
      { // min>>=1;
           min<<=1;      
      while(RECflag!=1);
       min_bit7&=0x80;
       min_bit7>>=7;
       min^=min_bit7;//receiver 1bit
        RECflag=0;
      }
}
interrupt[PORT1_VECTOR] void rec_port (void)
{    sendflag=0x01;//send 1bit
      RECflag=1;                                       
      min_bit7 = P1IN;//receiver 1bit
      P1IFG=0x00;
  }
//*******************************************************
//*****************************************************
void send_datatotr(void)//send all data to transifer.
 {unsigned int ii,jj;
   unsigned char long_h,long_l;
   
   P1IE =0x01;                           // P1.0 inte_ enable
   for(ii=0;ii<500;ii++)
     {delay();
     }
    jj=sendlong;
    long_l=jj;
    jj>>=8;
    long_h=jj;
     for(ii=0;ii<5;ii++)//bit syn
        { send_bytetotr(0x55);
        }
     for(ii=0;ii<4;ii++)   //byte syn
         { send_bytetotr(0xab);
         }
     for(ii=0;ii<3;ii++)// file longth
         { 
          send_bytetotr(long_h);
           send_bytetotr(long_l);
         }
    //   send_bytetotr(0xaa);//potect code
      for(ii=0;ii<sendlong;ii++)// file 
        {  send_bytetotr(recbuff1[ii]);
        }
    
     send_bytetotr(0x55);
     P1IE =0x40;   // P1.0 inte_disable, P1.6 inte_enable   
  }
 
void send_bytetotr(unsigned char Send1B)//send 1B to transifer.
 {   unsigned char mask=0x01,kk;
       for(kk=0;kk<8;kk++) //send 8 bit
        {   while(sendflag!=0x01); 
                  sendflag=0;
            if(mask&Send1B)
               { P1OUT |=TX_DATA;//      out 1, TXdata=P1.3;
               }
           else
               { P1OUT &=~TX_DATA;//         out 0
               }
            Send1B>>=1;   
         }
 }
 
 interrupt[UART0RX_VECTOR] void usart0_rx (void)//0 port
  {//  while ((IFG1 & UTXIFG0) == 0);        // USART0 TX buffer ready?
          //TXBUF0 = RXBUF0;                      // RXBUF0 to TXBUF0
           if(sendlong>=200)
                    {sendlong=200;
                    }
         recbuff[sendlong++]=RXBUF0;          //receiver 1B from PC 
            j=0;  
  }

// interrupt[UART1RX_VECTOR] void usart1_rx (void) //1port
//{
 // while ((IFG2 & UTXIFG1) == 0);        // USART1 TX buffer ready?
 // TXBUF1 = RXBUF1;                      // RXBUF1 to TXBUF1
 // recbuff[sendlong++]=RXBUF1;          //receiver 1B from PC 
 //  j=0;                                //clear num
//}
//************************************************************
void rfinit(void)  //RF init
 {delay();
 }
 //**********************************************************
void init(void)   //msp430  init
{//unsigned int i;
  WDTCTL = WDTPW + WDTHOLD;             // Stop WDT停止看门狗
  BCSCTL1 |= XTS;                       // ACLK = LFXT1 = HF XTAL
  P1DIR |= 0x1e;                        // Set P1.0\5\6\7 to input direction
  P1IE =0x40;                           // P1.6 inte_ enable
  //P1IES = 0x00;                         //up edge int 
  P1IES = 0x041;                         //p1.0\6 down edge int 
  P1OUT=0x00;
  //********************
  P2DIR |= 0xff;                        // Set P2 to output direction
  P2IE =0x00;                           // P2.0 int disable
  P2IES = 0x00;                         //up edge int 
 // P1IES = 0x01;                         //down edge int 
  P2OUT=0xff;
 // do 
 // {
 // IFG1 &= ~OFIFG;                       // Clear OSCFault flag
 // for (i = 0xFF; i > 0; i--);           // Time for flag to set
 // }
 // while ((IFG1 & OFIFG) == OFIFG);      // OSCFault flag still set?                
  //*********************************port0
  BCSCTL2 |= SELM1+SELM0;               // MCLK = LFXT1 (safe)
  UCTL0 = CHAR;                         // 8-bit character
  UTCTL0 = SSEL0;                       // UCLK = ACLK
  UBR00 = 0xc0;                         // 1.8432Mhz/9600 - 192
  //UBR00 = 0x60;                         // 1.8432Mhz/19200 - 96
  //UBR00 = 0x74;                         // 3.58Mhz/9600 - 372
  UBR10 = 0x00;                         //
  UMCTL0 = 0x00;                        // no modulation
  ME1 |= UTXE0 + URXE0;                 // Enable USART0 TXD/RXD
  IE1 |= URXIE0;                        // Enable USART0 RX interrupt
  P3SEL |= 0x30;                        // P3.4,5 = USART0 TXD/RXD
  P3DIR |= 0x10;                        // P3.4 output direction
  //*************************************port1
 
  UCTL1 = CHAR;                         // 8-bit character
  UTCTL1 = SSEL0;                       // UCLK = ACLK
 // UBR01 = 0x04;                         // 76.8khz/19200 - 04h
   UBR01 = 0x60;                         // 1.8432Mhz/19200 - 96
  //UBR01 = 0x20;                         // 1.8432Mhz/57600 - 32
  //UBR01 = 0x10;                         // 1.8432Mhz/115200 - 16
   //UBR01 = 0x80;                         // 7.3728Mhz/57600 - 128
    //UBR01 = 0x40;                         // 7.3728Mhz/115200 - 64
  UBR11 = 0x00;                         //
  UMCTL1 = 0x00;                        // no modulation
   ME2 |= UTXE1 + URXE1;                 // Enable USART0 TXD/RXD
  //IE2 |= URXIE1;                        // Enable USART1 RX interrupt
  P3SEL |= 0xc0;                        // P3.6,7 = USART1 TXD/RXD
  P3DIR |= 0x40;                        // P3.6 output direction
 //_EINT();                              // Enable interrupts
  // FCTL2 = FWKEY + FSSEL0 + FN0;      // 定义FLASH时序发生器输入时钟
}

void Send_Bytetopc(unsigned char SendByte)
 {//while ((IFG2 & UTXIFG1) == 0);        // USART1 TX buffer ready?
  // TXBUF1 = SendByte;
     while ((IFG1 & UTXIFG0) == 0);        // USART0 TX buffer ready?
       TXBUF0 = SendByte;                    //  to TXBUF0
           
  }

void delay(void)
 { unsigned int i;
  i=0;
   do (i++);
   while (i != 10);
 }

//***********************end