source: pyramid/firmware/Puzzlebox_Pyramid/Puzzlebox_Pyramid.ino @ 0b675ba

Last change on this file since 0b675ba was 0b675ba, checked in by Steve Castellotti <sc@…>, 9 years ago
  • added parseInputSerial()
  • split Bluetooth processing out into parseBluetooth()
  • Property mode set to 100644
File size: 19.0 KB
Line 
1/*
2
3Puzzlebox - Pyramid - Microcontroller
4
5Puzzlebox Pyramid microcontroller sketch. This sketch allows
6you to connect the Puzzlebox Pyramid to the NeuroSky MindWave
7Mobile headset over Bluetooth, then control the
8Puzzlebox Orbit helicopter using your brainwaves.
9Choose "Arduino Mega 2560 or Mega ADK" when building and
10uploading the compiled firmware.
11
12Copyright Puzzlebox Productions, LLC (2013)
13
14This code is released under the GNU Pulic License (GPL) version 2
15
16This software is distributed in the hope that it will be useful,
17but WITHOUT ANY WARRANTY; without even the implied warranty of
18MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
19
20You should have received a copy of the GNU General Public
21License along with this code; if not, write to the Free Software
22Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
23
24For more information about this licence please refer to http://www.gnu.org/copyleft/gpl.html
25
26For more details about the product please check http://puzzlebox.info
27
28Original Author: Hao Zhang <hz@puzzlebox.info>
29
30Last Modified 2013-10-09
31by Steve Castellotti <sc@puzzlebox.info>
32
33*/
34
35#include <Wire.h> //For I2C communication with RGB LED Panel
36#include <PWM.h> //For sending 38kHz Infrared to fly Orbit helicopter
37
38
39#define DEBUG_OUTPUT 1 //1 for debug
40
41
42byte _IR_period = 40;
43
44
45#define BUTTON_PIN 4
46/////////////Orbit Flight/////////////
47#define IR 6   
48#define ON 128
49#define OFF 0
50
51//PWM IR_frequency (in Hz) required by IR
52#define IR_frequency 38400
53
54//Global variables for controlling Orbit helicopter
55//variables start with "_" means global variable
56char _throttle=0; //32~127, default 0
57char _pitch=31; //0~63, default 31
58char _yaw=78; //16~127, default 78
59char _channel='A';
60char _command;
61byte _attention_threshold = 67; //treshold for launching Orbit helicopter
62
63///////////////MindWave Mobile Protocol///////////
64#define BAUDRATE 57600
65#define DEBUGOUTPUT 0
66#define powercontrol 10
67
68// checksum variables
69byte generatedChecksum = 0;
70byte checksum = 0;
71int payloadLength = 0;
72byte payloadData[64] = {
73        0
74};
75byte poorQuality = 0;
76byte attention = 0;
77byte att_buff = 0;
78byte meditation = 0;
79
80// system variables
81long lastReceivedPacket = 0;
82long lastLoop = 0;
83boolean bigPacket = false;
84
85///////////////Bluetooth Connection with MindWave Mobile/////////////
86String retSymb = "+RTINQ=";//start symble when there's any return
87String slaveName = ";MindWave Mobile";// caution that ';'must be included, and make sure the slave name is right.
88int nameIndex = 0;
89int addrIndex = 0;
90
91String recvBuf;
92String slaveAddr;
93
94String connectCmd = "\r\n+CONN=";
95
96////////////RGB Panel//////////////
97byte RGB_Panel[12][3] = {
98        {0,0,0},
99        {0,0,0},
100        {0,0,0},
101        {0,0,0},
102        {0,0,0},
103        {0,0,0},
104        {0,0,0},
105        {0,0,0},
106        {0,0,0},
107        {0,0,0},
108        {0,0,0},
109        {0,0,0},
110};
111
112
113// ################################################################
114
115/////////
116//SETUP//
117/////////
118void setup() {
119        pinMode(13, OUTPUT); 
120        Serial.begin(115200);
121
122        ////////Orbit Flight///////////
123        //initialize all timers except for 0, to save time keeping functions
124        InitTimersSafe();
125
126        //sets the IR_frequency for the specified pin
127        bool success = SetPinFrequencySafe(IR, IR_frequency);
128
129        //if the pin IR_frequency was set successfully, turn pin 13 on
130        if(success) {
131                Serial.println("Set PWM pin frequency SUCCESS"); 
132        }
133
134        /////////////RGB////////////////
135        Wire.begin(); // join i2c bus as master (address optional for master)
136
137        //////////Bluetooth///////////
138        setupBlueToothConnection();
139        //wait 1s and flush the serial buffer
140        delay(1000);
141        Serial.flush();//delete?
142        Serial1.flush();
143}
144
145
146// ################################################################
147
148/////////////
149//MAIN LOOP//
150/////////////
151void loop() {
152       
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       
187        ////MindWave Mobile Protocol////
188       
189        if(ReadOneByte() == 170) {
190               
191                if(ReadOneByte() == 170) {
192                       
193                        payloadLength = ReadOneByte();
194                        if(payloadLength > 169)                      //Payload length can not be greater than 169
195                                return;
196
197                        generatedChecksum = 0;       
198                        for(int i = 0; i < payloadLength; i++) { 
199                                payloadData[i] = ReadOneByte();            //Read payload into memory
200                                generatedChecksum += payloadData[i];
201                        }   
202
203                        checksum = ReadOneByte();                      //Read checksum byte from stream     
204                        generatedChecksum = 255 - generatedChecksum;   //Take one's compliment of generated checksum
205
206                        if (checksum == generatedChecksum) {   
207
208                                poorQuality = 200;
209                                attention = 0;
210                                meditation = 0;
211
212                                for(int i = 0; i < payloadLength; i++) {    // Parse the payload
213                                        switch (payloadData[i]) {
214                                        case 2:
215                                                i++;           
216                                                poorQuality = payloadData[i];
217                                                bigPacket = true;         
218                                                break;
219                                        case 4:
220                                                i++;
221                                                attention = payloadData[i];
222                                                break;
223                                        case 5:
224                                                i++;
225                                                meditation = payloadData[i];
226                                                break;
227                                        case 0x80:
228                                                i = i + 3;
229                                                break;
230                                        case 0x83:
231                                                i = i + 25;     
232                                                break;
233                                        default:
234                                                break;
235                                        } // switch
236                                } // for loop
237
238                                //update RGB Panel Display
239
240                                if(bigPacket) {
241                                        Serial.print("PoorQuality: ");
242                                        Serial.print(poorQuality, DEC);
243                                        Serial.print(" Attention: ");
244                                        Serial.print(attention, DEC);
245                                        Serial.print(" Meditation: ");
246                                        Serial.print(meditation, DEC);
247                                        Serial.print(" Time since last packet: ");
248                                        Serial.print(millis() - lastReceivedPacket, DEC);
249                                        lastReceivedPacket = millis();
250                                        Serial.print("\n");
251                                       
252                                        //Update RGB Panel when received data from MindWave Mobile
253                                        int att, med;
254                                        if(attention==0) att=0;
255                                                else att=(attention-1)/20+1;
256                                        if(meditation==0) med=0;
257                                                else med=(meditation-1)/20+1;
258                                       
259                                        att_buff=attention;
260                                       
261                                        if (att_buff>_attention_threshold) {
262                                                RGB_Panel[11][0]=255;
263                                                RGB_Panel[11][1]=255;
264                                                RGB_Panel[11][2]=128;
265                                        }
266                                        else{
267                                                RGB_Panel[11][0]=0;
268                                                RGB_Panel[11][1]=0;
269                                                RGB_Panel[11][2]=0;
270                                        }
271                                       
272                                        updateFrame(att,med,poorQuality); //update buffer
273                                        sendFrame(0);//send current buffer to RGB Panel with no delay
274                                       
275                                       
276                                       
277                                } // end if(bigPacket)     
278                                bigPacket = false;       
279                        } // if (checksum == generatedChecksum)
280                        else {
281                                #if DEBUG_OUTPUT
282                                Serial.println("Checksum Error!");
283                                // Checksum Error
284                                #endif
285                        }  // end if else for checksum
286                } // end if read 0xAA byte (170)
287        } // end if read 0xAA byte (170)
288
289        //read from button
290        if (digitalRead(BUTTON_PIN)){
291                RGB_Panel[11][0]=255;
292                RGB_Panel[11][1]=255;
293                RGB_Panel[11][2]=255;
294                digitalWrite(13,HIGH);
295        }
296        else {
297                RGB_Panel[11][0]=0;
298                RGB_Panel[11][1]=0;
299                RGB_Panel[11][2]=0;
300                digitalWrite(13,LOW);
301        }
302
303
304} // parseBluetooth
305
306
307// ################################################################
308
309// Read data from Serial1 UART on ADK
310byte ReadOneByte() {
311        int ByteRead;
312
313        while(!Serial1.available());
314        ByteRead = Serial1.read();
315
316        return ByteRead;
317}
318
319
320// ################################################################
321
322void setupBlueToothConnection() {
323
324        Serial1.begin(38400); //Set Bluetooth Module BaudRate (for communicating to ADK) to default baud rate 38400
325
326        // if you want to change baudrate, say to 115200;
327        //  Serial1.print("\r\n+STBD=115200\r\n");//set bluetooth working baudrate
328        //  delay(2000); // This delay is required.
329        //  Serial1.begin(115200);
330
331        Serial1.print("\r\n+STWMOD=1\r\n");//set the bluetooth work in master mode
332        Serial1.print("\r\n+STNA=Puzzlebox Pyramid\r\n");//set the bluetooth name as "Puzzlebox Pyramid"
333        Serial1.print("\r\n+STAUTO=0\r\n");// Forbid Auto-connection
334        Serial1.print("\r\n+STOAUT=1\r\n");// Permit Pair the device
335        Serial1.print("\r\n+STPIN =0000\r\n");// Set Pincode to 0000
336        delay(2000); // This delay is required.
337        //Serial1.flush();
338
339
340        if(digitalRead(BUTTON_PIN)==0){ //if needs pair
341                //update RGB Panel, Red Indicates it's pairing new headset
342                RGB_Panel[5][0]=255;
343                RGB_Panel[5][1]=0;
344                RGB_Panel[5][2]=0;
345                sendFrame(0);
346               
347                Serial1.print("\r\n+INQ=1\r\n");//make the master inquire
348                Serial.println("Pyramid is inquiring!");
349                delay(2000); // This delay is required.
350               
351                //find the target slave, hence MindWave Mobile Headset
352               
353                Serial.print("print recvChar:");
354                char recvChar;
355                while(1) {
356                        if(Serial1.available()) {
357                                recvChar = Serial1.read();
358                                Serial.print(recvChar);
359                                recvBuf += recvChar;
360                                nameIndex = recvBuf.indexOf(slaveName);//get the position of slave name
361                                //nameIndex -= 1;//decrease the ';' in front of the slave name, to get the position of the end of the slave address
362                                if ( nameIndex != -1 ) {
363                                        //Serial.print(recvBuf);
364                                        addrIndex = (recvBuf.indexOf(retSymb,(nameIndex - retSymb.length()- 18) ) + retSymb.length());//get the start position of slave address                 
365                                        slaveAddr = recvBuf.substring(addrIndex, nameIndex);//get the string of slave address
366                                        break;
367                                }
368                        }
369                }
370               
371                Serial.println();
372               
373                //form the full connection command
374                connectCmd += slaveAddr;
375                connectCmd += "\r\n";
376                int connectOK = 0;
377                Serial.print("Connecting to slave:");
378                Serial.print(slaveAddr);
379                Serial.println(slaveName);
380                //connecting the slave till they are connected
381                do {
382                        Serial1.print(connectCmd);//send connection command
383                        recvBuf = "";
384                        while(1) {
385                                if(Serial1.available()) {
386                                        recvChar = Serial1.read();
387                                        recvBuf += recvChar;
388                                        if(recvBuf.indexOf("CONNECT:OK") != -1) {
389                                                connectOK = 1;
390                                                Serial.println("Connected!");
391                                                //Serial1.print("Connected!");
392                                                break;
393                                        } else if (recvBuf.indexOf("CONNECT:FAIL") != -1){
394                                                Serial.println("Connect again!");
395                                                break;
396                                        }
397                                }
398                        }
399                } while(0 == connectOK);
400               
401        } //end if needs pair
402        else { //if auto connected
403                Serial1.print("\r\n+STAUTO=1\r\n");// Permit Auto-connection
404                //update bottom RGB LED to blue
405                RGB_Panel[5][0]=0;
406                RGB_Panel[5][1]=0;
407                RGB_Panel[5][2]=255;
408                sendFrame(0);
409        }
410
411        delay(3000);
412
413        //If Bluetooth connection is established, top LED blue.
414        // Otherwise top LED red.
415        if(digitalRead(5)){//D5 for Pyramid Shield, A1 for testing
416                RGB_Panel[11][0]=0;
417                RGB_Panel[11][1]=0;
418                RGB_Panel[11][2]=255;
419                sendFrame(0);
420        }
421        else{
422                RGB_Panel[11][0]=255;
423                RGB_Panel[11][1]=0;
424                RGB_Panel[11][2]=0;
425                sendFrame(0);
426        }
427       
428}
429// End setupBluetoothConnection
430
431
432// ################################################################
433
434void updateFrame(byte attention, byte meditation, byte poorQuality) {
435        // update RGB_Panel[][] here to set next Frame you want to send
436        // For Example:
437        // RGB_Panel[0][0]=0;
438        // RGB_Panel[0][1]=0;
439        // RGB_Panel[0][2]=255;
440        // will update the LED on 1:00 position to be blue.
441
442        // This following code update RGB Panel based on data
443        // received from MindWave Mobile.
444
445        // if the signal is good enough, light 6:00 LED in green.
446        if (poorQuality <1) {
447                RGB_Panel[5][0]=0;
448                RGB_Panel[5][1]=255;
449                RGB_Panel[5][2]=0;
450        }
451        else {
452                RGB_Panel[5][0]=0;
453                RGB_Panel[5][1]=0;
454                RGB_Panel[5][2]=0;
455               
456                //Make top LED green, indicating valid bluetooth connection
457                RGB_Panel[11][0]=0;
458                RGB_Panel[11][1]=255;
459                RGB_Panel[11][2]=0;
460        }
461
462
463        //light up & dim red LED according to attention level
464        for(int i=6; i<6+attention; i++) {
465                RGB_Panel[i][0]=255;
466                RGB_Panel[i][1]=0;
467                RGB_Panel[i][2]=0;
468        }
469        for(int i=6+attention; i<11; i++) {
470                RGB_Panel[i][0]=0;
471                RGB_Panel[i][1]=0;
472                RGB_Panel[i][2]=0;
473        }
474
475        //light up & dim blue LED according to meditation level
476        for(int i=4; i>4-meditation; i--) {
477                RGB_Panel[i][0]=0;
478                RGB_Panel[i][1]=0;
479                RGB_Panel[i][2]=255;
480        }
481        for(int i=4-meditation; i>-1; i--) {
482                RGB_Panel[i][0]=0;
483                RGB_Panel[i][1]=0;
484                RGB_Panel[i][2]=0;
485        }
486
487}// end updateFrame
488
489
490// ################################################################
491
492void sendFrame(int delayTime) {
493        // Maximum bytes that can be send over I2C in one
494        // transmission is 32 bytes, since we need 36 bytes
495        // to update a full frame, we just split one frame
496        // to two frames.
497
498        //delayTime=delayTime/2;
499
500        Wire.beginTransmission(1); // transmit to device #1 (RGB Panel)
501        Wire.write(0);
502        for(int i=0;i<6;i++){
503                for(int j=0;j<3;j++)
504                        Wire.write(RGB_Panel[i][j]);// sends 18 bytes of lights 1~6
505        }
506        Wire.endTransmission();    // stop transmitting
507        //delay(delayTime);
508
509        Wire.beginTransmission(1); // transmit to device #1 (RGB Panel)
510        Wire.write(18);
511        for(int i=6;i<12;i++){
512                for(int j=0;j<3;j++)
513                        Wire.write(RGB_Panel[i][j]);// sends 18 bytes of lights 7~12
514        }
515        Wire.endTransmission();    // stop transmitting
516        //delay(delayTime);
517       
518} // sendFrame
519
520
521// ################################################################
522
523//////PWM//////
524//generate ON/OFF control signals, with starting and stopping PWM generator
525void innerCycle(int onTime, int offTime) {
526        pwmWrite(IR, ON);
527        delayMicroseconds(onTime);
528        pwmWrite(IR, OFF);
529        delayMicroseconds(offTime);
530} // innerCycle
531
532
533// ################################################################
534
535void emitCode(char BIT) {
536        //emitCode generate LOWs between HIGHs as same as the parameter.
537        if
538                (BIT) innerCycle(671,732);// 1
539        else
540                innerCycle(337,402);// 0
541} // emitCode
542
543
544// ################################################################
545
546void sendCode(long code) {
547        char n;
548        //starting code, with special time period.
549        innerCycle(730,392); //(773 414)
550        innerCycle(730,392);
551
552        for (n=28;n>=0;n--)  emitCode((code >> n) & 1); //getting bits out from code
553
554} // sendCode
555
556
557// ################################################################
558
559long formCode(char throttle,char yaw,char pitch) {
560        char n;
561        long mainCode=0;
562        int checkSum=0;
563
564        //throttle
565        for (n=6; n>=0; n--)  bitWrite(mainCode,17+n,bitRead(throttle,n)); //getting the first 7 digits to mainCode
566
567        bitWrite(mainCode,16,1);  //meaning unclear, possibly left button.
568
569        //channel selection first half
570        if (_channel=='C') bitWrite(mainCode,15,1);
571        else bitWrite(mainCode,15,0); //this digit equals 0 in channel A or B
572
573        for (n=6; n>=0; n--)  bitWrite(mainCode,8+n,bitRead(yaw,n));//yaw
574
575        //channel selection second half
576        if (_channel=='A') bitWrite(mainCode,7,1);
577        else bitWrite(mainCode,7,0); //if channel B or C, this digit equals 0;
578
579        bitWrite(mainCode,6,0);// meaning unclear, possibly right button.
580
581        for (n=5; n>=0; n--)  bitWrite(mainCode,n,bitRead(pitch,n));//pitch 
582               
583        // CheckSum
584        for (n=0; n<=20; n=n+4)  checkSum += ((mainCode >> n) & B1111);//sum up every 4 digits in the code
585
586        checkSum=checkSum & B1111; //get the last 4 bits of the sum
587        checkSum=(16-checkSum) & B1111;//16-sum is the formula of this helicopter
588
589        mainCode= (mainCode << 5) | (checkSum << 1); //get the last 4 digit of CheckSum
590
591        bitWrite(mainCode,0,1);  //finish code
592        return mainCode; //mainCode is a 29 bit binary number
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 TracBrowser for help on using the repository browser.