Changeset 0b675ba in pyramid


Ignore:
Timestamp:
10/10/13 02:49:00 (6 years ago)
Author:
Steve Castellotti <sc@…>
Branches:
master
Children:
94b751c
Parents:
240e339
Message:
  • added parseInputSerial()
  • split Bluetooth processing out into parseBluetooth()
File:
1 edited

Legend:

Unmodified
Added
Removed
  • firmware/Puzzlebox_Pyramid/Puzzlebox_Pyramid.ino

    r240e339 r0b675ba  
    2626For more details about the product please check http://puzzlebox.info 
    2727 
    28 Original Author: Azureviolin <www.azureviolin.com> 
    29  
    30 Last Modified 2013-07-04 
     28Original Author: Hao Zhang <hz@puzzlebox.info> 
     29 
     30Last Modified 2013-10-09 
    3131by Steve Castellotti <sc@puzzlebox.info> 
    3232 
     
    3737 
    3838 
    39 #define DEBUG_OUTPUT 0 //1 for debug 
     39#define DEBUG_OUTPUT 1 //1 for debug 
    4040 
    4141 
     
    5959char _channel='A'; 
    6060char _command; 
    61 byte _attention_threshold = 60; //treshold for launching Orbit helicopter 
     61byte _attention_threshold = 67; //treshold for launching Orbit helicopter 
    6262 
    6363///////////////MindWave Mobile Protocol/////////// 
     
    7171int payloadLength = 0; 
    7272byte payloadData[64] = { 
    73 0}; 
     73        0 
     74}; 
    7475byte poorQuality = 0; 
    7576byte attention = 0; 
     
    9495 
    9596////////////RGB Panel////////////// 
    96 byte RGB_Panel[12][3]={ 
     97byte RGB_Panel[12][3] = { 
    9798        {0,0,0}, 
    9899        {0,0,0}, 
     
    108109        {0,0,0}, 
    109110}; 
    110  
    111  
    112 // ################################################################ 
    113  
    114 ///////////Serial Input/////////// 
    115 void parseInput() { 
    116          
    117         if (Serial.available() > 0)  { 
    118                  
    119                 Serial.print("Serial.available(): "); 
    120                 Serial.println(Serial.available()); 
    121                  
    122                 _command = Serial.read(); 
    123                  
    124                  
    125                 Serial.print("Serial.read(): "); 
    126                 Serial.println(_command); 
    127                  
    128                 switch (_command) 
    129                 {  
    130                         case 'P': _throttle=85; Serial.print("_throttle="); Serial.println(int(_throttle)); break; 
    131                         case 'O': _throttle=0; Serial.print("_throttle="); Serial.println(int(_throttle)); break; 
    132                         case 'U':  _throttle+=1;  Serial.print("_throttle="); Serial.println(int(_throttle)); break; 
    133                         case 'D':  _throttle-=1;  Serial.print("_throttle="); Serial.println(int(_throttle)); break; 
    134                         case 'L':  _yaw+=15;  Serial.print("_yaw="); Serial.println(int(_yaw)); break; 
    135                         case 'R':  _yaw-=15;  Serial.print("_yaw="); Serial.println(int(_yaw)); break; 
    136                         case 'F':  _pitch+=5;  Serial.print("_pitch="); Serial.println(int(_pitch)); break; 
    137                         case 'B':  _pitch-=5;  Serial.print("_pitch="); Serial.println(int(_pitch)); break; 
    138                         case '1':  _channel='A';  Serial.println("_channel=A"); break; 
    139                         case '2':  _channel='B';  Serial.println("_channel=B"); break; 
    140                         case '3':  _channel='C';  Serial.println("_channel=C"); break; 
    141                         case 'p':  setPitch(); break; 
    142                         case 't':  setThrottle(); break; 
    143                         case 'y':  setYaw(); break; 
    144                         case 'x':  setThrottle(); break; 
    145                 } 
    146         } 
    147 } // parseInput() 
    148  
    149  
    150 // ################################################################ 
    151  
    152 void setPitch() { 
    153  
    154         char inByte=0; 
    155         int a=0; 
    156         int b=0; 
    157         int c=0; 
    158         int newPitch=0; 
    159  
    160         while (Serial.available() == 0); 
    161         inByte = Serial.read() - '0'; 
    162         //Serial.println(inByte); 
    163         a = inByte; 
    164  
    165         while (Serial.available() == 0); 
    166         inByte = Serial.read() - '0'; 
    167         //Serial.println(inByte); 
    168         b = inByte; 
    169  
    170         while (Serial.available() == 0); 
    171         inByte = Serial.read() - '0'; 
    172         //Serial.println(inByte); 
    173         c = inByte; 
    174  
    175         newPitch = (a * 100) + (b * 10) + c; 
    176  
    177         if (newPitch < 0) 
    178                 newPitch=0; 
    179  
    180         if (newPitch > 100) 
    181                 newPitch=100; 
    182                  
    183         _pitch=newPitch; 
    184  
    185         Serial.print("_pitch="); 
    186         Serial.println(int(_pitch)); 
    187  
    188 } // setPitch 
    189  
    190  
    191 // ################################################################ 
    192  
    193 void setThrottle() { 
    194  
    195         char inByte=0; 
    196         int a=0; 
    197         int b=0; 
    198         int c=0; 
    199         int newThrottle=0; 
    200  
    201         while (Serial.available() == 0); 
    202         inByte = Serial.read() - '0'; 
    203         //Serial.println(inByte); 
    204         a = inByte; 
    205  
    206         while (Serial.available() == 0); 
    207         inByte = Serial.read() - '0'; 
    208         //Serial.println(inByte); 
    209         b = inByte; 
    210  
    211         while (Serial.available() == 0); 
    212         inByte = Serial.read() - '0'; 
    213         //Serial.println(inByte); 
    214         c = inByte; 
    215  
    216         newThrottle = (a * 100) + (b * 10) + c; 
    217  
    218         if (newThrottle < 0) 
    219                 newThrottle=0; 
    220  
    221         if (newThrottle > 100) 
    222                 newThrottle=100; 
    223                  
    224         _throttle=newThrottle; 
    225  
    226         Serial.print("_throttle="); 
    227         Serial.println(int(_throttle)); 
    228  
    229 } // setThrottle 
    230  
    231  
    232 // ################################################################ 
    233  
    234 void setYaw() { 
    235  
    236         char inByte=0; 
    237         int a=0; 
    238         int b=0; 
    239         int c=0; 
    240         int newYaw=0; 
    241  
    242         while (Serial.available() == 0); 
    243         inByte = Serial.read() - '0'; 
    244         //Serial.println(inByte); 
    245         a = inByte; 
    246  
    247         while (Serial.available() == 0); 
    248         inByte = Serial.read() - '0'; 
    249         //Serial.println(inByte); 
    250         b = inByte; 
    251  
    252         while (Serial.available() == 0); 
    253         inByte = Serial.read() - '0'; 
    254         //Serial.println(inByte); 
    255         c = inByte; 
    256  
    257         newYaw = (a * 100) + (b * 10) + c; 
    258  
    259         if (newYaw < 0) 
    260                 newYaw=0; 
    261  
    262         if (newYaw > 100) 
    263                 newYaw=100; 
    264                  
    265         _yaw=newYaw; 
    266  
    267         Serial.print("_yaw="); 
    268         Serial.println(int(_yaw)); 
    269  
    270 } // setYaw 
    271111 
    272112 
     
    276116//SETUP// 
    277117///////// 
    278 void setup() {  
     118void setup() { 
    279119        pinMode(13, OUTPUT);   
    280120        Serial.begin(115200); 
     
    292132        } 
    293133 
    294  
    295134        /////////////RGB//////////////// 
    296135        Wire.begin(); // join i2c bus as master (address optional for master) 
    297  
    298136 
    299137        //////////Bluetooth/////////// 
     
    313151void loop() { 
    314152         
    315         parseInput(); 
    316  
     153        parseBluetooth(); 
     154         
     155        //  parseSerialInput(); 
     156         
     157        ////Send Flight Command through IR Emitter//// 
     158        if (millis()-lastLoop>_IR_period) { 
     159                if(att_buff>_attention_threshold) { 
     160                        _throttle=85; 
     161                         
     162                         
     163                        //Add Settings for _yaw and _pitch here for custom flight path 
     164                         
     165                        sendCode(formCode(_throttle,_yaw,_pitch)); 
     166                         
     167                        Serial1.flush(); 
     168                } 
     169                 
     170                #if DEBUG_OUTPUT 
     171                Serial.print(" Attention:"); 
     172                Serial.print(att_buff); 
     173                Serial.print(" | Time per loop:"); 
     174                Serial.println(millis() - lastLoop, DEC); 
     175                lastLoop = millis(); 
     176                #endif 
     177         
     178        } // if (millis()-lastLoop>_IR_period) 
     179 
     180}// Main loop 
     181 
     182 
     183// ################################################################ 
     184 
     185void parseBluetooth() { 
     186         
    317187        ////MindWave Mobile Protocol//// 
    318         if (ReadOneByte() == 170) { 
    319                 if (ReadOneByte() == 170) { 
    320  
     188         
     189        if(ReadOneByte() == 170) { 
     190                 
     191                if(ReadOneByte() == 170) { 
     192                         
    321193                        payloadLength = ReadOneByte(); 
    322194                        if(payloadLength > 169)                      //Payload length can not be greater than 169 
     
    332204                        generatedChecksum = 255 - generatedChecksum;   //Take one's compliment of generated checksum 
    333205 
    334                         if(checksum == generatedChecksum) {    
     206                        if (checksum == generatedChecksum) {    
    335207 
    336208                                poorQuality = 200; 
     
    364236                                } // for loop 
    365237 
    366                                  
    367                                 // Update RGB Panel Display 
     238                                //update RGB Panel Display 
    368239 
    369240                                if(bigPacket) { 
     
    401272                                        updateFrame(att,med,poorQuality); //update buffer 
    402273                                        sendFrame(0);//send current buffer to RGB Panel with no delay 
    403                                  
    404                                  
    405274                                         
    406                                 }// end if(bigPacket)      
    407                                  
    408                                  
    409                                 bigPacket = false;    
    410                                  
    411                         } else { 
     275                                         
     276                                         
     277                                } // end if(bigPacket)      
     278                                bigPacket = false;         
     279                        } // if (checksum == generatedChecksum) 
     280                        else { 
    412281                                #if DEBUG_OUTPUT 
    413282                                Serial.println("Checksum Error!"); 
     
    416285                        }  // end if else for checksum 
    417286                } // end if read 0xAA byte (170) 
    418         } // end if read 0xAA byte (170) (ReadOneByte() == 170) 
     287        } // end if read 0xAA byte (170) 
    419288 
    420289        //read from button 
     
    433302 
    434303 
    435         ////Send Flight Command through IR Emitter//// 
    436         if (millis() - lastLoop > _IR_period) { 
    437                 if (att_buff > _attention_threshold) { 
    438                         if (_throttle != 85) { 
    439                                 _throttle=85; 
    440                                 Serial1.flush(); 
    441  
    442                         } 
    443                          
    444 //                      //Add Settings for _yaw and _pitch here for custom flight path 
    445 //                       
    446 //                      sendCode(formCode(_throttle,_yaw,_pitch)); 
    447                          
    448 //                      Serial1.flush(); 
    449 //              } else { 
    450 //                      _throttle=0; 
    451                 } 
    452  
    453  
    454  
    455                 //Add Settings for _yaw and _pitch here for custom flight path 
    456                 sendCode(formCode(_throttle,_yaw,_pitch)); 
    457                  
    458 //      #if DEBUG_OUTPUT 
    459 //      Serial.print("Time per loop:"); 
    460 //      Serial.print(millis() - lastLoop, DEC); 
    461 //      Serial.print("Attention:"); 
    462 //      Serial.println(att_buff); 
    463 //      lastLoop = millis(); 
    464 //      #endif 
    465  
    466         } 
    467  
    468 } // loop() 
     304} // parseBluetooth 
    469305 
    470306 
     
    473309// Read data from Serial1 UART on ADK 
    474310byte ReadOneByte() { 
    475          
    476         int ByteRead = 0; 
    477  
    478 //      while(!Serial1.available()); 
    479          
    480         if (Serial1.available() > 0) 
    481                 ByteRead = Serial1.read(); 
     311        int ByteRead; 
     312 
     313        while(!Serial1.available()); 
     314        ByteRead = Serial1.read(); 
    482315 
    483316        return ByteRead; 
     
    488321 
    489322void setupBlueToothConnection() { 
     323 
    490324        Serial1.begin(38400); //Set Bluetooth Module BaudRate (for communicating to ADK) to default baud rate 38400 
    491325 
     
    504338 
    505339 
    506         if(digitalRead(BUTTON_PIN)==0) { //if needs pair 
     340        if(digitalRead(BUTTON_PIN)==0){ //if needs pair 
    507341                //update RGB Panel, Red Indicates it's pairing new headset 
    508342                RGB_Panel[5][0]=255; 
     
    514348                Serial.println("Pyramid is inquiring!"); 
    515349                delay(2000); // This delay is required. 
    516                          
     350                 
    517351                //find the target slave, hence MindWave Mobile Headset 
    518352                 
     
    520354                char recvChar; 
    521355                while(1) { 
    522                         if(Serial1.available()){ 
     356                        if(Serial1.available()) { 
    523357                                recvChar = Serial1.read(); 
    524358                                Serial.print(recvChar); 
     
    526360                                nameIndex = recvBuf.indexOf(slaveName);//get the position of slave name 
    527361                                //nameIndex -= 1;//decrease the ';' in front of the slave name, to get the position of the end of the slave address 
    528                                 if ( nameIndex != -1 ){ 
     362                                if ( nameIndex != -1 ) { 
    529363                                        //Serial.print(recvBuf); 
    530364                                        addrIndex = (recvBuf.indexOf(retSymb,(nameIndex - retSymb.length()- 18) ) + retSymb.length());//get the start position of slave address                  
     
    533367                                } 
    534368                        } 
    535                 } // while 
     369                } 
    536370                 
    537371                Serial.println(); 
     372                 
    538373                //form the full connection command 
    539374                connectCmd += slaveAddr; 
     
    547382                        Serial1.print(connectCmd);//send connection command 
    548383                        recvBuf = ""; 
    549                         while(1){ 
    550                                 if(Serial1.available()){ 
     384                        while(1) { 
     385                                if(Serial1.available()) { 
    551386                                        recvChar = Serial1.read(); 
    552387                                        recvBuf += recvChar; 
    553                                         if (recvBuf.indexOf("CONNECT:OK") != -1) { 
     388                                        if(recvBuf.indexOf("CONNECT:OK") != -1) { 
    554389                                                connectOK = 1; 
    555390                                                Serial.println("Connected!"); 
    556391                                                //Serial1.print("Connected!"); 
    557392                                                break; 
    558                                         } else if(recvBuf.indexOf("CONNECT:FAIL") != -1) { 
     393                                        } else if (recvBuf.indexOf("CONNECT:FAIL") != -1){ 
    559394                                                Serial.println("Connect again!"); 
    560395                                                break; 
     
    564399                } while(0 == connectOK); 
    565400                 
    566         } else { //if auto connected 
     401        } //end if needs pair 
     402        else { //if auto connected 
    567403                Serial1.print("\r\n+STAUTO=1\r\n");// Permit Auto-connection  
    568404                //update bottom RGB LED to blue 
     
    577413        //If Bluetooth connection is established, top LED blue. 
    578414        // Otherwise top LED red. 
    579         //  if(digitalRead(A1)){//D5 for Pyramid Shield, A1 for testing 
    580         if (digitalRead(5)) {//D5 for Pyramid Shield, A1 for testing 
    581                                  
     415        if(digitalRead(5)){//D5 for Pyramid Shield, A1 for testing 
    582416                RGB_Panel[11][0]=0; 
    583417                RGB_Panel[11][1]=0; 
    584418                RGB_Panel[11][2]=255; 
    585419                sendFrame(0); 
    586         } else { 
     420        } 
     421        else{ 
    587422                RGB_Panel[11][0]=255; 
    588423                RGB_Panel[11][1]=0; 
     
    590425                sendFrame(0); 
    591426        } 
    592  
    593 } // setupBluetoothConnection() 
     427         
     428} 
     429// End setupBluetoothConnection 
    594430 
    595431 
     
    608444 
    609445        // if the signal is good enough, light 6:00 LED in green. 
    610         if (poorQuality <1){ 
     446        if (poorQuality <1) { 
    611447                RGB_Panel[5][0]=0; 
    612448                RGB_Panel[5][1]=255; 
     
    623459                RGB_Panel[11][2]=0; 
    624460        } 
    625          
     461 
    626462 
    627463        //light up & dim red LED according to attention level 
    628         for(int i=6; i<6+attention; i++){ 
     464        for(int i=6; i<6+attention; i++) { 
    629465                RGB_Panel[i][0]=255; 
    630466                RGB_Panel[i][1]=0; 
    631467                RGB_Panel[i][2]=0; 
    632468        } 
    633         for(int i=6+attention; i<11; i++){ 
     469        for(int i=6+attention; i<11; i++) { 
    634470                RGB_Panel[i][0]=0; 
    635471                RGB_Panel[i][1]=0; 
     
    638474 
    639475        //light up & dim blue LED according to meditation level 
    640         for(int i=4; i>4-meditation; i--){ 
     476        for(int i=4; i>4-meditation; i--) { 
    641477                RGB_Panel[i][0]=0; 
    642478                RGB_Panel[i][1]=0; 
    643479                RGB_Panel[i][2]=255; 
    644480        } 
    645         for(int i=4-meditation; i>-1; i--){ 
     481        for(int i=4-meditation; i>-1; i--) { 
    646482                RGB_Panel[i][0]=0; 
    647483                RGB_Panel[i][1]=0; 
     
    649485        } 
    650486 
    651 }// updateFrame() 
     487}// end updateFrame 
    652488 
    653489 
     
    679515        Wire.endTransmission();    // stop transmitting 
    680516        //delay(delayTime); 
    681 } // sendFrame() 
     517         
     518} // sendFrame 
    682519 
    683520 
     
    691528        pwmWrite(IR, OFF); 
    692529        delayMicroseconds(offTime); 
    693 } // innerCycle() 
     530} // innerCycle 
    694531 
    695532 
     
    698535void emitCode(char BIT) { 
    699536        //emitCode generate LOWs between HIGHs as same as the parameter. 
    700         if (BIT) 
    701                 innerCycle(671,732);// 1 
     537        if 
     538                (BIT) innerCycle(671,732);// 1 
    702539        else 
    703540                innerCycle(337,402);// 0 
    704 } // emitCode() 
    705  
    706  
    707 // ################################################################ 
    708  
    709 void sendCode(long code) {  
     541} // emitCode 
     542 
     543 
     544// ################################################################ 
     545 
     546void sendCode(long code) { 
    710547        char n;  
    711548        //starting code, with special time period. 
     
    713550        innerCycle(730,392);  
    714551 
    715         for (n=28;n>=0;n--) 
    716                 emitCode((code >> n) & 1); //getting bits out from code 
     552        for (n=28;n>=0;n--)  emitCode((code >> n) & 1); //getting bits out from code 
     553 
    717554} // sendCode 
    718555 
     
    721558 
    722559long formCode(char throttle,char yaw,char pitch) { 
    723          
    724560        char n; 
    725561        long mainCode=0; 
     
    755591        bitWrite(mainCode,0,1);  //finish code 
    756592        return mainCode; //mainCode is a 29 bit binary number 
    757          
    758 } // formCode() 
    759  
    760  
    761  
    762  
    763  
    764  
    765  
    766  
     593} // formCode 
     594 
     595 
     596// ################################################################ 
     597 
     598void setThrottle() { 
     599 
     600        char inByte=0; 
     601        int a=0; 
     602        int b=0; 
     603        int c=0; 
     604        int newThrottle=0; 
     605 
     606        while (Serial.available() == 0); 
     607        inByte = Serial.read() - '0'; 
     608        a = inByte; 
     609 
     610        while (Serial.available() == 0); 
     611        inByte = Serial.read() - '0'; 
     612        b = inByte; 
     613 
     614        while (Serial.available() == 0); 
     615        inByte = Serial.read() - '0'; 
     616        c = inByte; 
     617 
     618        newThrottle = (a * 100) + (b * 10) + c; 
     619 
     620        if (newThrottle < 0) 
     621                newThrottle=0; 
     622 
     623        if (newThrottle > 100) 
     624                newThrottle=100; 
     625                 
     626        _throttle=newThrottle; 
     627 
     628        Serial.print("_throttle="); 
     629        Serial.println(int(_throttle)); 
     630 
     631} // setThrottle 
     632 
     633 
     634// ################################################################ 
     635 
     636void setPitch() { 
     637 
     638        char inByte=0; 
     639        int a=0; 
     640        int b=0; 
     641        int c=0; 
     642        int newPitch=0; 
     643 
     644        while (Serial.available() == 0); 
     645        inByte = Serial.read() - '0'; 
     646        //Serial.println(inByte); 
     647        a = inByte; 
     648 
     649        while (Serial.available() == 0); 
     650        inByte = Serial.read() - '0'; 
     651        //Serial.println(inByte); 
     652        b = inByte; 
     653 
     654        while (Serial.available() == 0); 
     655        inByte = Serial.read() - '0'; 
     656        //Serial.println(inByte); 
     657        c = inByte; 
     658 
     659        newPitch = (a * 100) + (b * 10) + c; 
     660 
     661        if (newPitch < 0) 
     662                newPitch=0; 
     663 
     664        if (newPitch > 100) 
     665                newPitch=100; 
     666                 
     667        _pitch=newPitch; 
     668 
     669        Serial.print("_pitch="); 
     670        Serial.println(int(_pitch)); 
     671 
     672} // setPitch 
     673 
     674 
     675// ################################################################ 
     676 
     677//void setThrottle() { 
     678// 
     679//      char inByte=0; 
     680//      int a=0; 
     681//      int b=0; 
     682//      int c=0; 
     683//      int newThrottle=0; 
     684// 
     685//      while (Serial.available() == 0); 
     686//      inByte = Serial.read() - '0'; 
     687//      //Serial.println(inByte); 
     688//      a = inByte; 
     689// 
     690//      while (Serial.available() == 0); 
     691//      inByte = Serial.read() - '0'; 
     692//      //Serial.println(inByte); 
     693//      b = inByte; 
     694// 
     695//      while (Serial.available() == 0); 
     696//      inByte = Serial.read() - '0'; 
     697//      //Serial.println(inByte); 
     698//      c = inByte; 
     699// 
     700//      newThrottle = (a * 100) + (b * 10) + c; 
     701// 
     702//      if (newThrottle < 0) 
     703//              newThrottle=0; 
     704// 
     705//      if (newThrottle > 100) 
     706//              newThrottle=100; 
     707//               
     708//      _throttle=newThrottle; 
     709// 
     710//      Serial.print("_throttle="); 
     711//      Serial.println(int(_throttle)); 
     712// 
     713//} // setThrottle 
     714 
     715 
     716// ################################################################ 
     717 
     718void setYaw() { 
     719 
     720        char inByte=0; 
     721        int a=0; 
     722        int b=0; 
     723        int c=0; 
     724        int newYaw=0; 
     725 
     726        while (Serial.available() == 0); 
     727        inByte = Serial.read() - '0'; 
     728        //Serial.println(inByte); 
     729        a = inByte; 
     730 
     731        while (Serial.available() == 0); 
     732        inByte = Serial.read() - '0'; 
     733        //Serial.println(inByte); 
     734        b = inByte; 
     735 
     736        while (Serial.available() == 0); 
     737        inByte = Serial.read() - '0'; 
     738        //Serial.println(inByte); 
     739        c = inByte; 
     740 
     741        newYaw = (a * 100) + (b * 10) + c; 
     742 
     743        if (newYaw < 0) 
     744                newYaw=0; 
     745 
     746        if (newYaw > 100) 
     747                newYaw=100; 
     748                 
     749        _yaw=newYaw; 
     750 
     751        Serial.print("_yaw="); 
     752        Serial.println(int(_yaw)); 
     753 
     754} // setYaw 
     755 
     756 
     757// ################################################################ 
     758 
     759///////////Serial Input/////////// 
     760void parseSerialInput() { 
     761         
     762        if (Serial.available() > 0)  { 
     763                 
     764//              Serial.print("Serial.available(): "); 
     765//              Serial.println(Serial.available()); 
     766                 
     767                _command = Serial.read(); 
     768                 
     769                Serial.print("Serial.read(): "); 
     770                Serial.println(_command); 
     771                 
     772                switch (_command) { 
     773                         
     774                        case 'P': _throttle=85; Serial.print("_throttle="); Serial.println(int(_throttle)); break; 
     775                        case 'O': _throttle=0; Serial.print("_throttle="); Serial.println(int(_throttle)); break; 
     776                        case 'U':  _throttle+=1;  Serial.print("_throttle="); Serial.println(int(_throttle)); break; 
     777                        case 'D':  _throttle-=1;  Serial.print("_throttle="); Serial.println(int(_throttle)); break; 
     778                        case 'L':  _yaw+=15;  Serial.print("_yaw="); Serial.println(int(_yaw)); break; 
     779                        case 'R':  _yaw-=15;  Serial.print("_yaw="); Serial.println(int(_yaw)); break; 
     780                        case 'F':  _pitch+=5;  Serial.print("_pitch="); Serial.println(int(_pitch)); break; 
     781                        case 'B':  _pitch-=5;  Serial.print("_pitch="); Serial.println(int(_pitch)); break; 
     782                        case '1':  _channel='A';  Serial.println("_channel=A"); break; 
     783                        case '2':  _channel='B';  Serial.println("_channel=B"); break; 
     784                        case '3':  _channel='C';  Serial.println("_channel=C"); break; 
     785                        case 'p':  setPitch(); break; 
     786                        case 't':  setThrottle(); break; 
     787                        case 'y':  setYaw(); break; 
     788                        case 'x':  setThrottle(); break; 
     789                } 
     790        } 
     791 
     792} // parseSerialInput() 
     793 
Note: See TracChangeset for help on using the changeset viewer.