RC 4アルゴリズムの430実装

7663 ワード

RC 4アルゴリズムのMSP 430は、本プログラムには、キーのぶれ解消、SPI伝送データ、割り込み関数、
#include <MSP430x14x.h>

unsigned char keypoint=0;

unsigned char Rpoint=0;

int i;

unsigned char R_buff[8];

unsigned char T_buff[4];

unsigned char RR_buff[4];

char s_box[256];



void getkey(unsigned char *key,int key_len, char *s_box);

void main(void)

{

    WDTCTL = WDTPW + WDTHOLD;  /*        ,  OX5a80*/

    DCOCTL=0xE0;           //DCOCLK      ,

    BCSCTL1=0x85;          //  XT2     ,         。

    BCSCTL2=0x00;          //MCLk SMCLk      DCOCLK,    1  ,DCO      。

    P2DIR=0x00;            //  P2       

    P2IE=0x00;             //        

    P2IES=0x00;

    P2IFG=0x00;

    P2IE |=BIT3;           //P2.3     ,p2.3    ,     

    P2IES |=BIT3;



    P1DIR=0x0F;            //p1.0-P1.3     ,PxDIR      0

    P1OUT=0x00;            //P1        ,     

    P1IE=0x00;             //        

    P1IES=0x00;

    P1IFG=0x00;

    //  P1.4-P1.7   

    //                     ,     

    P1IE |= BIT4;	

    P1IES |= BIT4;	

    P1IE |= BIT5;	

    P1IES |= BIT5;

    P1IE |= BIT6;	

    P1IES |= BIT6;	

    P1IE |= BIT7;	

    P1IES |= BIT7;



    UCTL0 |= CHAR+SYNC+MM+SWRST;    //SPI   ,8   

    UTCTL0=CKPH+SSEL1+STC;        //3 SPI  ,         SMCLK,          

    UBR00=0x04;              //          ,4  

    UBR10=0x00;

    UMCTL0=0x00;             //          

    UCTL0 &= ~SWRST;        //    USART   , SWRST=0,SPI  

    P3SEL |=0x0F;            //P3.1-P3.3     

    P3DIR=0x0A;

    P4DIR |=0x03;              //P4.0 STE   ,p4.0     

    ME1 |=USPIE0;              //SPI0    

//    IE1 |= URXIE0;             // RX interrupt enable

    P4OUT |= BIT0;

    P4OUT |= BIT1;

    _EINT();                      /* Enable interrupts */



    while(1)

    {



      LPM0;

      _NOP();

    }

}

/******  ,      。******/

void delay(){

   unsigned char temp;

   for (temp=0xff;temp>0;temp--);

}







/*****    ,    。*****/



unsigned char key(void)

{

   unsigned char x;

   P1DIR=0x0F;//  p1.0-p1.3     ,p1.4-p1.7     

   P1OUT=0x07;    //     ,  P1.3  ,   P1.4-P1.7     0000 0111

   switch(P1IN&0xF0)

   {

    case 0xE0: x=0;      //p1.4    P1IN=1110 0111

               break;

    case 0xD0: x=1;      //p1.5    P1IN=1101 0111

               break;

    case 0xB0: x=2;

               break;

    case 0x70: x=3;

               break;

    default: P1OUT=0x0B; //     ,  p1.2    

              switch(P1IN&0xF0)

              {

              case 0xE0: x=4;

                         break;

              case 0xD0: x=5;

                         break;

              case 0xB0: x=6;

                         break;

              case 0x70: x=7;

                         break;

              default: P1OUT=0x0D; //     

                       switch(P1IN&0xF0)

                       {

                         case 0xE0: x=8;

                                    break;

                         case 0xD0: x=9;

                                    break;

                         case 0xB0: x=10;

                                    break;

                         case 0x70: x=11;

                                    break;

                         default: P1OUT=0x0E;//     

                                switch(P1IN&0xF0)

                                {

                                 case 0xE0: x=12;

                                            break;

                                 case 0xD0: x=13;

                                            break;

                                 case 0xB0: x=14;

                                            break;

                                 case 0x70: x=15;

                                            break;

                                }

                       }

              }

   }



   return (x);

}



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



unsigned char keyj(void)

