shell.c File Reference

#include "includes.h"

Go to the source code of this file.

Defines

#define ShellIdleState   0
#define ShellInitial0State   1
#define ShellInitial1State   2
#define ShellInitial2State   3
#define ShellWaitCommandState   4
#define ShellDispatchState   5
#define ShellExecuteState   6
#define ShellExecuteStopState   7
#define ExecuteIdleState   0
#define ExecuteStartState   1
#define ExecuteRunState   2
#define ItemInfo   0
#define ItemHelp   1
#define ItemExit   2
#define ItemBye   3
#define ItemQuit   4
#define ItemQuit2   5
#define ItemIcsperase   6
#define ItemIcspread   7
#define ItemIcspwrite   8
#define ArgumentSearchState   0
#define ArgumentGoThroughState   1
#define ArgumentDoneState   2

Functions

void F_ShellInit (void)
void F_ShellSvc (void)
void F_ShellArgumentInitial (void)
void F_ShellArgumentSvc (unsigned char Data)
void F_ShellArgumentParser (void)
U8 F_ShellArgumentCheck (void)
void F_ShellArgumentExecute (unsigned char **Argv, unsigned char Argc)
void F_ShellArgumentReset (void)
void F_ShellArgumentBs (void)
void F_ShellArgumentDel (void)
void F_ShellArgumentKeyPut (unsigned char Data)
void F_ShellArgumentIns (void)
void F_ShellArgumentHome (void)
void F_ShellArgumentEnd (void)
void F_ShellArgumentPageUp (void)
void F_ShellArgumentPageDown (void)
void F_ShellArgumentArrowUp (void)
void F_ShellArgumentArrowDown (void)
void F_ShellArgumentArrowLeft (void)
void F_ShellArgumentArrowRight (void)
void F_ShellCodeBank (void)

Variables

U8 info [] = "info"
U8 help [] = "help"
U8 myexit [] = "exit"
U8 bye [] = "bye"
U8 quit [] = "quit"
U8 quit2 [] = "q"
U8 icsperase [] = "icsperase"
U8 icspread [] = "icspread"
U8 icspwrite [] = "icspwrite"
U8 * ShellCommand []
U8 SourceFilename [100]
FILE * pStream
U32 ImageSize
SHELL_CONTROL ShellCtrl
ARGUMENT_CONTROL ArgumentCtrl

Define Documentation

#define ArgumentDoneState   2

Definition at line 451 of file shell.c.

#define ArgumentGoThroughState   1

Definition at line 450 of file shell.c.

#define ArgumentSearchState   0

Definition at line 449 of file shell.c.

#define ExecuteIdleState   0

Definition at line 20 of file shell.c.

#define ExecuteRunState   2

Definition at line 22 of file shell.c.

#define ExecuteStartState   1

Definition at line 21 of file shell.c.

#define ItemBye   3

Definition at line 27 of file shell.c.

#define ItemExit   2

Definition at line 26 of file shell.c.

#define ItemHelp   1

Definition at line 25 of file shell.c.

#define ItemIcsperase   6

Definition at line 30 of file shell.c.

#define ItemIcspread   7

Definition at line 31 of file shell.c.

#define ItemIcspwrite   8

Definition at line 32 of file shell.c.

#define ItemInfo   0

Definition at line 24 of file shell.c.

#define ItemQuit   4

Definition at line 28 of file shell.c.

#define ItemQuit2   5

Definition at line 29 of file shell.c.

#define ShellDispatchState   5

Definition at line 16 of file shell.c.

#define ShellExecuteState   6

Definition at line 17 of file shell.c.

#define ShellExecuteStopState   7

Definition at line 18 of file shell.c.

#define ShellIdleState   0

Definition at line 11 of file shell.c.

#define ShellInitial0State   1

Definition at line 12 of file shell.c.

#define ShellInitial1State   2

Definition at line 13 of file shell.c.

