A Small Control System Using 8051: irda.c Source File

00001 /**************************************************
00002 * Function: Driver for irda bit signal reveice  
00003 *           and process.
00004 * File:    irda.c
00005 * Author:  Book Chen
00006 * 2008.08.08 
00007 ****************************************************
00008 */
00009 #include "..\inc\includes.h"
00010 
00011 // Irda state machine
00012 #define StartState       0
00013 #define CustomCodeState  1
00014 #define CustomCodeBState 2
00015 #define DataCodeState    3
00016 #define DataCodeBState   4
00017 #define RepeatKeyState   5 
00018 
00019 //Irda input bit type
00020 #define cIrdaNull           0 
00021 #define cIrdaStart          1
00022 #define cIrdaData0          2
00023 #define cIrdaData1          3
00024 #define cIrdaStopBit        4
00025 #define cIrdaStopLeaderCode 5
00026 
00027 struct IRDA_CONTROL data IrdaCtrl;
00028 void F_IrdaPutKey(); 
00029 
00030 void F_IrdaPowerOnInit(void) LargeReentrant{
00031                       // For IRDA time counter
00032     TMOD|=0x10;       // Timer1 in mode 1...16 bit 
00033     TL1=0x00;         //   
00034     TH1=0x00;         // 
00035     TR1=0;            // Timer 1 start to count.
00036     ET1=0;            // Timer 1 is baudrate generator, disable timer interrupt 
00037                       // Irda use external int 0
00038     //PX0=1;          // Irda interrupt has high priority
00039     IT0=1;            // Interrupt trigger level...negitive edge tirgger
00040     EX0=1;      
00041 }
00042 void F_IrdaSvc(void) LargeReentrant{
00043     INT8U i=0;
00044 
00045         if(F_IrdaCheckKeyInBuffer()==IRDA_KEY_BUFFER_EMPTY) return;
00046         i=F_IrdaGetKey();                                // Get a irda key
00047         if(i==0x80){                                          
00048             LcmChar[47]='8';                             // Show '80' on lcm
00049             LcmChar[48]='0';
00050             F_MotorDirectionSet(1);                      // If ir key code is 0x80, set motor to run clockwise.
00051         }
00052         else if(i==0x40){                                // If ir key code is 0x80, set motor to run clockwise.
00053             LcmChar[47]='4';                             // Show '40' on lcm
00054             LcmChar[48]='0';
00055             F_MotorDirectionSet(0);                      // If ir key code is 0x80, set motor to run clockwise.       
00056         }                  
00057 }
00058 void F_IrdaBitProc(void){
00059     INT8U ucTemp;
00060     if(IrdaCtrl.Status&cIrdaSignalinput){    // Has a irda signal in
00061         ucTemp=IrdaCtrl.Type;                // Assign signal type...start, bit 0, bit 1,stop
00062         IrdaCtrl.Status&=~cIrdaSignalinput;  // Negect flag of irda signal
00063     }                            
00064     else return;
00065     if(ucTemp==cIrdaNull) return;            // No irda bit 
00066     if(ucTemp==cIrdaStopBit) return;         // No irda bit 
00067     if(ucTemp==cIrdaStopLeaderCode) IrdaCtrl.State=RepeatKeyState; // Repeat key code
00068     switch(IrdaCtrl.State){                  // Assigb bit to irda signal buffer 
00069         case StartState:
00070             if(ucTemp==cIrdaStart){
00071                 IrdaCtrl.State=CustomCodeState;
00072                 IrdaCtrl.CustomCode[0]=0;
00073                 IrdaCtrl.CustomCode[1]=0;
00074                 IrdaCtrl.DataCode[0]=0;
00075                 IrdaCtrl.DataCode[1]=0;
00076                 IrdaCtrl.BitCount=0;
00077             }   
00078             return;
00079         case CustomCodeState:
00080             if(ucTemp==cIrdaData0){
00081                 IrdaCtrl.CustomCode[0]<<=1;
00082                 IrdaCtrl.CustomCode[0]&=0xFE;
00083                 IrdaCtrl.BitCount++;
00084                 if(IrdaCtrl.BitCount==8){
00085                     IrdaCtrl.State=CustomCodeBState;
00086                     IrdaCtrl.BitCount=0;
00087                 }
00088             }
00089             else if(ucTemp==cIrdaData1){
00090                 IrdaCtrl.CustomCode[0]<<=1;
00091                 IrdaCtrl.CustomCode[0]|=0x01;
00092                 IrdaCtrl.BitCount++; 
00093                 if(IrdaCtrl.BitCount==8){
00094                     IrdaCtrl.State=CustomCodeBState;
00095                     IrdaCtrl.BitCount=0;
00096                 }
00097             }
00098             else{
00099                  IrdaCtrl.State=StartState;                
00100             }
00101             return; 
00102        case CustomCodeBState:
00103             if(ucTemp==cIrdaData0){
00104                 IrdaCtrl.CustomCode[1]<<=1;
00105                 IrdaCtrl.CustomCode[1]&=0xFE;
00106                 IrdaCtrl.BitCount++;
00107                 if(IrdaCtrl.BitCount==8){
00108                     IrdaCtrl.State=DataCodeState;
00109                     IrdaCtrl.BitCount=0;
00110                 }
00111             }
00112             else if(ucTemp==cIrdaData1){
00113                 IrdaCtrl.CustomCode[1]<<=1;
00114                 IrdaCtrl.CustomCode[1]|=0x01;
00115                 IrdaCtrl.BitCount++; 
00116                 if(IrdaCtrl.BitCount==8){
00117                     IrdaCtrl.State=DataCodeState;
00118                     IrdaCtrl.BitCount=0;
00119                 }
00120             }
00121             else{
00122                  IrdaCtrl.State=StartState;                
00123             }
00124             return;
00125        case DataCodeState:
00126             if(ucTemp==cIrdaData0){
00127                 IrdaCtrl.DataCode[0]<<=1;
00128                 IrdaCtrl.DataCode[0]&=0xFE;
00129                 IrdaCtrl.BitCount++;
00130                 if(IrdaCtrl.BitCount==8){
00131                     IrdaCtrl.State=DataCodeBState;
00132                     IrdaCtrl.BitCount=0;
00133                 }
00134             }
00135             else if(ucTemp==cIrdaData1){
00136                 IrdaCtrl.DataCode[0]<<=1;
00137                 IrdaCtrl.DataCode[0]|=0x01;
00138                 IrdaCtrl.BitCount++; 
00139                 if(IrdaCtrl.BitCount==8){
00140                     IrdaCtrl.State=DataCodeBState;
00141                     IrdaCtrl.BitCount=0;
00142                 }
00143             }
00144             else{
00145                  IrdaCtrl.State=StartState;                
00146             }
00147             return;
00148         case DataCodeBState:
00149             if(ucTemp==cIrdaData0){
00150                 IrdaCtrl.DataCode[1]<<=1;
00151                 IrdaCtrl.DataCode[1]&=0xFE;
00152                 IrdaCtrl.BitCount++;
00153                 if(IrdaCtrl.BitCount==8){   
00154                     F_IrdaPutKey();
00155                     IrdaCtrl.State=StartState;
00156                     IrdaCtrl.BitCount=0;                   
00157                 }
00158             }
00159             else if(ucTemp==cIrdaData1){
00160                 IrdaCtrl.DataCode[1]<<=1;
00161                 IrdaCtrl.DataCode[1]|=0x01;
00162                 IrdaCtrl.BitCount++; 
00163                 if(IrdaCtrl.BitCount==8){                                                        
00164                     F_IrdaPutKey();
00165                     IrdaCtrl.State=StartState;    // wait fot next irda  key input      
00166                     IrdaCtrl.BitCount=0;                  
00167                 }
00168             }
00169             else{
00170                  IrdaCtrl.State=StartState;                
00171             }
00172             return;
00173         case RepeatKeyState:                       // repeat key
00174             /*if(IrdaCtrl.KeyInPut==4){
00175                 if(IrdaCtrl.KeyInGet==0){;}        // Too many input keys, skip this key
00176                 else{
00177                     IrdaCtrl.KeyCode[0]=IrdaCtrl.KeyCode[4];
00178                     IrdaCtrl.KeyInPut=0;
00179                 }
00180             }
00181             else if((IrdaCtrl.KeyInPut+1)!=IrdaCtrl.KeyInGet){              
00182                 IrdaCtrl.KeyCode[IrdaKeyBuff.KeyInPut+1]=IrdaCtrl.DataCode[IrdaKeyBuff.KeyInPut];
00183                 IrdaCtrl.KeyInPut++;
00184             }
00185             */
00186             IrdaCtrl.BitCount=0; 
00187             IrdaCtrl.State=StartState;
00188             return;       
00189     }
00190 }
00191 void F_IrdaPutKey() LargeReentrant{                    // Put an Irda Key to key buffer
00192     if((IrdaCtrl.CustomCode[0]==0x61)&&(IrdaCtrl.CustomCode[1]==0xD6)){   //SUMC
00193         if(IrdaCtrl.KeyInPut==(IRDA_KEY_BUFFER_SIZE-1)){           
00194             if(IrdaCtrl.KeyInGet==0){;}                // Too many input keys, skip this key
00195             else{
00196                 IrdaCtrl.KeyInPut=0;
00197                 IrdaCtrl.KeyInBuffer[0]=IrdaCtrl.DataCode[0];           
00198             }
00199         }
00200         else{ 
00201             if((IrdaCtrl.KeyInPut+1)!=IrdaCtrl.KeyInGet){  
00202                 IrdaCtrl.KeyInPut++;
00203                 IrdaCtrl.KeyInBuffer[IrdaCtrl.KeyInPut]=IrdaCtrl.DataCode[0];    
00204             }
00205         }
00206     }
00207 }
00208 INT8U F_IrdaGetKey() LargeReentrant{                   // Get a key from Ir key buffer
00209     if(IrdaCtrl.KeyInGet!=IrdaCtrl.KeyInPut){
00210         if(IrdaCtrl.KeyInGet==(IRDA_KEY_BUFFER_SIZE-1)){
00211             IrdaCtrl.KeyInGet=0;
00212             return IrdaCtrl.KeyInBuffer[0];
00213         }
00214         else{
00215             IrdaCtrl.KeyInGet++;
00216             return IrdaCtrl.KeyInBuffer[IrdaCtrl.KeyInGet];
00217         }
00218     }
00219     return 0xFF;
00220 } 
00221 
00222 INT8U F_IrdaCheckKeyInBuffer() LargeReentrant{  // check key in buffer status
00223     if(IrdaCtrl.KeyInPut<(IRDA_KEY_BUFFER_SIZE-1)){
00224         if((IrdaCtrl.KeyInPut+1)==IrdaCtrl.KeyInGet) return IRDA_KEY_BUFFER_FULL;    
00225         else if(IrdaCtrl.KeyInGet!=IrdaCtrl.KeyInPut) return IRDA_KEY_BUFFER_NOT_FULL;        
00226         else return IRDA_KEY_BUFFER_EMPTY;                                                 
00227     }
00228     else{
00229         if(IrdaCtrl.KeyInGet==0) return IRDA_KEY_BUFFER_FULL;                            
00230         else if(IrdaCtrl.KeyInGet!=IrdaCtrl.KeyInPut) return IRDA_KEY_BUFFER_NOT_FULL;        
00231         else if(IrdaCtrl.KeyInGet==(IRDA_KEY_BUFFER_SIZE-1)) return IRDA_KEY_BUFFER_EMPTY;   
00232     }
00233 }
00234 
00235 void F_IrdaGetSignalType() LargeReentrant{
00236     if((IrdaCtrl.unTime.uc[0]>=46)&&((IrdaCtrl.unTime.uc[0]<=50))){        
00237         IrdaCtrl.Type=cIrdaStart; 
00238     }
00239     else if((IrdaCtrl.unTime.uc[0]>=3)&&((IrdaCtrl.unTime.uc[0]<=5))){     
00240         IrdaCtrl.Type=cIrdaData0; 
00241     }
00242     else if((IrdaCtrl.unTime.uc[0]>=7)&&((IrdaCtrl.unTime.uc[0]<=9))){     
00243         IrdaCtrl.Type=cIrdaData1; 
00244     }
00245     else if((IrdaCtrl.unTime.uc[0]>=38)&&((IrdaCtrl.unTime.uc[0]<=42))){   
00246         IrdaCtrl.Type=cIrdaStopLeaderCode; 
00247     }  
00248     else if((IrdaCtrl.unTime.uc[0]>=112)&&((IrdaCtrl.unTime.uc[0]<=216))){ 
00249         IrdaCtrl.Type=cIrdaStopBit; 
00250     }                            
00251     else IrdaCtrl.Type=cIrdaNull;                                          
00252 }    
00253