{  unsigned char z;

   P1DIR=0x0F;          //  P1.0-P1.3     ,p1.4-p1.7     

   P1OUT=0x00;          //  P1OUT     

   z=(~(P1IN)&0xF0);      //  X  ,P1IN           ,     

   return(z);          //    ,   0;         0

}



unsigned char keyf(void)

{  unsigned char z;

   P2DIR=0x00;          //  p2       

   z=(P2IN&0x08);      //  X    0000 1000   P2.3     

   return(z);          //    ,   0;         0

}



#pragma vector=PORT1_VECTOR

__interrupt void port1key(void) //        

 {

    if(keypoint<8)

   { if(keyj()!=0x00)  //        

     {

      delay()  ;   //   

      if(keyj()!=0x00)  //         

      {



           R_buff[keypoint]=key();    //         

           keypoint++;





      }

    }

    }

    P1OUT=0x00;

    P1IFG=0x00;         //      





 }

/*****    ( 8 8       4 8 2   ,       0  )******/

void keyin()

{

    T_buff[0]=R_buff[0]*2*2*2*2+R_buff[1];

    T_buff[1]=R_buff[2]*2*2*2*2+R_buff[3];

    T_buff[2]=R_buff[4]*2*2*2*2+R_buff[5];

    T_buff[3]=R_buff[6]*2*2*2*2+R_buff[7];



}





/*****SPI       *****/



void initspi(void)

{

   UCTL0 |= CHAR+SYNC+MM+SWRST;    //SPI   ,8   ,   SWRST=1

   UTCTL0=CKPH+SSEL1+STC;        //3 SPI  ,         SMCLK

   UBR00=0x03;              //          ,3  ,SMCLK/3

   UBR10=0x00;

   UMCTL0=0x00;             //          

   UCTL0 &= ~SWRST;        //    USART   , SWRST=0,SPI  

   P3SEL |=0x0F;            //P3.1-P3.3     

   P4DIR |=0x01;              //P4.0 STE   ,p4.0     

   ME1 |=USPIE0;              //SPI0    



}



#pragma vector=PORT2_VECTOR

__interrupt void port2keyaffirm(void)

{



    if(keyf()==0x00)  //        

     {

      delay()  ;   //   

      if(keyf()==0x00)  //        

      {

        /*initspi();*/

         Rpoint=0;



      for(i=keypoint;i<8;i++)  //           8 ,   0

         {

           R_buff[i]=0;

         }



      keyin();



      getkey(R_buff,8, s_box);



     for(i=0;i<4+256;i++)          // 4     8        FPGA

      {

        if (i<4)

           P4OUT |= BIT0;//P4.0     (  ),SIMO UCLK    

        else

           P4OUT |= BIT1;

        _NOP();       //SIMO    ,            

        _NOP();       //UCLK USART  ,         

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        while(!(IFG1 & UTXIFG0));

        if (i<4)

           P4OUT &=~(BIT0);//P4.0     (  ),SIMO UCLK    

        else

           P4OUT &=~(BIT1);//p4.0     , FPGA          ,

        if(i<4)

          TXBUF0=T_buff[i];//SIMO UCLK          

        else

          TXBUF0=s_box[i-4];



        while(!(IFG1 & UTXIFG0));

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        _NOP();

        if (i<4)

           P4OUT |= BIT0;//P4.0     (  ),SIMO UCLK    

        else

           P4OUT |= BIT1;//P4.0     ,SIMO UCLK    

      }

     keypoint=0;



     P2IFG=0x00;         //      



   }

  }

}



#pragma vector=USART0RX_VECTOR

__interrupt void SPI0_rx (void)

{

  RR_buff[Rpoint]= RXBUF0;//RXBUF0      

  Rpoint++;

  TXBUF0=0xFF;//TXBUF0      ,   UTxIFGx

}



void getkey(unsigned char *key,int key_len, char *s_box)

{

  int i=0;

  int j=0;

  char temp;

  for(i=0;i<256;i++)

    s_box[i]=i;

  for(i=0;i<256;i++)

  {

    j=(j+key[i%key_len]+s_box[i])%256;

    temp=s_box[i];

    s_box[i]=s_box[j];

    s_box[j]=temp;

  }

}