#define ShellInitial2State   3

Definition at line 14 of file shell.c.

#define ShellWaitCommandState   4

Definition at line 15 of file shell.c.

Function Documentation

void F_ShellArgumentArrowDown ( void   ) 

Definition at line 619 of file shell.c.

00619                                    {
00620     #if(DEBUG_SHELL_KEY==1)
00621         F_StringPut("\r\n key_arrow_down");
00622     #endif
00623 }

void F_ShellArgumentArrowLeft ( void   ) 

Definition at line 624 of file shell.c.

00624                                    {
00625     #if(DEBUG_SHELL_KEY==1)
00626         F_StringPut("\r\n key_arrow_left");
00627     #endif
00628     if(ArgumentCtrl.Index==0){;}
00629     else{
00630         ArgumentCtrl.Index--;
00631     }
00632 }

void F_ShellArgumentArrowRight ( void   ) 

Definition at line 633 of file shell.c.

00633                                     {
00634     #if(DEBUG_SHELL_KEY==1)
00635         F_StringPut("\r\n key_arrow_right");
00636     #endif
00637     if(ArgumentCtrl.Index==ArgumentCtrl.Put){;}
00638     else{
00639         if(ArgumentCtrl.Index<ArgumentCtrl.Put) ArgumentCtrl.Index++;
00640     }
00641 }

void F_ShellArgumentArrowUp ( void   ) 

Definition at line 614 of file shell.c.

00614                                  {
00615     #if(DEBUG_SHELL_KEY==1)
00616         F_StringPut("\r\n key_arrow_up");
00617     #endif
00618 }

void F_ShellArgumentBs ( void   ) 

Definition at line 516 of file shell.c.

00516                             {
00517     unsigned char i;
00518     #if(DEBUG_SHELL_KEY==1)
00519         F_StringPut("\r\n key_bs");
00520     #endif
00521     if(ArgumentCtrl.Put==ArgumentCtrl.Index){
00522         if(ArgumentCtrl.Put==0){;}
00523         else{
00524             ArgumentCtrl.Put--;
00525             ArgumentCtrl.Index--;
00526         }
00527     }
00528     else{
00529         if(ArgumentCtrl.Index==0){;}
00530         else{
00531             ArgumentCtrl.Index--;
00532             ArgumentCtrl.Put--;
00533             i=ArgumentCtrl.Index;
00534             for(;i<=ArgumentCtrl.Put;i++){
00535                 ArgumentCtrl.Data[i]=ArgumentCtrl.Data[i+1];
00536             }
00537         }
00538     }
00539 }

U8 F_ShellArgumentCheck ( void   ) 

Definition at line 502 of file shell.c.

00502                              {
00503     if(ArgumentCtrl.HasInput==TRUE) return TRUE;
00504     else return FALSE;
00505 }

void F_ShellArgumentDel ( void   ) 

Definition at line 540 of file shell.c.

00540                              {
00541     unsigned char i;
00542     #if(DEBUG_SHELL_KEY==1)
00543         F_StringPut("\r\n key_del");
00544     #endif
00545     if(ArgumentCtrl.Put==ArgumentCtrl.Index){;} // nothing to delete
00546     else{                                           // xxxxyyyy -> xxxyyyy
00547        ArgumentCtrl.Put--;
00548        i=ArgumentCtrl.Index;
00549        for(;i<=ArgumentCtrl.Put;i++){
00550            ArgumentCtrl.Data[i]=ArgumentCtrl.Data[i+1];
00551        }
00552     }
00553 }

void F_ShellArgumentEnd ( void   ) 

Definition at line 598 of file shell.c.

00598                              {
00599     #if(DEBUG_SHELL_KEY==1)
00600         F_StringPut("\r\n key_end");
00601     #endif
00602     ArgumentCtrl.Index=ArgumentCtrl.Put;
00603 }

void F_ShellArgumentExecute ( unsigned char **  Argv,
unsigned char  Argc 
)

