Changeset 65d5c40 in pyramid


Ignore:
Timestamp:
11/13/13 00:04:02 (6 years ago)
Author:
Steve Castellotti <sc@…>
Branches:
master
Children:
ba86b3f
Parents:
0bad654
Message:
  • parseHop() added
File:
1 edited

Legend:

Unmodified
Added
Removed
  • firmware/Puzzlebox_Pyramid/Puzzlebox_Pyramid.ino

    r0bad654 r65d5c40  
    10991099} 
    11001100 
    1101  
    1102 // ################################################################ 
    1103  
    1104 void executeHop() { 
    1105          
    1106         char inByte=0; 
    1107          
    1108         char direction; 
     1101// ################################################################ 
     1102 
     1103void setColorDirection(char direction) { 
    11091104         
    11101105        int p1; 
     
    11121107        int p3; 
    11131108         
    1114         int hopThrottle = DEFAULT_THROTTLE; 
    1115         int hopYaw = DEFAULT_YAW; 
    1116         int hopPitch = DEFAULT_PITCH; 
    1117          
    1118         while (Serial.available() == 0); 
    1119         direction = Serial.read(); 
    1120          
    1121         Serial.print("Serial.read(): "); 
    1122         Serial.println(_command); 
    1123          
    1124          
    11251109        // Set Color Pattern 
    11261110         
     
    11291113        if (direction == 'f') { 
    11301114                #if DEBUG_OUTPUT 
    1131                         Serial.println("Hop: Forward"); 
     1115                        Serial.println("Direction: Forward"); 
    11321116                #endif 
    11331117                p1 = 10; 
     
    11371121        else if (direction == 'b') { 
    11381122                #if DEBUG_OUTPUT 
    1139                         Serial.println("Hop: Backwards"); 
     1123                        Serial.println("Direction: Backwards"); 
    11401124                #endif 
    11411125                p1 = 4; 
     
    11451129        else if (direction == 'l') { 
    11461130                #if DEBUG_OUTPUT 
    1147                         Serial.println("Hop: Left"); 
     1131                        Serial.println("Direction: Left"); 
    11481132                #endif 
    11491133                p1 = 7; 
     
    11531137        else if (direction == 'r') { 
    11541138                #if DEBUG_OUTPUT 
    1155                         Serial.println("Hop: Right"); 
     1139                        Serial.println("Direction: Right"); 
    11561140                #endif 
    11571141                p1 = 1; 
     
    11611145        else if (direction == 'u') { 
    11621146                #if DEBUG_OUTPUT 
    1163                         Serial.println("Hop: Up"); 
     1147                        Serial.println("Direction: Up"); 
    11641148                #endif 
    11651149                p1 = 11; 
     
    11851169         
    11861170        sendFrame(0); 
    1187          
     1171 
     1172 
     1173} // setColorDirection 
     1174 
     1175 
     1176// ################################################################ 
     1177 
     1178void manualSlide(char direction, int hopThrottle, int hopYaw, int hopPitch) { 
     1179         
     1180//      char inByte=0; 
     1181//       
     1182//      char direction; 
     1183//       
     1184//      int p1; 
     1185//      int p2; 
     1186//      int p3; 
     1187//       
     1188//      while (Serial.available() == 0); 
     1189//      direction = Serial.read(); 
     1190//       
     1191//      Serial.print("Serial.read(): "); 
     1192//      Serial.println(_command); 
     1193         
     1194         
     1195        // Set Color Pattern 
     1196        setColorDirection(direction); 
    11881197         
    11891198         
     
    12651274        sendCode(formCode(DEFAULT_THROTTLE, DEFAULT_YAW, DEFAULT_PITCH)); 
    12661275        setColorWheel(255, 255, 0); // yellow 
    1267          
    1268          
    1269 } // setColor() 
     1276 
     1277         
     1278} // manualSlide 
     1279 
     1280 
     1281// ################################################################ 
     1282 
     1283void parseHop() { 
     1284         
     1285        char inByte=0; 
     1286         
     1287        char direction; 
     1288         
     1289        int p1; 
     1290        int p2; 
     1291        int p3; 
     1292         
     1293        int hopThrottle = DEFAULT_THROTTLE; 
     1294        int hopYaw = DEFAULT_YAW; 
     1295        int hopPitch = DEFAULT_PITCH; 
     1296         
     1297        while (Serial.available() == 0); 
     1298        direction = Serial.read(); 
     1299         
     1300        Serial.print("Serial.read(): "); 
     1301        Serial.println(direction); 
     1302         
     1303        // Set Color Pattern 
     1304        setColorDirection(direction); 
     1305         
     1306        manualHop(direction, hopThrottle, hopYaw, hopPitch); 
     1307         
     1308        setColorWheel(255, 255, 0); // yellow 
     1309         
     1310        sendCode(formCode(DEFAULT_THROTTLE, DEFAULT_YAW, DEFAULT_PITCH)); 
     1311         
     1312         
     1313} 
     1314 
     1315 
     1316// ################################################################ 
     1317 
     1318void manualHop(char direction, int hopThrottle, int hopYaw, int hopPitch) { 
     1319         
     1320        // Begin Hop 
     1321                #if DEBUG_OUTPUT 
     1322                        Serial.println("Hop: (Ascending)"); 
     1323                #endif 
     1324        while (hopThrottle < HOP_THROTTLE_MAX) { 
     1325                 
     1326                hopThrottle = hopThrottle + HOP_THROTTLE_STEP; 
     1327                if (hopThrottle > HOP_THROTTLE_MAX) 
     1328                        hopThrottle = HOP_THROTTLE_MAX; 
     1329                 
     1330                if (direction == 'f') { 
     1331                        hopPitch = hopPitch + HOP_PITCH_STEP_FORWARD; 
     1332                        if (hopPitch > HOP_PITCH_MAX) 
     1333                                hopPitch = HOP_PITCH_MAX; 
     1334                } 
     1335                 
     1336                else if (direction == 'b') { 
     1337                        hopPitch = hopPitch - HOP_PITCH_STEP_BACKWARD; 
     1338                        if (hopPitch < HOP_PITCH_MIN) 
     1339                                hopPitch = HOP_PITCH_MIN; 
     1340                } 
     1341                 
     1342                else if (direction == 'l') { 
     1343                        hopYaw = hopYaw + HOP_YAW_STEP; 
     1344                        if (hopYaw > HOP_YAW_MAX) 
     1345                                hopYaw = HOP_YAW_MAX; 
     1346                } 
     1347                 
     1348                else if (direction == 'r') { 
     1349                        hopYaw = hopYaw - HOP_YAW_STEP; 
     1350                        if (hopYaw < HOP_YAW_MIN) 
     1351                                hopYaw = HOP_YAW_MIN; 
     1352                } 
     1353                 
     1354                #if DEBUG_OUTPUT 
     1355                        Serial.print("Sending: ("); 
     1356                        Serial.print(hopThrottle); 
     1357                        Serial.print(", "); 
     1358                        Serial.print(hopYaw); 
     1359                        Serial.print(", "); 
     1360                        Serial.print(hopPitch); 
     1361                        Serial.println(")"); 
     1362                #endif 
     1363                 
     1364                sendCode(formCode(hopThrottle, hopYaw, hopPitch)); 
     1365                delay(80); //cycle(); 
     1366        } 
     1367         
     1368        // Descend 
     1369                #if DEBUG_OUTPUT 
     1370                        Serial.println("Hop: (Descending)"); 
     1371                #endif 
     1372        while (hopThrottle > DEFAULT_THROTTLE) { 
     1373                 
     1374                hopThrottle = hopThrottle - HOP_THROTTLE_STEP; 
     1375                if (hopThrottle < DEFAULT_THROTTLE) 
     1376                        hopThrottle = DEFAULT_THROTTLE; 
     1377                 
     1378                 
     1379                #if DEBUG_OUTPUT 
     1380                        Serial.print("Sending: ("); 
     1381                        Serial.print(hopThrottle); 
     1382                        Serial.print(", "); 
     1383                        Serial.print(hopYaw); 
     1384                        Serial.print(", "); 
     1385                        Serial.print(hopPitch); 
     1386                        Serial.println(")"); 
     1387                #endif 
     1388 
     1389                 
     1390                sendCode(formCode(hopThrottle, hopYaw, hopPitch)); 
     1391                delay(80); //cycle(); 
     1392        } 
     1393         
     1394         
     1395} // manualHop 
     1396 
     1397 
     1398// ################################################################ 
     1399 
     1400void executeHop() { 
     1401         
     1402        char inByte=0; 
     1403         
     1404        char direction; 
     1405         
     1406        int p1; 
     1407        int p2; 
     1408        int p3; 
     1409         
     1410        int hopThrottle = DEFAULT_THROTTLE; 
     1411        int hopYaw = DEFAULT_YAW; 
     1412        int hopPitch = DEFAULT_PITCH; 
     1413         
     1414        while (Serial.available() == 0); 
     1415        direction = Serial.read(); 
     1416         
     1417        Serial.print("Serial.read(): "); 
     1418        Serial.println(direction); 
     1419         
     1420         
     1421        // Set Color Pattern 
     1422         
     1423        setColorWheel(0, 0, 0); // black 
     1424         
     1425        if (direction == 'f') { 
     1426                #if DEBUG_OUTPUT 
     1427                        Serial.println("Hop: Forward"); 
     1428                #endif 
     1429                p1 = 10; 
     1430                p2 = 11; 
     1431                p3 = 0; 
     1432        } 
     1433        else if (direction == 'b') { 
     1434                #if DEBUG_OUTPUT 
     1435                        Serial.println("Hop: Backwards"); 
     1436                #endif 
     1437                p1 = 4; 
     1438                p2 = 5; 
     1439                p3 = 6; 
     1440        } 
     1441        else if (direction == 'l') { 
     1442                #if DEBUG_OUTPUT 
     1443                        Serial.println("Hop: Left"); 
     1444                #endif 
     1445                p1 = 7; 
     1446                p2 = 8; 
     1447                p3 = 9; 
     1448        } 
     1449        else if (direction == 'r') { 
     1450                #if DEBUG_OUTPUT 
     1451                        Serial.println("Hop: Right"); 
     1452                #endif 
     1453                p1 = 1; 
     1454                p2 = 2; 
     1455                p3 = 3; 
     1456        } 
     1457        else if (direction == 'u') { 
     1458                #if DEBUG_OUTPUT 
     1459                        Serial.println("Hop: Up"); 
     1460                #endif 
     1461                p1 = 11; 
     1462                p2 = 3; 
     1463                p3 = 7; 
     1464        } 
     1465 
     1466         
     1467         
     1468        // White 
     1469        RGB_Panel[p1][0]=255; 
     1470        RGB_Panel[p1][1]=255; 
     1471        RGB_Panel[p1][2]=255; 
     1472         
     1473        RGB_Panel[p2][0]=255; 
     1474        RGB_Panel[p2][1]=255; 
     1475        RGB_Panel[p2][2]=255; 
     1476         
     1477        RGB_Panel[p3][0]=255; 
     1478        RGB_Panel[p3][1]=255; 
     1479        RGB_Panel[p3][2]=255; 
     1480         
     1481         
     1482        sendFrame(0); 
     1483         
     1484         
     1485         
     1486        // Begin Hop 
     1487                #if DEBUG_OUTPUT 
     1488                        Serial.println("Hop: (Ascending)"); 
     1489                #endif 
     1490        while (hopThrottle < HOP_THROTTLE_MAX) { 
     1491                 
     1492                hopThrottle = hopThrottle + HOP_THROTTLE_STEP; 
     1493                if (hopThrottle > HOP_THROTTLE_MAX) 
     1494                        hopThrottle = HOP_THROTTLE_MAX; 
     1495                 
     1496                if (direction == 'f') { 
     1497                        hopPitch = hopPitch + HOP_PITCH_STEP_FORWARD; 
     1498                        if (hopPitch > HOP_PITCH_MAX) 
     1499                                hopPitch = HOP_PITCH_MAX; 
     1500                } 
     1501                 
     1502                else if (direction == 'b') { 
     1503                        hopPitch = hopPitch - HOP_PITCH_STEP_BACKWARD; 
     1504                        if (hopPitch < HOP_PITCH_MIN) 
     1505                                hopPitch = HOP_PITCH_MIN; 
     1506                } 
     1507                 
     1508                else if (direction == 'l') { 
     1509                        hopYaw = hopYaw + HOP_YAW_STEP; 
     1510                        if (hopYaw > HOP_YAW_MAX) 
     1511                                hopYaw = HOP_YAW_MAX; 
     1512                } 
     1513                 
     1514                else if (direction == 'r') { 
     1515                        hopYaw = hopYaw - HOP_YAW_STEP; 
     1516                        if (hopYaw < HOP_YAW_MIN) 
     1517                                hopYaw = HOP_YAW_MIN; 
     1518                } 
     1519                 
     1520                #if DEBUG_OUTPUT 
     1521                        Serial.print("Sending: ("); 
     1522                        Serial.print(hopThrottle); 
     1523                        Serial.print(", "); 
     1524                        Serial.print(hopYaw); 
     1525                        Serial.print(", "); 
     1526                        Serial.print(hopPitch); 
     1527                        Serial.println(")"); 
     1528                #endif 
     1529                 
     1530                sendCode(formCode(hopThrottle, hopYaw, hopPitch)); 
     1531                delay(80); //cycle(); 
     1532        } 
     1533         
     1534        // Descend 
     1535                #if DEBUG_OUTPUT 
     1536                        Serial.println("Hop: (Descending)"); 
     1537                #endif 
     1538        while (hopThrottle > DEFAULT_THROTTLE) { 
     1539                 
     1540                hopThrottle = hopThrottle - HOP_THROTTLE_STEP; 
     1541                if (hopThrottle < DEFAULT_THROTTLE) 
     1542                        hopThrottle = DEFAULT_THROTTLE; 
     1543                 
     1544                 
     1545                #if DEBUG_OUTPUT 
     1546                        Serial.print("Sending: ("); 
     1547                        Serial.print(hopThrottle); 
     1548                        Serial.print(", "); 
     1549                        Serial.print(hopYaw); 
     1550                        Serial.print(", "); 
     1551                        Serial.print(hopPitch); 
     1552                        Serial.println(")"); 
     1553                #endif 
     1554 
     1555                 
     1556                sendCode(formCode(hopThrottle, hopYaw, hopPitch)); 
     1557                delay(80); //cycle(); 
     1558        } 
     1559         
     1560         
     1561        sendCode(formCode(DEFAULT_THROTTLE, DEFAULT_YAW, DEFAULT_PITCH)); 
     1562        setColorWheel(255, 255, 0); // yellow 
     1563         
     1564         
     1565} // executeHop() 
    12701566 
    12711567 
     
    15311827                        case 's':  setStartScreen(); break; 
    15321828                        case 'h':  executeHop(); break; 
     1829                        case 'o':  parseHop(); break; 
     1830//                      case 'm':  manualSlide(); break; 
    15331831                } 
    15341832        } 
     
    15411839 
    15421840 
     1841 
Note: See TracChangeset for help on using the changeset viewer.