A Simple operation System using S3C2410: application/shellapp/shell.c Source File

00001 /*********************************************************
00002 * Project: Bootloader using gnu gcc 2.95.3
00003 * Function: main service loop
00004 *
00005 * File: main.c
00006 * Author: Book Chen
00007 * Date 20080822
00008 ***********************************************************
00009 */
00010 #include "includes.h"
00011 
00012 #define DEBUG_COMMAND 0
00013 
00014 // support shell commands 
00015 #define ItemInfo     0
00016 #define ItemTftp     1
00017 #define ItemAudio    2
00018 #define ItemVideo    3
00019 #define ItemVga      4
00020 #define ItemXmodem   5
00021 #define ItemDmaTest0 6
00022 #define ItemDmaTest1 7
00023 #define ItemDmaTest2 8
00024 #define ItemDmaTest3 9
00025 #define ItemGetImage 10
00026 #define ItemRunImage 11
00027 #define ItemLs       12
00028 
00029 INT8U info[]="info";
00030 INT8U tftp[]="tftp";
00031 INT8U audio[]="audio";
00032 INT8U video[]="video";
00033 INT8U vga[]="vga";
00034 INT8U xmodem[]="xmodem";
00035 INT8U dmatest0[]="dmatest0";
00036 INT8U dmatest1[]="dmatest1";
00037 INT8U dmatest2[]="dmatest2";
00038 INT8U dmatest3[]="dmatest3";
00039 INT8U getimage[]="getimage";
00040 INT8U runimage[]="runimage";
00041 INT8U ls[]="ls";
00042 INT8U *ShellCommand[]={
00043 info,
00044 tftp,
00045 audio,
00046 video,
00047 vga,
00048 xmodem,
00049 dmatest0,
00050 dmatest1,
00051 dmatest2,
00052 dmatest3,
00053 getimage,
00054 runimage,
00055 ls,
00056 (INT8U *)0
00057 };
00058 
00059 SHELL_CONTROL ShellCtrl;
00060 
00061 #define ARGUMENT_ARGV_MAX 10
00062 #define ARGUMENT_INDEX_MAX 250
00063 typedef struct{
00064     unsigned char State;
00065     unsigned char Status;
00066     unsigned char HasInput;
00067     unsigned char Insert;
00068     unsigned char *pArgv[ARGUMENT_ARGV_MAX];
00069     unsigned char Argc;
00070     unsigned char Index;
00071     unsigned char Get;
00072     unsigned char Put;
00073     unsigned char Data[ARGUMENT_INDEX_MAX];
00074 }ARGUMENT_CONTROL;
00075 
00076 #define DEBUG_SHELL_DUMP 0
00077 #define DEBUG_SHELL_KEY  0
00078 #define DEBUG_SHELL_DONE 0
00079 
00080 #define ArgumentIdleState    0
00081 #define ArgumentInitialState 1
00082 #define ArgumentRxState      2
00083 
00084 #define MeetEscKey  0x01
00085 #define HasEscXkey  0x02
00086 #define HasPageDown 0x04
00087 
00088 ARGUMENT_CONTROL ArgumentCtrl;
00089 
00090 void F_ShellInitial(void){
00091     ShellCtrl.State=ShellInitial0State;
00092     ShellCtrl.Timer=0; 
00093     F_ShellArgumentInitial();
00094 }
00095 void F_ShellSvc(void){
00096     unsigned char i;
00097     unsigned char Argc;
00098     unsigned char **ppArgv;    // pointer of pArgv
00099     void (*GotoStart)(void);
00100 
00101     switch(ShellCtrl.State){
00102         case ShellIdleState:
00103             break;
00104         case ShellInitial0State:
00105             F_ShellArgumentInitial();
00106             ShellCtrl.State=ShellInitial1State;
00107             break;
00108         case ShellInitial1State:
00109             myprintf("\r\n********************");
00110             myprintf("\r\n I am linux arm");
00111             myprintf("\r\n********************");
00112             myprintf("\r\nARM:>");
00113             ShellCtrl.State=ShellWaitCommandState;
00114             break;
00115         case ShellInitial2State: 
00116             F_ShellArgumentSvc();
00117             break;
00118         case ShellWaitCommandState:
00119             F_ShellArgumentSvc();
00120             if(F_ShellArgumentCheck()==TRUE) ShellCtrl.State=ShellDispatchState;
00121             break;
00122         case ShellDispatchState:
00123             Argc=ArgumentCtrl.Argc;
00124             ppArgv=(unsigned char **)&ArgumentCtrl.pArgv; 
00125             if(Argc>0){
00126                 for(i=0;;i++){
00127                     if(ShellCommand[i]==(INT8U *)0){
00128                         myprintf("\n\r command not found");
00129                         break;
00130                     }
00131                     if(strcmp((char *)ArgumentCtrl.pArgv[0],(char *)ShellCommand[i])==0){
00132                         ShellCtrl.ExecuteItem=i;
00133                         ShellCtrl.ExecuteState=ExecuteStartState;
00134                         ShellCtrl.State=ShellExecuteState;
00135                         //ShellCtrl.State=ShellExecuteStopState;
00136                         return;
00137                     }
00138                 }
00139             }
00140             myprintf("\n\rARM:>");
00141             F_ShellArgumentReset();
00142             ShellCtrl.State=ShellWaitCommandState;
00143             break;
00144         case ShellExecuteState:
00145             switch(ShellCtrl.ExecuteItem){
00146                 case ItemInfo:
00147                     switch(ShellCtrl.ExecuteState){
00148                         case ExecuteIdleState:
00149                             ShellCtrl.State=ShellExecuteStopState;
00150                             break;
00151                         case ExecuteStartState:
00152                             myprintf("\n\r system infomation");
00153                             myprintf("\n\r mcu:       s3c2440");
00154                             myprintf("\n\r sdram:     64mb");
00155                             myprintf("\n\r nandflash: 64mb");
00156                             ShellCtrl.ExecuteState=ExecuteIdleState;
00157                             break; 
00158                     }
00159                     break;
00160                 case ItemTftp:
00161                     switch(ShellCtrl.ExecuteState){
00162                         case ExecuteIdleState:
00163                             ShellCtrl.State=ShellExecuteStopState;
00164                             break;
00165                         case ExecuteStartState:
00166                             ShellCtrl.ExecuteState=ExecuteIdleState;
00167                             break;
00168                     }
00169                     break;
00170                 case ItemAudio:
00171                     switch(ShellCtrl.ExecuteState){
00172                         case ExecuteIdleState:
00173                             ShellCtrl.State=ShellExecuteStopState;
00174                             break;
00175                         case ExecuteStartState:
00176                             ShellCtrl.ExecuteState=ExecuteRunState;
00177                             break;
00178                         case ExecuteRunState:
00179                             ShellCtrl.ExecuteState=ExecuteIdleState;
00180                             break;
00181                     }
00182                     break;
00183                 case ItemVideo:
00184                     switch(ShellCtrl.ExecuteState){
00185                         case ExecuteIdleState:
00186                             ShellCtrl.State=ShellExecuteStopState;
00187                             break;
00188                         case ExecuteStartState:
00189                             ShellCtrl.ExecuteState=ExecuteIdleState;
00190                             break;
00191                     }
00192                     break;
00193                 case ItemVga:
00194                     switch(ShellCtrl.ExecuteState){
00195                         case ExecuteIdleState:
00196                             ShellCtrl.State=ShellExecuteStopState;
00197                             break;
00198                         case ExecuteStartState:
00199                             F_Testvga();
00200                             ShellCtrl.ExecuteState=ExecuteRunState;
00201                             break;
00202                         case ExecuteRunState: 
00203                             ShellCtrl.ExecuteState=ExecuteIdleState;
00204                             break;
00205                     }
00206                     break;
00207                 case ItemXmodem:
00208                     switch(ShellCtrl.ExecuteState){
00209                         case ExecuteIdleState:
00210                             ShellCtrl.State=ShellExecuteStopState;
00211                             break;
00212                         case ExecuteStartState:
00213                             ShellCtrl.Timer=50000;
00214                             F_Uart0BufferReset();
00215                             F_XmodemRxStart();
00216                             ShellCtrl.ExecuteState=ExecuteRunState;
00217                             break;
00218                         case ExecuteRunState:
00219                             if(F_XmodemStatusCheck()!=TRUE) return;
00220                             F_Uart0BufferReset();
00221                             if(ShellCtrl.Timer!=0)  myprintf("\n\r xmodem transfer success");
00222                             myprintf("\n\r BlockNumber: %2x ",XmodemCtrl.BlockNumber);
00223                             myprintf("\n\r TotalBlockCount: %8x ",XmodemCtrl.TotalBlockCount);
00224                             myprintf("\n\r ByteCount:   %8x ",XmodemCtrl.ByteCount);
00225                             myprintf("\n\r pData:       %8x ",(INT32U)XmodemCtrl.pData);
00226                             myprintf("\n\r State:       %2x ",XmodemCtrl.State);
00227                             myprintf("\n\r SubState:    %2x ",XmodemCtrl.SubState);
00228                             myprintf("\n\r ErrorCount:  %2x ",XmodemCtrl.ErrorCount);
00229                             myprintf("\n\r ErrorCode:  %2x ",XmodemCtrl.ErrorCode);
00230                             myprintf("\n\r ErrorRecord:  %2x ",XmodemCtrl.ErrorRecord);
00231                             ShellCtrl.ExecuteState=ExecuteIdleState;
00232                             break;
00233                     }
00234                     break;
00235                 case ItemDmaTest0:
00236                     switch(ShellCtrl.ExecuteState){
00237                         case ExecuteIdleState:
00238                             ShellCtrl.State=ShellExecuteStopState;
00239                             break;
00240                         case ExecuteStartState:
00241                             ShellCtrl.ExecuteState=ExecuteRunState;
00242                             break;
00243                         case ExecuteRunState:
00244                             ShellCtrl.ExecuteState=ExecuteIdleState;
00245                             break;
00246                     }
00247                     break;
00248                 case ItemDmaTest1:
00249                     switch(ShellCtrl.ExecuteState){
00250                         case ExecuteIdleState:
00251                             ShellCtrl.State=ShellExecuteStopState;
00252                             break;
00253                         case ExecuteStartState:
00254                             ShellCtrl.ExecuteState=ExecuteRunState;
00255                             break;
00256                         case ExecuteRunState:
00257                             ShellCtrl.ExecuteState=ExecuteIdleState;
00258                             break;
00259                     }
00260                     break;
00261                 case ItemDmaTest2:
00262                     switch(ShellCtrl.ExecuteState){
00263                         case ExecuteIdleState:
00264                             ShellCtrl.State=ShellExecuteStopState;
00265                             break;
00266                         case ExecuteStartState: 
00267                             ShellCtrl.ExecuteState=ExecuteRunState;
00268                             break;
00269                         case ExecuteRunState:
00270                             ShellCtrl.ExecuteState=ExecuteIdleState;
00271                             break; 
00272                     }
00273                     break;
00274                 case ItemDmaTest3:
00275                     switch(ShellCtrl.ExecuteState){
00276                         case ExecuteIdleState:
00277                             ShellCtrl.State=ShellExecuteStopState;
00278                             break;
00279                         case ExecuteStartState:
00280                             ShellCtrl.ExecuteState=ExecuteRunState;
00281                             break;
00282                         case ExecuteRunState: 
00283                             ShellCtrl.ExecuteState=ExecuteIdleState;
00284                             break;
00285                     }
00286                     break;
00287                 case ItemGetImage:
00288                     switch(ShellCtrl.ExecuteState){
00289                         case ExecuteIdleState:
00290                             ShellCtrl.State=ShellExecuteStopState;
00291                             break;
00292                         case ExecuteStartState:
00293                             ShellCtrl.ExecuteState=ExecuteRunState;
00294                             break;
00295                         case ExecuteRunState: 
00296                             ShellCtrl.ExecuteState=ExecuteIdleState;
00297                             break;
00298                     }
00299                     break;
00300                 case ItemRunImage:
00301                     switch(ShellCtrl.ExecuteState){
00302                         case ExecuteIdleState:
00303                             ShellCtrl.State=ShellExecuteStopState;
00304                             break;
00305                         case ExecuteStartState:  
00306                             //DisableInt();
00307                             memcpy((INT8U *)0,(INT8U *)0x30000000,0x1000); // update steppingstone
00308                             GotoStart=(void (*)(void))0x30000000;
00309                             (*GotoStart)();
00310                             break; // This line will never execute 
00311                     }
00312                     break;
00313                 case ItemLs:
00314                     switch(ShellCtrl.ExecuteState){
00315                         case ExecuteIdleState:
00316                             ShellCtrl.State=ShellExecuteStopState;
00317                             break;
00318                         case ExecuteStartState:
00319                             myprintf("\n\r command list");
00320                             myprintf("\n\r info");
00321                             myprintf("\n\r tftp");
00322                             myprintf("\n\r audio");
00323                             myprintf("\n\r video");
00324                             myprintf("\n\r vga");
00325                             myprintf("\n\r xmodem");
00326                             myprintf("\n\r dmatest0");
00327                             myprintf("\n\r dmatest1");
00328                             myprintf("\n\r dmatest2");
00329                             myprintf("\n\r dmatest3");
00330                             myprintf("\n\r getimage");
00331                             myprintf("\n\r runimage");
00332                             ShellCtrl.ExecuteState=ExecuteRunState;
00333                             break;
00334                         case ExecuteRunState:
00335                             ShellCtrl.ExecuteState=ExecuteIdleState;
00336                             break;
00337                     }
00338                     break;
00339                 default:
00340                     ShellCtrl.State=ShellExecuteStopState;
00341                     break;
00342             }
00343             break;
00344         case ShellExecuteStopState:
00345              myprintf("\n\rARM:>");
00346              F_ShellArgumentReset();
00347              ShellCtrl.State=ShellWaitCommandState;
00348             break;
00349         default:
00350             break;
00351     }
00352 }
00353 
00354 void F_ShellArgumentInitial(void){
00355     ArgumentCtrl.Put=0;
00356     ArgumentCtrl.Index=0;
00357     ArgumentCtrl.Insert=FALSE;
00358     ArgumentCtrl.Argc=0;
00359     ArgumentCtrl.Status=0; 
00360     ArgumentCtrl.HasInput=FALSE;
00361     ArgumentCtrl.State=ArgumentRxState;
00362 }
00363 void F_ShellArgumentSvc(void){
00364     unsigned char Data;
00365 
00366     switch(ArgumentCtrl.State){
00367         case ArgumentIdleState:
00368             break;
00369         case ArgumentRxState:
00370             if(F_Uart0RxBufferCheck()==UART0_BUFFER_EMPTY) return;
00371             Data=F_Uart0RxBufferGet();
00372             // process special keys
00373             if(Data==ASCII_ESC){
00374                 ArgumentCtrl.Status=0;
00375                 ArgumentCtrl.Status=MeetEscKey;
00376                 return;
00377             }
00378             else if(ArgumentCtrl.Status==MeetEscKey){
00379                 if(Data==0x5b){
00380                     ArgumentCtrl.Status=HasEscXkey;
00381                     return;
00382                 }
00383                 else{
00384                     ArgumentCtrl.Status=0; // meet single esc key, not a special key
00385                 }
00386             }
00387             else if(ArgumentCtrl.Status==HasEscXkey){
00388                 switch(Data){
00389                     case KEY_HOME:
00390                         F_ShellArgumentHome();
00391                         ArgumentCtrl.Status=0;
00392                         return;
00393                     case KEY_END:
00394                         F_ShellArgumentEnd();
00395                         ArgumentCtrl.Status=0;
00396                         return;
00397                     case KEY_PAGE_UP:
00398                         F_ShellArgumentPageUp();
00399                         ArgumentCtrl.Status=0;
00400                         return;
00401                     case KEY_PAGE_DOWN:
00402                         ArgumentCtrl.Status=HasPageDown;
00403                         return;
00404                     case KEY_LEFT_ARROW:
00405                         F_ShellArgumentArrowLeft();
00406                         ArgumentCtrl.Status=0;
00407                         return;
00408                     case KEY_RIGHT_ARROW:
00409                         F_ShellArgumentArrowRight();
00410                         ArgumentCtrl.Status=0;
00411                         return;
00412                     case KEY_UP_ARROW:
00413                         F_ShellArgumentArrowUp();
00414                         ArgumentCtrl.Status=0;
00415                         return;
00416                     case KEY_DOWN_ARROW:
00417                         F_ShellArgumentArrowDown();
00418                         ArgumentCtrl.Status=0;
00419                         return;
00420                     default:
00421                         ArgumentCtrl.Status=0;
00422                         return; // skip this code no matter what it is
00423                 }
00424                 //ArgumentCtrl.Status=0;
00425             }
00426             else if(ArgumentCtrl.Status==HasPageDown){
00427                 if(Data==0x4a){
00428                     F_ShellArgumentPageDown(); 
00429                     ArgumentCtrl.Status=0;
00430                     return; 
00431                 }    
00432                 ArgumentCtrl.Status=0;       
00433             }
00434             switch(Data){ 
00435                 case  ASCII_NUL: // ^@
00436                     break;
00437                 case  ASCII_SOH: // ^A
00438                     break;
00439                 case  ASCII_STX: // ^B
00440                     break;
00441                 case  ASCII_ETX: // ^C
00442                     break;
00443                 case  ASCII_EOT: // ^D
00444                     break;
00445                 case  ASCII_ENQ: // ^E
00446                     break;
00447                 case  ASCII_ACK: // ^F
00448                     break;
00449                 case  ASCII_BEL: // ^G
00450                     break;
00451                 case  ASCII_BS:  // ^H
00452                     F_ShellArgumentBs();
00453                     break;
00454                 case  ASCII_HT:  // ^I
00455                     break;
00456                 case  ASCII_LF:  // ^J
00457                     break;
00458                 case  ASCII_VT:  // ^K
00459                     break;
00460                 case  ASCII_FF:  // ^L
00461                     break;
00462                 case  ASCII_CR:  // ^M
00463                     F_ShellArgumentKeyPut(Data);
00464                     F_ShellArgumentParser();
00465                     //ArgumentCtrl.Index=0;
00466                     //ArgumentCtrl.Put=0;
00467                     break;
00468                 case  ASCII_SO:  // ^N
00469                     break;
00470                 case  ASCII_SI:  // ^O
00471                     break;
00472                 case  ASCII_DLE: // ^P
00473                     break;
00474                 case  ASCII_DC1: // ^Q
00475                     break;
00476                 case  ASCII_DC2: // ^R
00477                     break;
00478                 case  ASCII_DC3: // ^S
00479                     break;
00480                 case  ASCII_DC4: // ^T
00481                     break;
00482                 case  ASCII_NAK: // ^U
00483                     break;
00484                 case  ASCII_SYN: // ^V
00485                     break;
00486                 case  ASCII_ETB: // ^W
00487                     break;
00488                 case  ASCII_CAN: // ^X
00489                     break;
00490                 case  ASCII_EM:  // ^Y
00491                     break;
00492                 case  ASCII_SUB: // ^Z
00493                     break;
00494                 //case  ASCII_ESC: // ^[
00495                 //    break;
00496                 case  ASCII_FS:   /* ^\  */
00497                     break;
00498                 case  ASCII_GS:  // ^]
00499                     break;
00500                 case  ASCII_RS:  // ^^
00501                     break;
00502                 case  ASCII_US:  // ^_
00503                     break;
00504                 case  ASCII_DEL: //
00505                     F_ShellArgumentDel();
00506                     break;
00507                 default:
00508                     if((Data>=0x20)&&(Data<=0x7e)){
00509                         F_ShellArgumentKeyPut(Data);
00510                     }
00511                     break;
00512             }
00513     }
00514 }
00515 
00516 #define ArgumentSearchState    0
00517 #define ArgumentGoThroughState 1
00518 #define ArgumentDoneState      2
00519 void F_ShellArgumentParser(void){
00520     unsigned char Index;
00521     unsigned char State;
00522     unsigned char Status;
00523     //unsigned char i;
00524     //unsigned char **ppArgv;
00525 
00526     Index=0;
00527     Status=0;
00528     ArgumentCtrl.Argc=0;
00529     State=ArgumentSearchState;
00530     while(1){
00531         switch(State){
00532             case ArgumentSearchState:
00533                 if(ArgumentCtrl.Data[Index]==0x20){;}       // " "
00534                 else if(ArgumentCtrl.Data[Index]==0x0d){  // enter key
00535                     ArgumentCtrl.Data[Index]=0;
00536                     ArgumentCtrl.Data[Index+1]=0x0d;
00537                     State=ArgumentDoneState;                
00538                 }
00539                 else{ 
00540                     ArgumentCtrl.pArgv[ArgumentCtrl.Argc]=&ArgumentCtrl.Data[Index];
00541                     ArgumentCtrl.Argc++;
00542                     State=ArgumentGoThroughState;
00543                 }
00544                 break;
00545             case ArgumentGoThroughState:
00546                 if(ArgumentCtrl.Data[Index]==0x0d){
00547                     ArgumentCtrl.Data[Index]=0;
00548                     ArgumentCtrl.Data[Index+1]=0x0d;
00549                     State=ArgumentDoneState;                
00550                 }
00551                 else if(ArgumentCtrl.Data[Index]==0x20){
00552                     ArgumentCtrl.Data[Index]=0;
00553                     State=ArgumentSearchState;          
00554                 }
00555                 break;
00556             case ArgumentDoneState:
00557                 if(ArgumentCtrl.Put==250){ // too many input
00558                     F_ShellArgumentReset();
00559                     return;
00560                 }
00561                 ArgumentCtrl.HasInput=TRUE;
00562                 return;
00563                 //if(ArgumentCtrl.Argc!=0) F_ShellArgumentExecute(&ArgumentCtrl.pArgv,ArgumentCtrl.Argc);
00564                 //break;
00565         }
00566         Index++;
00567     }
00568 }
00569 INT8U F_ShellArgumentCheck(void){
00570     if(ArgumentCtrl.HasInput==TRUE) return TRUE;
00571     else return FALSE;
00572 }
00573 //void F_ShellExecute(unsigned char **Argv,unsigned char Argc){
00574 void F_ShellArgumentExecute(unsigned char **Argv,unsigned char Argc){
00575 
00576 }
00577 void F_ShellArgumentReset(void){
00578     ArgumentCtrl.Index=0;
00579     ArgumentCtrl.Put=0;
00580     ArgumentCtrl.Argc=0;
00581     ArgumentCtrl.HasInput=FALSE;
00582 }
00583 void F_ShellArgumentBs(void){
00584     unsigned char i;
00585     #if(DEBUG_SHELL_KEY==1)
00586         myprintf("\n\r key_bs");
00587     #endif
00588     if(ArgumentCtrl.Put==ArgumentCtrl.Index){
00589         if(ArgumentCtrl.Put==0){;}
00590         else{
00591             ArgumentCtrl.Put--;
00592             ArgumentCtrl.Index--;
00593         }
00594     }
00595     else{
00596         if(ArgumentCtrl.Index==0){;}
00597         else{
00598             ArgumentCtrl.Index--;
00599             ArgumentCtrl.Put--;
00600             i=ArgumentCtrl.Index;
00601             for(;i<=ArgumentCtrl.Put;i++){
00602                 ArgumentCtrl.Data[i]=ArgumentCtrl.Data[i+1];
00603             }
00604         }
00605     }
00606 }
00607 void F_ShellArgumentDel(void){ 
00608     unsigned char i;
00609     #if(DEBUG_SHELL_KEY==1)
00610         myprintf("\n\r key_del");
00611     #endif
00612     if(ArgumentCtrl.Put==ArgumentCtrl.Index){;} // nothing to delete
00613     else{                                           // xxxxyyyy -> xxxyyyy
00614        ArgumentCtrl.Put--;
00615        i=ArgumentCtrl.Index;
00616        for(;i<=ArgumentCtrl.Put;i++){
00617            ArgumentCtrl.Data[i]=ArgumentCtrl.Data[i+1];
00618        }
00619     }
00620 }
00621 void F_ShellArgumentKeyPut(unsigned char Data){ 
00622     unsigned char i;
00623 
00624     if(ArgumentCtrl.Put==ArgumentCtrl.Index){
00625         ArgumentCtrl.Data[ArgumentCtrl.Index]=Data;
00626         if(ArgumentCtrl.Put<250){
00627             ArgumentCtrl.Put++;
00628             ArgumentCtrl.Index++;
00629         }
00630     }
00631     else{
00632         if(Data==0x0d){ 
00633             ArgumentCtrl.Data[ArgumentCtrl.Put]=Data;
00634         }
00635         else{
00636             if(ArgumentCtrl.Insert==TRUE){
00637                 i=ArgumentCtrl.Put;
00638                 for(;i>=ArgumentCtrl.Index;i--){
00639                     ArgumentCtrl.Data[i+1]=ArgumentCtrl.Data[i];
00640                 }
00641                 ArgumentCtrl.Data[ArgumentCtrl.Index]=Data;
00642                 if(ArgumentCtrl.Put<250) ArgumentCtrl.Put++;
00643                 ArgumentCtrl.Index++;
00644             }
00645             else{
00646                 ArgumentCtrl.Data[ArgumentCtrl.Index]=Data;
00647                 ArgumentCtrl.Index++;
00648             }
00649         }
00650     }
00651 }
00652 void F_ShellArgumentIns(void){ 
00653     #if(DEBUG_SHELL_KEY==1)
00654         myprintf("\n\r key_ins");
00655     #endif
00656     //if(ArgumentCtrl.Insert==TRUE) ArgumentCtrl.Insert=FALSE;
00657     //else ArgumentCtrl.Insert=TRUE;
00658 }
00659 void F_ShellArgumentHome(void){ 
00660     #if(DEBUG_SHELL_KEY==1)
00661         myprintf("\n\r key_home");
00662     #endif
00663     ArgumentCtrl.Index=0;
00664 }
00665 void F_ShellArgumentEnd(void){
00666     #if(DEBUG_SHELL_KEY==1)
00667         myprintf("\n\r key_end");
00668     #endif
00669     ArgumentCtrl.Index=ArgumentCtrl.Put;
00670 }
00671 void F_ShellArgumentPageUp(void){
00672     #if(DEBUG_SHELL_KEY==1)
00673         myprintf("\n\r key_page_up");
00674     #endif
00675 }
00676 void F_ShellArgumentPageDown(void){
00677     #if(DEBUG_SHELL_KEY==1)
00678         myprintf("\n\r key_page_down");
00679     #endif
00680 }
00681 void F_ShellArgumentArrowUp(void){
00682     #if(DEBUG_SHELL_KEY==1)
00683         myprintf("\n\r key_arrow_up");
00684     #endif
00685 }
00686 void F_ShellArgumentArrowDown(void){
00687     #if(DEBUG_SHELL_KEY==1)
00688         myprintf("\n\r key_arrow_down");
00689     #endif
00690 }
00691 void F_ShellArgumentArrowLeft(void){
00692     #if(DEBUG_SHELL_KEY==1)
00693         myprintf("\n\r key_arrow_left");
00694     #endif
00695     if(ArgumentCtrl.Index==0){;}
00696     else{
00697         ArgumentCtrl.Index--;
00698     }
00699 }
00700 void F_ShellArgumentArrowRight(void){
00701     #if(DEBUG_SHELL_KEY==1)
00702         myprintf("\n\r key_arrow_right");
00703     #endif
00704     if(ArgumentCtrl.Index==ArgumentCtrl.Put){;}
00705     else{
00706         if(ArgumentCtrl.Index<ArgumentCtrl.Put) ArgumentCtrl.Index++;
00707     }
00708 }
00709