Definition at line 507 of file shell.c.

00507                                                                     {
00508 
00509 }

void F_ShellArgumentHome ( void   ) 

Definition at line 592 of file shell.c.

00592                               {
00593     #if(DEBUG_SHELL_KEY==1)
00594         F_StringPut("\r\n key_home");
00595     #endif
00596     ArgumentCtrl.Index=0;
00597 }

void F_ShellArgumentInitial ( void   ) 

Definition at line 290 of file shell.c.

00290                                  {
00291     ArgumentCtrl.Put=0;
00292     ArgumentCtrl.Index=0;
00293     ArgumentCtrl.Insert=FALSE;
00294     ArgumentCtrl.Argc=0;
00295     ArgumentCtrl.Status=0;
00296     ArgumentCtrl.HasInput=FALSE;
00297     ArgumentCtrl.State=ArgumentRxState;
00298 }

void F_ShellArgumentIns ( void   ) 

Definition at line 585 of file shell.c.

00585                              {
00586     #if(DEBUG_SHELL_KEY==1)
00587         F_StringPut("\r\n key_ins");
00588     #endif
00589     //if(ArgumentCtrl.Insert==TRUE) ArgumentCtrl.Insert=FALSE;
00590     //else ArgumentCtrl.Insert=TRUE;
00591 }

void F_ShellArgumentKeyPut ( unsigned char  Data  ) 

Definition at line 554 of file shell.c.

00554                                               {
00555     unsigned char i;
00556 
00557     if(ArgumentCtrl.Put==ArgumentCtrl.Index){
00558         ArgumentCtrl.Data[ArgumentCtrl.Index]=Data;
00559         if(ArgumentCtrl.Put<ARGUMENT_INDEX_MAX){
00560             ArgumentCtrl.Put++;
00561             ArgumentCtrl.Index++;
00562         }
00563     }
00564     else{
00565         if(Data==0x0d){
00566             ArgumentCtrl.Data[ArgumentCtrl.Put]=Data;
00567         }
00568         else{
00569             if(ArgumentCtrl.Insert==TRUE){
00570                 i=ArgumentCtrl.Put;
00571                 for(;i>=ArgumentCtrl.Index;i--){
00572                     ArgumentCtrl.Data[i+1]=ArgumentCtrl.Data[i];
00573                 }
00574                 ArgumentCtrl.Data[ArgumentCtrl.Index]=Data;
00575                 if(ArgumentCtrl.Put<ARGUMENT_INDEX_MAX) ArgumentCtrl.Put++;
00576                 ArgumentCtrl.Index++;
00577             }
00578             else{
00579                 ArgumentCtrl.Data[ArgumentCtrl.Index]=Data;
00580                 ArgumentCtrl.Index++;
00581             }
00582         }
00583     }
00584 }

void F_ShellArgumentPageDown ( void   ) 

Definition at line 609 of file shell.c.

00609                                   {
00610     #if(DEBUG_SHELL_KEY==1)
00611         F_StringPut("\r\n key_page_down");
00612     #endif
00613 }

void F_ShellArgumentPageUp ( void   ) 

Definition at line 604 of file shell.c.

00604                                 {
00605     #if(DEBUG_SHELL_KEY==1)
00606         F_StringPut("\r\n key_page_up");
00607     #endif
00608 }

void F_ShellArgumentParser ( void   ) 

Definition at line 452 of file shell.c.

