Command.cpp

00001 /**************************************************************/
00002 // Name: Commande.h
00003 // 
00004 // Description: defines a command object for checking and  
00005 //  executing commands
00006 //
00007 /**************************************************************/
00008 
00009 #include "Command.h"
00010 #include "Interface.h"
00011 #include "PS2Keyboard.h"
00012 #include <string.h>
00013 #include "keyname.h"
00014 #include "TextLCD.h"
00015 #include <stdlib.h>
00016 
00017 Interface interface[32];
00018 
00019 /*Command::Command(char* cmdname){
00020     strcpy(name, cmdname);
00021     parameter_count = 0;
00022 }
00023 
00024 int Command::addParameter(char* param){
00025     
00026     return parameter_count++;
00027 }*/
00028 
00029 PS2Keyboard ps2kb(p12, p11); // CLK, DAT
00030 //Serial pc(USBTX, USBRX);
00031 TextLCD pc(p15, p16, p17, p18, p19, p20);
00032 //char input[32];
00033 
00034 DigitalOut testled(LED2);
00035 
00036 void execute(char* input){
00037     char* cmdname = strtok(input," -");
00038     char* param;
00039     if(strcmp(cmdname, "DIN") == 0){
00040         param = strtok(NULL," -");
00041         // create operation
00042         if(strcmp(param, "C") == 0){
00043             param = strtok (NULL," -");
00044             if(param[0] == 'P'){
00045                 int pin_num = str2int(param+1);
00046                 if(pin_num >= 5 && pin_num <= 32){
00047                     pc.printf("\n\nCreating D_IN...");
00048                     wait(2);
00049                     interface[pin_num-5].p_object = malloc(sizeof(DigitalIn));
00050                     memmove(interface[pin_num-5].p_object, &DigitalIn(getPin(pin_num)), sizeof(DigitalIn));
00051                 }
00052             }
00053             else {  //pins not given
00054             }
00055         }
00056         // read operation
00057         else if(strcmp(param, "R") == 0){
00058             param = strtok(NULL," -");
00059             if(param[0] == 'P'){
00060                 int pin_num = str2int(param+1);
00061                 if(pin_num >= 5 && pin_num <= 32){
00062                     pc.printf("\n\nReading...");
00063                     int val = ((DigitalIn)(*(DigitalIn*)interface[pin_num-5].p_object)).read();
00064                     pc.printf("\nI am: %d", val);
00065                     wait(2);
00066                 }
00067             }
00068         }
00069     }
00070     else if((strcmp(cmdname, "DOUT")) == 0){
00071         param = strtok(NULL," -");
00072         // create operation
00073         if(strcmp(param, "C") == 0){
00074             param = strtok(NULL," -");
00075             if(param[0] == 'P'){
00076                 int pin_num = str2int(param + 1);
00077                 if(pin_num >= 5 && pin_num <= 32){
00078                     pc.printf("\n\nCreating D_Out..");
00079                     wait(1);
00080                     //DigitalOut tmp(getPin(pin_num));
00081                     //interface[pin_num-5].p_object = &tmp;
00082                     //interface[pin_num-5].dout = &DigitalOut(getPin(pin_num));
00083                     interface[pin_num-5].p_object = malloc(sizeof(DigitalOut));
00084                     //(DigitalOut)interface[pin_num-5].p_object = DigitalOut(getPin(pin_num));
00085                     memmove(interface[pin_num-5].p_object, &DigitalOut(getPin(pin_num)), sizeof(DigitalOut));
00086                     //pc.printf("\n\nwriting to %X", interface[pin_num-5].p_object);
00087                     //wait(2);
00088                     
00089                     /*DigitalOut t = *((DigitalOut*)(interface[pin_num-5].p_object));
00090                     
00091                     wait(4);*/
00092                     //interface[pin_num-5].dout = &tmp;
00093                     
00094                 }
00095             }
00096             else {  //pins not given
00097             }
00098         }
00099         // write operation
00100         else if(strcmp(param, "W") == 0){
00101             param = strtok(NULL," -");
00102             if(param[0] == 'P'){
00103                 int pin_num = str2int(param + 1);
00104                 if(pin_num >= 5 && pin_num <= 32){
00105                     param = strtok(NULL," -");
00106                     int a = str2int(param);
00107                     //interface[pin_num-5].dout = a;
00108                     //(DigitalOut)(*((DigitalOut*)(interface[pin_num-5].dout))).write(a);
00109                     //DigitalOut t = *((DigitalOut*)(interface[pin_num-5].p_object));
00110                     //memcpy(, sizeof(DigitalOut));
00111                     //pc.printf("\n\na:%X", interface[pin_num-5].p_object);
00112                     //pc.printf("\nb:%X", &t);
00113                     //wait(2);
00114                     pc.printf("\n\nWriting...");
00115                     wait(2);
00116                     ((DigitalOut)(*(DigitalOut*)interface[pin_num-5].p_object)).write(a);
00117                     //t = a;
00118                     //(DigitalOut)(*(interface[pin_num-5].dout)).write(a);
00119                 }
00120             }
00121             else{ //Bad pin parameter
00122             }
00123         }
00124         
00125         else if(strcmp(param, "R") == 0){
00126             param = strtok(NULL," -");
00127             if(param[0] == 'P'){
00128                 int pin_num = str2int(param + 1);
00129                 if(pin_num >= 5 && pin_num <= 32){
00130                     pc.printf("\n\nWriting...");
00131                     wait(2);
00132                     int a = ((DigitalOut)(*(DigitalOut*)interface[pin_num-5].p_object)).read();
00133                     pc.printf("\n\n Value = %d", a);
00134                     wait(2);
00135                 }
00136             }
00137             else{ //Bad pin parameter
00138             }
00139         }
00140     }
00141     else if(!strcmp(cmdname, "I2C")){
00142         char* param = strtok(NULL," -");
00143         // create operation
00144         if(!strcmp(param, "C")){
00145             param = strtok(NULL," -");
00146             if(param[0] == 'P'){
00147                 pc.printf("\n\nCreating I2C...");
00148                 wait(2);
00149                 int pin_num = str2int(param+1);
00150                 interface[pin_num-5].p_object = malloc(sizeof(I2C));
00151                 if(pin_num == 9 || pin_num == 10){
00152                     memmove(interface[pin_num-5].p_object, &I2C(p9, p10), sizeof(I2C));
00153                 }
00154                 else if(pin_num == 28 || pin_num == 27){
00155                     memmove(interface[pin_num-5].p_object, &I2C(p28, p27), sizeof(I2C));
00156                 }
00157             }
00158             else {  //pins not given
00159             }
00160         }
00161         // write operation
00162         else if(!strcmp(param, "W")){
00163             param = strtok(NULL," -");
00164             if(param[0] == 'P'){
00165             
00166                 pc.printf("\n\nWriting to I2C...");
00167                 wait(2);
00168                 int pin_num = str2int(param+1);
00169                 //I2C tmp = *((I2C*)(interface[pin_num-5].p_object));
00170                 
00171                 int addr, strlen;
00172                 
00173                 param = strtok(NULL," -");
00174                 addr = hexstr2int(param);
00175                 param = strtok(NULL," -");
00176                 strlen = str2int(param);
00177                 char cmd[strlen];
00178                 for(int i = 0; i < strlen; i++){
00179                     param = strtok(NULL," -");
00180                     cmd[i] = str2int(&param[i]);
00181                 }
00182                 
00183                 
00184                 ((I2C)(*(I2C*)interface[pin_num-5].p_object)).write(addr, cmd, strlen);
00185             }
00186         }
00187         //read
00188         else if(!strcmp(param, "R")){
00189             param = strtok(NULL," -");
00190             if(param[0] == 'P'){
00191                 pc.printf("\n\nReading from I2C...");
00192                 wait(2);
00193             
00194                 int pin_num = str2int(param+1);
00195                 int addr, strlen;
00196                 
00197                 param = strtok(NULL," -");
00198                 addr = str2int(param);
00199                 param = strtok(NULL," -");
00200                 strlen = str2int(param);
00201                 char cmd[strlen];
00202                 
00203                 ((I2C)(*(I2C*)interface[pin_num-5].p_object)).read(addr, cmd, strlen);
00204                 // print the ranging data to the screen
00205                 int e = 0;
00206                 for(int i = 1; i < strlen; i++){
00207                     e =  ((e << 8) + cmd[i]);
00208                 }
00209                 float echo = (float)e* 0.01;
00210                 pc.printf("Value = %.4f\n", echo);
00211                 wait(2);
00212                 // print the ranging data to the screen
00213                 //float echo = 0.01 * ((cmd[0] << 8) + cmd[1]);
00214                 //pc.printf("Range = %.2f\n", echo);
00215                 //wait(2);
00216             }
00217         }
00218     }
00219     else if(!strcmp(cmdname, "SERIAL")){
00220     //baud, putc, getc
00221         char* param = strtok(NULL," -");
00222         // create operation
00223         if(!strcmp(param, "C")){
00224             param = strtok(NULL," -");
00225             if(param[0] == 'P'){
00226                 pc.printf("\n\nCreating Serial...");
00227                 wait(2);
00228                 int pin_num = str2int(param+1);
00229                 interface[pin_num-5].p_object = malloc(sizeof(Serial));
00230                 if(pin_num == 9 || pin_num == 10){
00231                     memmove(interface[pin_num-5].p_object, &Serial(p9, p10), sizeof(Serial));
00232                 }
00233                 else if(pin_num == 13 || pin_num == 14){
00234                     memmove(interface[pin_num-5].p_object, &Serial(p13, p14), sizeof(Serial));
00235                 }
00236                 else if(pin_num == 28 || pin_num == 27){
00237                     memmove(interface[pin_num-5].p_object, &Serial(p28, p27), sizeof(Serial));
00238                 }
00239             }
00240             else {  //pins not given
00241             }
00242         }
00243         //putc
00244         else if(!strcmp(param, "P")){
00245             param = strtok(NULL," -");
00246             if(param[0] == 'P'){
00247                 int pin_num = str2int(param+1);
00248                 param = strtok(NULL," -");
00249                 int c = str2int(param);
00250                 pc.printf("\n\nPutting a %d", c);
00251                 wait(2);
00252                 ((Serial)(*(Serial*)interface[pin_num-5].p_object)).putc(c);
00253             }
00254         }
00255         //getc
00256         else if(!strcmp(param, "G")){
00257             param = strtok(NULL," -");
00258             if(param[0] == 'P'){
00259                 int pin_num = str2int(param+1);
00260                 int val = ((Serial)(*(Serial*)interface[pin_num-5].p_object)).getc();
00261                 pc.printf("\nValue: %d", val);
00262                 wait(2);
00263             }
00264         }
00265         //baud
00266         else if(!strcmp(param, "B")){
00267             param = strtok(NULL," -");
00268             if(param[0] == 'P'){
00269                 int pin_num = str2int(param+1);
00270                 param = strtok(NULL," -");
00271                 int a = str2int(param);
00272                 pc.printf("\n\nSetting baud to %d", a);
00273                 wait(2);
00274                 ((Serial)(*(Serial*)interface[pin_num-5].p_object)).baud(a);
00275             }
00276         }
00277     }
00278     
00279     else if(!strcmp(cmdname, "PWMO")){
00280         char* param = strtok(NULL," -");
00281         // create operation
00282         if(!strcmp(param, "C")){
00283             param = strtok(NULL," -");
00284             if(param[0] == 'P'){
00285                 int pin_num = str2int(param+1);
00286                 if(pin_num >= 21 && pin_num <= 26){
00287                     pc.printf("\n\nCreating PWM...");
00288                     wait(2);
00289                     interface[pin_num-5].p_object = malloc(sizeof(PwmOut));
00290                     memmove(interface[pin_num-5].p_object, &PwmOut(getPin(pin_num)), sizeof(PwmOut));
00291                 }
00292             }
00293             else {  //pins not given
00294             }
00295         }
00296         //write
00297         else if(strcmp(param, "W") == 0){
00298             param = strtok(NULL," -");
00299             if(param[0] == 'P'){
00300                 int pin_num = str2int(param + 1);
00301                 if(pin_num >= 21 && pin_num <= 26){
00302                     param = strtok(NULL," -");
00303                     //float a = str2int(param) / (sizeof(int)*8 - 1);
00304                     float a = atof(param);
00305                     pc.printf("\n\nWriting... a %f", a);
00306                     wait(2);
00307                     ((PwmOut)(*(PwmOut*)interface[pin_num-5].p_object)).write(a);
00308                 }
00309             }
00310             else{ //Bad pin parameter
00311             }
00312         }
00313         
00314         //read
00315         else if(!strcmp(param, "R")){
00316             param = strtok(NULL," -");
00317             if(param[0] == 'P'){
00318                 int pin_num = str2int(param + 1);
00319                 if(pin_num >= 21 && pin_num <= 26){
00320                     float a = ((PwmOut)(*(PwmOut*)interface[pin_num-5].p_object)).read();
00321                     pc.printf("\n\nValue = %f", a);
00322                     wait(2);
00323                 }
00324             }
00325         }
00326     }
00327 }
00328 
00329 void run(){
00330         /*// Read Input
00331         pc.printf("> ");
00332         pc.scanf("%s", input);
00333         pc.printf("\n\r");
00334         pc.printf("%s\n\r", input);
00335         
00336         // Execute Instruction
00337         if(1)
00338             execute(input);*/
00339             
00340     PS2Keyboard::keyboard_event_t evt_kb;
00341     char str[32];
00342     for(int i = 0; i<32 ; i++) str[i] = ' ';    
00343     int numchar = 0;
00344     char *p = str;
00345     while (1) {
00346         if (ps2kb.processing(&evt_kb)) {
00347             for (int i = 0; i < evt_kb.length; i++) {
00348                 if(evt_kb.scancode[i] == 0xf0){
00349                     i++;
00350                     char c = evt_kb.scancode[i];
00351                     if(c == 0x5A){
00352                         // Gordon can call a function here to use str to do whatever
00353                         execute(p);
00354                     
00355                         for(int i = 0; i<32 ; i++) 
00356                             p[i] = ' ';
00357                         numchar = 0;
00358                     }
00359                     else numchar = curstr(p,numchar,c);
00360                 }
00361             }
00362             for(int i = 0; i<32 ; i++) 
00363                 pc.printf("%c", str[i]);
00364             pc.printf("\n\n"); 
00365         }       
00366         
00367     }
00368 }
00369 
00370 int str2int(char* str) {
00371     int num = 0, i = 0;
00372     while(str[i] != NULL){
00373         num = num * 10 + str[i] - '0';
00374         i++;
00375     }
00376     return num;
00377 }
00378 
00379 int hexstr2int(char* str) {
00380     int num = 0, i = 0;
00381     while(str[i] != NULL){
00382         num = num * 16 + str[i] - '0';
00383         i++;
00384     }
00385     return num;
00386 }