00452                                 {
00453     unsigned char Index;
00454     unsigned char State;
00455     unsigned char Status;
00456     //unsigned char i;
00457     //unsigned char **ppArgv;
00458 
00459     Index=0;
00460     Status=0;
00461     ArgumentCtrl.Argc=0;
00462     State=ArgumentSearchState;
00463     while(1){
00464         switch(State){
00465             case ArgumentSearchState:
00466                 if(ArgumentCtrl.Data[Index]==0x20){;}       // " "
00467                 else if(ArgumentCtrl.Data[Index]==0x0d){  // enter key
00468                     ArgumentCtrl.Data[Index]=0;
00469                     ArgumentCtrl.Data[Index+1]=0x0d;
00470                     State=ArgumentDoneState;
00471                 }
00472                 else{
00473                     ArgumentCtrl.pArgv[ArgumentCtrl.Argc]=&ArgumentCtrl.Data[Index];
00474                     ArgumentCtrl.Argc++;
00475                     State=ArgumentGoThroughState;
00476                 }
00477                 break;
00478             case ArgumentGoThroughState:
00479                 if(ArgumentCtrl.Data[Index]==0x0d){
00480                     ArgumentCtrl.Data[Index]=0;
00481                     ArgumentCtrl.Data[Index+1]=0x0d;
00482                     State=ArgumentDoneState;
00483                 }
00484                 else if(ArgumentCtrl.Data[Index]==0x20){
00485                     ArgumentCtrl.Data[Index]=0;
00486                     State=ArgumentSearchState;
00487                 }
00488                 break;
00489             case ArgumentDoneState:
00490                 if(ArgumentCtrl.Put==ARGUMENT_INDEX_MAX){ // too many input
00491                     F_ShellArgumentReset();
00492                     return;
00493                 }
00494                 ArgumentCtrl.HasInput=TRUE;
00495                 return;
00496                 //if(ArgumentCtrl.Argc!=0) F_ShellArgumentExecute(&ArgumentCtrl.pArgv,ArgumentCtrl.Argc);
00497                 //break;
00498         }
00499         Index++;
00500     }
00501 }

void F_ShellArgumentReset ( void   ) 

Definition at line 510 of file shell.c.

00510                                {
00511     ArgumentCtrl.Index=0;
00512     ArgumentCtrl.Put=0;
00513     ArgumentCtrl.Argc=0;
00514     ArgumentCtrl.HasInput=FALSE;
00515 }

void F_ShellArgumentSvc ( unsigned char  Data  ) 

Definition at line 300 of file shell.c.

00300                                            {
00301     switch(ArgumentCtrl.State){
00302         case ArgumentIdleState:
00303             break;
00304         case ArgumentRxState:            
00305             // process special keys
00306             if(Data==ASCII_ESC){
00307                 ArgumentCtrl.Status=0;
00308                 ArgumentCtrl.Status=MeetEscKey;
00309                 return;
00310             }
00311             else if(ArgumentCtrl.Status==MeetEscKey){
00312                 if(Data==0x5b){
00313                     ArgumentCtrl.Status=HasEscXkey;
00314                     return;
00315                 }
00316                 else{
00317                     ArgumentCtrl.Status=0; // meet single esc key, not a special key
00318                 }
00319             }
00320             else if(ArgumentCtrl.Status==HasEscXkey){
00321                 switch(Data){
00322                     case KEY_HOME:
00323                         F_ShellArgumentHome();
00324                         ArgumentCtrl.Status=0;
00325                         return;
00326                     case KEY_END:
00327                         F_ShellArgumentEnd();
00328                         ArgumentCtrl.Status=0;
00329                         return;
00330                     case KEY_PAGE_UP:
00331                         F_ShellArgumentPageUp();
00332                         ArgumentCtrl.Status=0;
00333                         return;
00334                     case KEY_PAGE_DOWN:
00335                         ArgumentCtrl.Status=HasPageDown;
00336                         return;
00337                     case KEY_LEFT_ARROW:
00338                         F_ShellArgumentArrowLeft();
00339                         ArgumentCtrl.Status=0;
00340                         return;
00341                     case KEY_RIGHT_ARROW:
00342                         F_ShellArgumentArrowRight();
00343                         ArgumentCtrl.Status=0;
00344                         return;
00345                     case KEY_UP_ARROW:
00346                         F_ShellArgumentArrowUp();
00347                         ArgumentCtrl.Status=0;
00348                         return;
00349                     case KEY_DOWN_ARROW:
00350                         F_ShellArgumentArrowDown();
00351                         ArgumentCtrl.Status=0;
00352                         return;
00353                     default:
00354                         ArgumentCtrl.Status=0;
00355                         return; // skip this code no matter what it is
00356                 }
00357                 //ArgumentCtrl.Status=0;
00358             }
00359             else if(ArgumentCtrl.Status==HasPageDown){
00360                 if(Data==0x4a){
00361                     F_ShellArgumentPageDown();
00362                     ArgumentCtrl.Status=0;
00363                     return;
00364                 }
00365                 ArgumentCtrl.Status=0;
00366             }
00367             switch(Data){
00368                 case  ASCII_NUL: // ^@
00369                     break;
00370                 case  ASCII_SOH: // ^A
00371                     break;
00372                 case  ASCII_STX: // ^B
00373                     break;
00374                 case  ASCII_ETX: // ^C
00375                     break;
00376                 case  ASCII_EOT: // ^D
00377                     break;
00378                 case  ASCII_ENQ: // ^E
00379                     break;
00380                 case  ASCII_ACK: // ^F
00381                     break;
00382                 case  ASCII_BEL: // ^G
00383                     break;
00384                 case  ASCII_BS:  // ^H
00385                     F_ShellArgumentBs();
00386                     //F_HidPs2KeyDispatch(Data);
00387                     //F_GuiTextBufferPut(Data);
00388                     break;
00389                 case  ASCII_HT:  // ^I
00390                     break;
00391                 case  ASCII_LF:  // ^J
00392                     break;
00393                 case  ASCII_VT:  // ^K
00394                     break;
00395                 case  ASCII_FF:  // ^L
00396                     break;
00397                 case  ASCII_CR:  // ^M
00398                     F_ShellArgumentKeyPut(Data);
00399                     F_ShellArgumentParser();
00400                     break;
00401                 case  ASCII_SO:  // ^N
00402                     break;
00403                 case  ASCII_SI:  // ^O
00404                     break;
00405                 case  ASCII_DLE: // ^P
00406                     break;
00407                 case  ASCII_DC1: // ^Q
00408                     break;
00409                 case  ASCII_DC2: // ^R
00410                     break;
00411                 case  ASCII_DC3: // ^S
00412                     break;
00413                 case  ASCII_DC4: // ^T
00414                     break;
00415                 case  ASCII_NAK: // ^U
00416                     break;
00417                 case  ASCII_SYN: // ^V
00418                     break;
00419                 case  ASCII_ETB: // ^W
00420                     break;
00421                 case  ASCII_CAN: // ^X
00422                     break;
00423                 case  ASCII_EM:  // ^Y
00424                     break;
00425                 case  ASCII_SUB: // ^Z
00426                     break;
00427                 //case  ASCII_ESC: // ^[
00428                 //    break;
00429                 case  ASCII_FS:   /* ^\  */
00430                     break;
00431                 case  ASCII_GS:  // ^]
00432                     break;
00433                 case  ASCII_RS:  // ^^
00434                     break;
00435                 case  ASCII_US:  // ^_
00436                     break;
00437                 case  ASCII_DEL: //
00438                     F_ShellArgumentDel();
00439                     break;
00440                 default:
00441                     if((Data>=0x20)&&(Data<=0x7e)){
00442                         F_ShellArgumentKeyPut(Data);
00443                     }
00444                     break;
00445             }
00446     }
00447 }

void F_ShellCodeBank ( void   ) 

Definition at line 643 of file shell.c.

00643                           {
00644     /*
00645     if(F_SpiFlashRdid()==NO_ERROR) printf("\n SPI FLASH found.");
00646     else{ 
00647         printf("\n SPI FLASH no found");    
00648         ShellCtrl.ExecuteState=ExecuteIdleState;
00649         break;
00650     } 
00651     
00652     if(ArgumentCtrl.Argc==1){
00653         printf("\n No input file.");                                
00654         ShellCtrl.ExecuteState=ExecuteIdleState;
00655         break;
00656     } 
00657     printf("\n Input file is %20s ",ArgumentCtrl.pArgv[1]);
00658     F_SystemStringCopy(SourceFilename,ArgumentCtrl.pArgv[1]);
00659     pStream=NULL;
00660     if(SourceFilename[0]!=0) pStream=fopen((char *)SourceFilename,"rb");
00661     if(pStream==NULL){                          
00662         printf("\n Can not open file %20s.",ArgumentCtrl.pArgv[1]);                                
00663         ShellCtrl.ExecuteState=ExecuteIdleState;
00664         break;
00665     }
00666     fseek(pStream,0L,SEEK_END);
00667     FileEnd=ftell(pStream);
00668     fseek(pStream,0L,SEEK_SET);
00669     FileStart=ftell(pStream);
00670     ImageSize=FileEnd-FileStart;
00671     printf("\n File size is %8x ",ImageSize);
00672     F_WriterSpiFlashWrite0(pStream,0);          
00673     */
00674 }

void F_ShellInit ( void   ) 

Definition at line 64 of file shell.c.

00064                       {
00065     ShellCtrl.State=ShellInitial0State;
00066     ShellCtrl.Status=0;
00067     ShellCtrl.ExecuteState=0;
00068     ShellCtrl.ExecuteItem=0;
00069     ShellCtrl.Exit=FALSE;
00070 }

void F_ShellSvc ( void   ) 

Definition at line 72 of file shell.c.

00072                      {
00073     U8 Data,i;
00074     //U32 FileEnd,FileStart;
00075     //U32 Address,Length;
00076     U8 Argc;
00077     //unsigned char *pData;
00078     U8 **ppArgv;    // pointer of pArgv
00079     //U32 j;
00080 
00081     switch(ShellCtrl.State){
00082         case ShellIdleState:
00083             break;          
00084         case ShellInitial0State:    
00085             printf("\n*******************************");
00086             printf("\n Hello, welcome to use MYLPT.");
00087             printf("\n type <help> for help");
00088             printf("\n*******************************");
00089             printf("\n$>");
00090             F_ShellArgumentInitial();
00091             ShellCtrl.State=ShellWaitCommandState;
00092             break;
00093         case ShellInitial1State:    
00094             break;
00095         case ShellInitial2State:    
00096             break;
00097         case ShellWaitCommandState:
00098             Data=getch();
00099             putch(Data);
00100             F_ShellArgumentSvc(Data);
00101             if(F_ShellArgumentCheck()==TRUE) ShellCtrl.State=ShellDispatchState;
00102             break;
00103         case ShellDispatchState:
00104             Argc=ArgumentCtrl.Argc;
00105             ppArgv=(unsigned char **)&ArgumentCtrl.pArgv;
00106             if(Argc>0){
00107                 for(i=0;;i++){
00108                     if(ShellCommand[i]==(U8 *)0){
00109                         printf("\r\n command not found");
00110                         break;
00111                     }
00112                     if(strcmp((char *)ArgumentCtrl.pArgv[0],(char *)ShellCommand[i])==0){
00113                         ShellCtrl.ExecuteItem=i;
00114                         ShellCtrl.ExecuteState=ExecuteStartState;
00115                         ShellCtrl.State=ShellExecuteState;
00116                         return;
00117                     }
00118                 }
00119             }
00120             printf("\n$>");
00121             F_ShellArgumentReset();
00122             ShellCtrl.State=ShellWaitCommandState;
00123             break;
00124         case ShellExecuteState:
00125             switch(ShellCtrl.ExecuteItem){
00126                 case ItemInfo:
00127                     switch(ShellCtrl.ExecuteState){
00128                         case ExecuteIdleState:
00129                             ShellCtrl.State=ShellExecuteStopState;
00130                             break;
00131                         case ExecuteStartState:                     
00132                             printf("\n*******************************************");
00133                             printf("\n Hello, welcome to use MYLPT.");
00134                             printf("\n MYLPT is developed by BOOK CHEN.");
00135                             printf("\n BOOK CHEN is a firmware engineer,SUMC Inc.");
00136                             printf("\n*******************************************");
00137                             ShellCtrl.ExecuteState=ExecuteIdleState;
00138                             break;
00139                     }
00140                     break;
00141                 case ItemHelp:
00142                     switch(ShellCtrl.ExecuteState){
00143                         case ExecuteIdleState:
00144                             ShellCtrl.State=ShellExecuteStopState;
00145                             break;
00146                         case ExecuteStartState:
00147                             printf("\n help information:");
00148                             printf("\n info");
00149                             printf("\n help");
00150                             printf("\n exit");
00151                             printf("\n bye");
00152                             printf("\n quit");
00153                             printf("\n q");
00154                             printf("\n icsp");
00155                             ShellCtrl.ExecuteState=ExecuteRunState;
00156                             break;
00157                         case ExecuteRunState:
00158                             ShellCtrl.ExecuteState=ExecuteIdleState;
00159                             break;
00160                     }
00161                     break;
00162                 case ItemExit:
00163                     switch(ShellCtrl.ExecuteState){
00164                         case ExecuteIdleState:
00165                             ShellCtrl.State=ShellExecuteStopState;
00166                             break;
00167                         case ExecuteStartState:         
00168                             ShellCtrl.Exit=TRUE;
00169                             printf("\n bye.");
00170                             ShellCtrl.ExecuteState=ExecuteIdleState;
00171                             break;
00172                         case ExecuteRunState:
00173                             ShellCtrl.ExecuteState=ExecuteIdleState;
00174                             break;
00175                     }
00176                     break;
00177                 case ItemBye:
00178                     switch(ShellCtrl.ExecuteState){
00179                         case ExecuteIdleState:
00180                             ShellCtrl.State=ShellExecuteStopState;
00181                             break;
00182                         case ExecuteStartState:         
00183                             ShellCtrl.Exit=TRUE;
00184                             printf("\n bye.");
00185                             ShellCtrl.ExecuteState=ExecuteIdleState;
00186                             break;
00187                         case ExecuteRunState:
00188                             ShellCtrl.ExecuteState=ExecuteIdleState;
00189                             break;
00190                     }
00191                     break;
00192                 case ItemQuit:
00193                     switch(ShellCtrl.ExecuteState){
00194                         case ExecuteIdleState:
00195                             ShellCtrl.State=ShellExecuteStopState;
00196                             break;
00197                         case ExecuteStartState:         
00198                             ShellCtrl.Exit=TRUE;
00199                             printf("\n bye.");
00200                             ShellCtrl.ExecuteState=ExecuteIdleState;
00201                             break;
00202                         case ExecuteRunState:
00203                             ShellCtrl.ExecuteState=ExecuteIdleState;
00204                             break;
00205                     }
00206                     break;
00207                 case ItemQuit2:
00208                     switch(ShellCtrl.ExecuteState){
00209                         case ExecuteIdleState:
00210                             ShellCtrl.State=ShellExecuteStopState;
00211                             break;
00212                         case ExecuteStartState:         
00213                             ShellCtrl.Exit=TRUE;
00214                             printf("\n bye.");
00215                             ShellCtrl.ExecuteState=ExecuteIdleState;
00216                             break;
00217                         case ExecuteRunState:
00218                             ShellCtrl.ExecuteState=ExecuteIdleState;
00219                             break;
00220                     }
00221                     break;
00222                 case ItemIcsperase:
00223                     switch(ShellCtrl.ExecuteState){
00224                         case ExecuteIdleState:
00225                             ShellCtrl.State=ShellExecuteStopState;
00226                             break;
00227                         case ExecuteStartState: 
00228                             printf("\n icsp erase");
00229                             F_IcspProgramModeEnter(); 
00230                             F_IcspBulkErase();           
00231                             F_IcspProgramModeExit();
00232                             F_IcspReset();
00233                             ShellCtrl.ExecuteState=ExecuteRunState;
00234                             break;
00235                         case ExecuteRunState:
00236                             if(F_WriterStateGet()!=0) return;
00237                             ShellCtrl.ExecuteState=ExecuteIdleState;
00238                             break;
00239                     }
00240                     break;
00241                 case ItemIcspread:
00242                     switch(ShellCtrl.ExecuteState){
00243                         case ExecuteIdleState:
00244                             ShellCtrl.State=ShellExecuteStopState;
00245                             break;
00246                         case ExecuteStartState: 
00247                             printf("\n icsp read");
00248                             F_IcspTest();
00249                             //F_WriterImageWrite();
00250                             ShellCtrl.ExecuteState=ExecuteRunState;
00251                             break;
00252                         case ExecuteRunState:
00253                             if(F_WriterStateGet()!=0) return;
00254                             ShellCtrl.ExecuteState=ExecuteIdleState;
00255                             break;
00256                     }
00257                     break;
00258                 case ItemIcspwrite:
00259                     switch(ShellCtrl.ExecuteState){
00260                         case ExecuteIdleState:
00261                             ShellCtrl.State=ShellExecuteStopState;
00262                             break;
00263                         case ExecuteStartState: 
00264                             printf("\n icsp write");
00265                             //F_IcspTest();
00266                             F_WriterImageWrite();
00267                             ShellCtrl.ExecuteState=ExecuteRunState;
00268                             break;
00269                         case ExecuteRunState:
00270                             if(F_WriterStateGet()!=0) return;
00271                             ShellCtrl.ExecuteState=ExecuteIdleState;
00272                             break;
00273                     }
00274                     break;
00275                 default:
00276                     ShellCtrl.State=ShellExecuteStopState;
00277                     break;
00278             }           
00279             break;
00280         case ShellExecuteStopState:
00281             printf("\n$>");
00282             F_ShellArgumentReset();
00283             ShellCtrl.State=ShellWaitCommandState;
00284             break;
00285         default:
00286             break;
00287     }
00288 }

Variable Documentation

ARGUMENT_CONTROL ArgumentCtrl

Definition at line 62 of file shell.c.

U8 bye[] = "bye"

Definition at line 38 of file shell.c.

U8 help[] = "help"

Definition at line 36 of file shell.c.

U8 icsperase[] = "icsperase"

Definition at line 41 of file shell.c.

U8 icspread[] = "icspread"

Definition at line 42 of file shell.c.

U8 icspwrite[] = "icspwrite"

Definition at line 43 of file shell.c.

U32 ImageSize

Definition at line 60 of file shell.c.

U8 info[] = "info"

Definition at line 35 of file shell.c.

U8 myexit[] = "exit"

Definition at line 37 of file shell.c.

FILE* pStream

Definition at line 59 of file shell.c.

U8 quit[] = "quit"

Definition at line 39 of file shell.c.

U8 quit2[] = "q"

Definition at line 40 of file shell.c.

U8* ShellCommand[]

Initial value:

{
info,
help,
myexit,             
bye,
quit,
quit2,
icsperase,
icspread,
icspwrite,
(U8 *)0
}

Definition at line 45 of file shell.c.

SHELL_CONTROL ShellCtrl

Definition at line 61 of file shell.c.

U8 SourceFilename[100]

Definition at line 58 of file shell.c.

Generated on Sun Jul 19 00:50:40 2009 for PROGRAMER FOR PIC18F87J10 USING LPT PORT by  doxygen 1.5.9