bool isBeaconInRange(tSensors irSensor) // subroutine that determines whether IR beacon is in range { wait1Msec(1); int ir = SensorValue[irSensor]; // defines integer that returns current sensor value nxtDisplayCenteredTextLine(2, "ir = %d", ir); wait1Msec(1); if (ir == 0) // no beacon detected { return false; } else // beacon detected { return true; } }
task main() { byte inputs = 0; nxtDisplayCenteredTextLine(0, "HiTechnic"); nxtDisplayCenteredBigTextLine(1, "Proto"); nxtDisplayCenteredTextLine(3, "Test 1"); nxtDisplayCenteredTextLine(5, "Connect SMUX to"); nxtDisplayCenteredTextLine(6, "S1 and HTPB to"); nxtDisplayCenteredTextLine(7, "SMUX Port 1"); wait1Msec(2000); PlaySound(soundBeepBeep); while(bSoundActive) EndTimeSlice(); eraseDisplay(); while(true) { // Fetch the state of the digital IO pins. When not explicitly // configured as input or output, they will default to input. inputs = HTPBreadIO(HTPB, 0x3F); nxtDisplayTextLine(4, "D: 0x%x", (int)inputs); wait1Msec(10); } }
void hashtagyoloswagdiem(){ nxtDisplayCenteredTextLine(1, "KICKING"); wait10Msec(300); motor[Dribbler] = 0; if(SensorValue(TouchSensor) == 1){ while(SensorValue(TouchSensor) == 1){ // While the Touch Sensor is inactive (hasn't been pressed): motor[Kicker] = 100; } } while(SensorValue(TouchSensor) == 0){ // While the Touch Sensor is active (has been pressed): motor[Kicker] = 100; } motor[Kicker] = 0; motor[Dribbler] = 100; }
void corridorTurn(int currentWaypoint, int destinationWaypoint) { //Turn based on arguments. //Face sonar to the correct wall. nxtDisplayCenteredTextLine(4, "from: %d", currentWaypoint); nxtDisplayCenteredTextLine(5, "to: %d", destinationWaypoint); //wait1Msec(1000); float a = 0; switch(currentWaypoint) { case 1: a = PI/2; break; case 2: a = (destinationWaypoint == 1) ? -PI/2 : PI/2; break; case 3: a = -PI/2; break; } turnRadiansClockwise(a); }
void turnPointLeft (float mRot, float mRotPerSec) { nxtDisplayCenteredTextLine(5, "TPL(%.2f,%.2f)", mRot, mRotPerSec); if (moveModeType != MMAllMoveTypes && moveModeType != MMTurnsOnly && moveModeType != MMPointTurnsOnly) { return; } if (moveModeTiming == MMOneMoveAtATime) { waitForTouch(); } if (stepThroughMode == stepThroughModeOn) { waitForTouch(); } checkParameterRange(mRot, mRotPerSec); int leftWheelInitial = nMotorEncoder[leftWheelMotor]; int rightWheelInitial = nMotorEncoder[rightWheelMotor]; int leftWheelTarget = nMotorEncoder[leftWheelMotor] - 360 * mRot; int rightWheelTarget = nMotorEncoder[rightWheelMotor] + 360 * mRot; ClearTimer(T1); float motorPower = revolutionsPerSecondToMotorPower(mRotPerSec); motor[leftWheelMotor] = -1 * motorPower; motor[rightWheelMotor] = motorPower; while ((nMotorEncoder[leftWheelMotor] > leftWheelTarget) && (nMotorEncoder[rightWheelMotor] < rightWheelTarget)) { nxtDisplayCenteredTextLine(7, "%d", nMotorEncoder[leftWheelMotor]); } motor[leftWheelMotor] = 0; motor[rightWheelMotor] = 0; int leftWheelChange = nMotorEncoder[leftWheelMotor] - leftWheelInitial; int rightWheelChange = nMotorEncoder[rightWheelMotor] - rightWheelInitial; float revolutionsWheelsRotated = ((float) ( abs(leftWheelChange) > abs(rightWheelChange) ? leftWheelChange : rightWheelChange )) / 360.0; nxtDisplayCenteredTextLine(2, "TPL(%.2f,%.2f)", mRot, mRotPerSec); nxtDisplayCenteredTextLine(3, "%.2frev %.2fsec", (float) revolutionsWheelsRotated, (float) time10(T1) / 100); nxtDisplayCenteredTextLine(5, ""); nxtDisplayCenteredTextLine(7, ""); }
void turnRightTillLine(){ move=true; while(move) { motor[motorD] = 30; motor[motorE] = 0; sColor = SensorValue[colorport]; if (sColor > colorMid) move = false; StringFormat(disp,"%d", sColor); nxtDisplayCenteredTextLine(2, disp ); } // move in opposite direction to be back on the line motor[motorD] = 0; motor[motorE] = 0; wait10Msec(100); }
void initializeRobot() { eraseDisplay(); string print; int n = 0; while (n<400){ print = SensorValue[IRSeeker]; nxtDisplayCenteredTextLine(0,print); wait10Msec(10); n = n + 1; } return; }
//x and y in meters void navigateToWaypoint (float new_x, float new_y) { new_x *= 100; new_y *= 100; float dx = new_x - x; float dy = new_y - y; nxtDisplayCenteredTextLine(1, "x: %f", dx); nxtDisplayCenteredTextLine(2, "y: %f", dy); float targetAngle = 0; if (dy != 0) { targetAngle = atan( dx / dy ); } else { targetAngle = PI/2; } nxtDisplayCenteredTextLine(4, "TA: %f", targetAngle); //SW quadrant nxtDisplayCenteredTextLine(5, "HERE: %f", (float)0); if(dy < 0 && dx >= 0) { targetAngle += PI; nxtDisplayCenteredTextLine(5, "HERE: %f", (float)1); } //NW if (dy <= 0 && dx < 0) { targetAngle -= PI; nxtDisplayCenteredTextLine(5, "HERE: %f", (float)2); } if(dy > 0 && dx < 0) { targetAngle = -atan( abs(dx) / dy ); nxtDisplayCenteredTextLine(5, "HERE: %f", (float)3); } float newAngle = targetAngle - theta; nxtDisplayCenteredTextLine(3, "NA: %f", newAngle); wait1Msec(1000); turnNDegrees(newAngle); moveForward(sqrt((dx*dx) + (dy*dy))); }
/** * Turns around until black is found */ void turnToLine(void) { spinInDirection(); while(!isDark()) { abortTimeslice(); } int startDir = currentDirection(); while(isDark()) { abortTimeslice(); } motor[left] = 0; motor[right] = 0; int centre = startDir + (angleDifference(currentDirection(), startDir)/2); nxtDisplayCenteredTextLine(6, "cen: %i", centre); turnToAngle(centre, 0); }
task main () { int _color = 0; string _tmp; int red = 0; int green = 0; int blue = 0; nxtDisplayCenteredTextLine(0, "HiTechnic"); nxtDisplayCenteredBigTextLine(1, "COLOUR"); nxtDisplayCenteredTextLine(3, "SMUX Test"); nxtDisplayCenteredTextLine(5, "Connect SMUX to"); nxtDisplayCenteredTextLine(6, "S1 and CS to"); nxtDisplayCenteredTextLine(7, "SMUX Port 1"); wait1Msec(2000); eraseDisplay(); while (true) { // Read the currently detected colour from the sensor _color = HTCSreadColor(HTCOLOR); // If colour == -1, it implies an error has occurred if (_color < 0) { nxtDisplayTextLine(4, "ERROR!!"); nxtDisplayTextLine(5, "HTCSreadColor"); wait1Msec(2000); StopAllTasks(); } // Read the RGB values of the currently colour from the sensor // A return value of false implies an error has occurred if (!HTCSreadRGB(HTCOLOR, red, green, blue)) { nxtDisplayTextLine(4, "ERROR!!"); nxtDisplayTextLine(5, "HTCSreadRGB"); wait1Msec(2000); StopAllTasks(); } // Read the RGB values of the currently colour from the sensor // A return value of false implies an error has occurred nxtDisplayCenteredTextLine(0, "Color: %d", _color); nxtDisplayCenteredBigTextLine(1, "R G B"); nxtEraseRect(0,10, 99, 41); nxtFillRect( 0, 10, 30, 10 + (red+1)/8); nxtFillRect(35, 10, 65, 10 + (green+1)/8); nxtFillRect(70, 10, 99, 10 + (blue+1)/8); StringFormat(_tmp, " %3d %3d", red, green); nxtDisplayTextLine(7, "%s %3d", _tmp, blue); wait1Msec(100); } }
//////////////////////////////////////////////////////////////////////////////// //Select Robot Start Location (Wall) -----------------------------------------// //////////////////////////////////////////////////////////////////////////////// void selectStartLocation() { eraseDisplay(); // Enable Top Line NXT Display (Bluetooth, NXT Name & Battery Status) //bNxtLCDStatusDisplay = true; while(true) { nxtDisplayCenteredTextLine(1,"DITU SAYS WEAR"); nxtDisplayCenteredTextLine(2,"SAFETY GLASSES"); nxtDisplayCenteredTextLine(4,"Start Location:"); //------------------------------------------------ if(nNxtButtonPressed == 1) // NXT Right Triangle Button { robotStartLocation++; wait1Msec(400); } //------------------------------------------------- if(nNxtButtonPressed == 2) // NXT Left Triangle Button { robotStartLocation--; wait1Msec(400); } // Keep AutoActions within a range of valid values if (robotStartLocation > 2) robotStartLocation = 2; if (robotStartLocation < 0) robotStartLocation = 0; //------------------------------------------------- switch (robotStartLocation) { case 0: nxtDisplayCenteredTextLine(6, "Left Wall");break; case 1: nxtDisplayCenteredTextLine(6, "Corner");break; case 2: nxtDisplayCenteredTextLine(6, "Right Wall");break; case 3: nxtDisplayCenteredTextLine(6, "Under Rack");break; default: nxtDisplayCenteredTextLine(6, "Error");break; } //--------------------------------------------------------------- if(nNxtButtonPressed == 3) // NXT Orange Button { wait1Msec(400); break; } //--------------------------------------------------------------- } }
task main() { init(); //waitForStart(); // Wait for the beginning of autonomous phase. /////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////// //// //// //// Add your robot specific autonomous code here. //// //// //// /////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////// while((fs1<25&&fs1>1000||fs1<1400)||(fs2<1400||fs2<25&&fs2>1000)){ fs1 = HTFreadSensor(HTFS1); fs2 = HTFreadSensor(HTFS2); HTIRS2readAllDCStrength(HTIRS2,dcS1,dcS2,dcS3,dcS4,dcS5); nxtDisplayCenteredTextLine(1,"IRSensor\n%i\n%i\n%i\n%i\n%i)",dcS1,dcS2,dcS3,dcS4,dcS5); if(dcS1>5||dcS2>5||dcS3>5||dcS4>5||dcS5>5){ if(dcS3>dcS1&&dcS3>dcS2&&dcS3>dcS4&&dcS3>dcS5){ forward(power); } else if(dcS1+dcS2>dcS4+dcS5){ rotateLeft(power); } else if(dcS1+dcS2<dcS4+dcS5){ rotateRight(power); } else{ stop(); } } else{ forward(power/2); } } servoPos=255; stop(); wait1Msec(1000); servo[servo1]=servoPos; reverse(power); wait1Msec(500); stop(); }
task main() { string sColor; while (true) { switch (SensorValue[S4]) { case 0: sColor = "Black"; break; case 2: sColor = "Blue"; break; case 4: sColor = "Green"; break; case 6: sColor = "Yellow"; break; case 8: sColor = "Red"; break; case 17: sColor = "White"; break; default: sColor = "???"; break; } nxtDisplayCenteredTextLine(2, sColor); wait1Msec(50); } }
task main() { string sColor; while(true) { switch (SensorValue[colorSensor]) { case BLACKCOLOR: sColor = "Black"; break; case BLUECOLOR: sColor = "Blue"; break; case GREENCOLOR: sColor = "Green"; break; case YELLOWCOLOR: sColor = "Yellow"; break; case REDCOLOR: sColor = "Red"; break; case WHITECOLOR: sColor = "White"; break; default: sColor = "???"; break; } nxtDisplayCenteredTextLine(2, sColor); wait1Msec(50); } }
task main() { initializeRobot(); waitForStart(); while(nMotorEncoder[RightDrive] < 4*360*0.4) { moveForward(70); } // STEP 2: Deploy auto-scoring arm servoTarget[autoServo] = 200; wait1Msec(500); servoTarget[autoServo] = 255; wait1Msec(500); while(nMotorEncoder[RightDrive] < 4*360*0.8) { moveForward(70); } motor[LeftDrive] = 70; motor[RightDrive] = -70; while(true) { nxtDisplayCenteredTextLine(3, "Heading: %d", currHeading); wait1Msec(10); if (currHeading >= 90 && currHeading < 110) break; } halt(); resetEncoders(); wait1Msec(100); //STEP 7: Drive onto ramp while(nMotorEncoder[RightDrive] > -(4*360*3)) { moveForward(-70); } halt(); currHeading = 0.0; wait1Msec(100); }
//////////////////////////////////////////////////////////////////////////////// //Select Program--------------------------------------------------------------// //////////////////////////////////////////////////////////////////////////////// void selectProgram() { eraseDisplay(); // Enable Top Line NXT Display (Bluetooth, NXT Name & Battery Status) bNxtLCDStatusDisplay = true; while(true) { nxtDisplayCenteredTextLine(1,"DITU SAYS WEAR"); nxtDisplayCenteredTextLine(2,"SAFETY GLASSES"); nxtDisplayCenteredTextLine(4, "Select Test:"); //------------------------------------------------ if(nNxtButtonPressed == 1) { Program++; wait1Msec(400); } //------------------------------------------------- if(nNxtButtonPressed == 2) { Program--; wait1Msec(400); } //------------------------------------------------- switch (Program) { case 0: nxtDisplayCenteredTextLine(6, "No Auto");break; case 1: nxtDisplayCenteredTextLine(6, "One Auto Ring");break; case 2: nxtDisplayCenteredTextLine(6, "Two Auto Rings");break; case 3: nxtDisplayCenteredTextLine(6, "One Auto W/ Normal Rings");break; case 4: nxtDisplayCenteredTextLine(6, "Two Auto W/ Normal Rings");break; } //--------------------------------------------------------------- if(nNxtButtonPressed == 3) { eraseDisplay(); break; } //--------------------------------------------------------------- } }
task main () { nxtDisplayCenteredTextLine(0, "HiTechnic"); nxtDisplayCenteredBigTextLine(1, "MAGNETIC"); nxtDisplayCenteredTextLine(3, "Field Sensor"); nxtDisplayCenteredTextLine(4, "Test 1"); nxtDisplayCenteredTextLine(5, "Connect Sensor"); nxtDisplayCenteredTextLine(6, "to S1"); wait1Msec(2000); nxtDisplayCenteredTextLine(5, "Press enter"); nxtDisplayCenteredTextLine(6, "to set bias"); wait1Msec(2000); eraseDisplay(); while(true) { eraseDisplay(); nxtDisplayTextLine(1, "Resetting"); nxtDisplayTextLine(2, "bias"); wait1Msec(500); // Start the calibration and display the offset nxtDisplayTextLine(2, "Bias: %4d", HTMAGstartCal(HTMAG)); PlaySound(soundBlip); while(bSoundActive); while(nNxtButtonPressed != kNoButton) EndTimeSlice(); while(nNxtButtonPressed != kEnterButton) { eraseDisplay(); nxtDisplayTextLine(1, "Reading"); // Read the current calibration offset and display it nxtDisplayTextLine(2, "Bias: %4d", HTMAGreadCal(HTMAG)); nxtDisplayClearTextLine(4); // Read the current rotational speed and display it nxtDisplayTextLine(4, "Mag: %4d", HTMAGreadVal(HTMAG)); nxtDisplayTextLine(6, "Press enter"); nxtDisplayTextLine(7, "to recalibrate"); wait1Msec(100); } } }
void RightBasketFarBridge() { RightBasketFar(); goInches(2, speed); goTurn(47, speed); goInches(36, speed); goInches(10,Minspeed); wait1Msec(300); goInches(2, Minspeed); goTurn(92, speed); goInches(10, speed); goInches(1, -speed); servo[FrontHolder] = 140; wait1Msec(1500); goInches(4, MountainSpeed); servo[FrontHolder] = 0; goInches(29.25, MountainSpeed); while(1) { wait1Msec(3000); int xAxis; HTACreadX(Accel, xAxis); //stores the z value to the variable zAxis nxtDisplayCenteredTextLine(2, "X:"+xAxis); if (xAxis > 2) { goInches(.1, MountainSpeed); } else if (xAxis < -24) { goInches(.1, -MountainSpeed); } else { break; } } }
//----main----// task main () { nxtDisplayCenteredTextLine(3, "Pose Test"); wait1Msec(500); initialisePose(); //set up iterate(stepSize); //run excitation etc currentDirection = 0; //set initial currentTheta = 0; changeTheta = 0; //display data displayMax(); nxtDisplayTextLine(2, "Num Act.: %3d",numActive); nxtDisplayTextLine(4, "Direction: %1d", currentDirection); nxtDisplayTextLine(5, "currentTheta:%3d", currentTheta); nxtDisplayTextLine(6, "changeTheta:%3d", changeTheta); datalogging(); while(totalClicks<1800) { alive(); //stop NXT from sleeping totalClicks += clicks; //drive(-100,190,50); // drive(50,180,50); pose3D(changeTheta,0.5); displayMax(); nxtDisplayTextLine(2, "Num Act.: %3d",numActive); nxtDisplayTextLine(4, "Direction: %1d", currentDirection); nxtDisplayTextLine(5, "currentTheta:%3d", currentTheta); nxtDisplayTextLine(6, "changeTheta:%3d", changeTheta); clearEncoders(); //clear encoder count changeTheta=0; datalogging(); } PlaySound(soundFastUpwardTones); while(bSoundActive) {} SaveNxtDatalog(); }
//////////////////////////////////////////////////////////////////////////////// //Select Row------------------------------------------------------------------// //////////////////////////////////////////////////////////////////////////////// void selectRow() { eraseDisplay(); // Enable Top Line NXT Display (Bluetooth, NXT Name & Battery Status) //bNxtLCDStatusDisplay = true; while(true) { nxtDisplayCenteredTextLine(1,"DITU SAYS WEAR"); nxtDisplayCenteredTextLine(2,"SAFETY GLASSES"); nxtDisplayCenteredTextLine(4,"Peg Row:"); //------------------------------------------------ if(nNxtButtonPressed == 1) // NXT Right Triangle Button { Row++; wait1Msec(400); } //------------------------------------------------- if(nNxtButtonPressed == 2) // NXT Left Triangle Button { Row--; wait1Msec(400); } //--------------------------------------------------------------- // Keep Row within a range of valid values if (Row > 2) Row = 2; if (Row < 0) Row = 0; switch (Row) { case 0: nxtDisplayCenteredTextLine(6, "Bottom Row");break; case 1: nxtDisplayCenteredTextLine(6, "Middle Row");break; case 2: nxtDisplayCenteredTextLine(6, "Top Row");break; default: nxtDisplayCenteredTextLine(6, "Error");break; } //--------------------------------------------------------------- if(nNxtButtonPressed == 3) // NXT Orange Button { //////////////// You need to return a variable wait1Msec(400); //////////////// that selects the auto program break; //////////////// for later. -Jos :) } //--------------------------------------------------------------- } }
task main() { nNxtButtonTask = -2; nxtDisplayCenteredTextLine(0, "Codatex"); nxtDisplayCenteredBigTextLine(1, "RFID"); nxtDisplayCenteredTextLine(3, "Test 2"); nxtDisplayCenteredTextLine(5, "Connect sensor"); nxtDisplayCenteredTextLine(6, "to S1"); wait1Msec(2000); eraseDisplay(); nxtDisplayCenteredTextLine(3, "Start single"); nxtDisplayCenteredTextLine(4, "reading loop"); wait1Msec(2000); eraseDisplay(); // Set up the sensor for continuous readings. CTRFIDsetContinuous(CTRFID); // loop for transponder readings with continuous read function while(nNxtButtonPressed == kNoButton) { // read the transponder if (!CTRFIDreadTransponder(CTRFID, transponderID)) { eraseDisplay(); nxtDisplayTextLine(3, "Error reading"); nxtDisplayTextLine(4, "from sensor!"); wait10Msec(5000); StopAllTasks(); } nxtDisplayCenteredTextLine(3, "Transponder ID:"); nxtDisplayCenteredTextLine(4, "%s", transponderID); // Be sure to add about 200ms after each read // or you end up getting 0000000000 as a transponder address wait1Msec(200); } }
void movesStart (WaitFor waitForRoutine, float waitForParam) { nxtDisplayCenteredTextLine(5, "Starting"); if (moveModeTiming == MMOneMoveAtATime || stepThroughMode == stepThroughModeOn) { } else { switch (waitForRoutine) { case WFTouch: waitForTouch(); break; case WFLoud: waitForLoud(waitForParam); break; case WFTime: waitForTime(waitForParam); break; case WFNothing: default: break; } } }
int time(){ int d = 1; int wait_time = 0; nxtDisplayTextLine(1, "L_ARROW = +time"); nxtDisplayTextLine(2, "R_ARROW = Determine Position"); nxtDisplayTextLine(5, "Delay Time?"); bool select = false; while(!select){ nxtDisplayCenteredTextLine(3, "%d", d); if(nNxtButtonPressed == 2){ //Left arrow is button 2 wait10Msec(50); wait_time = 100*d; d++; select = false; }else if(nNxtButtonPressed == 1){ // Right arow is button 1 wait10Msec(50); select = true; } } return wait_time; }
void initializeRobot() { // Place code here to sinitialize servos to starting positions. // Sensors are automatically configured and setup by ROBOTC. They may need a brief time to stabilize. int black; wait10Msec(200); black=SensorValue[colorport]; wait10Msec(50); black=SensorValue[colorport]; colorMid=(black+(black/2)); StringFormat(disp,"%d %d", black, colorMid); nxtDisplayCenteredTextLine(2, disp ); //PlayTone(850, 100); //int white; //white= SensorValue[colorport]; //wait10Msec(200); //white= SensorValue[colorport]; // StringFormat(disp,"White is %d", white); // nxtDisplayCenteredTextLine(2, disp ); //wait10Msec(200); //PlayTone(800, 100); //wait10Msec(200); //int black= SensorValue[colorport]; // StringFormat(disp,"Black is %d", black); // nxtDisplayCenteredTextLine(2, disp ); //wait10Msec(200); //colorMid = (white+black)/2; // StringFormat(disp,"Mid is %d", colorMid); // nxtDisplayCenteredTextLine(2, disp ); //PlayTone(750, 100); //wait10Msec(500); return; }
int JedkNejblizsimu(){ dokoncil = false; while(!dokoncil){ HledejNejkratsiCestu(); string cesta; char ccesta[20]; for(int i=0; i<20 && znovu == false; i++) ccesta[i] = nejkratsiCesta[i]; StringFromChars(cesta, ccesta); nxtDisplayCenteredTextLine(0, cesta); for(int i=0; i<cestaSize; i++){ if(nejkratsiCesta[i] == 0){ dokoncil = true; break; } else if(nejkratsiCesta[i] == 'R'){ cleanExit = true; Rovne(false); } else if(nejkratsiCesta[i] == '0'){ if(PoziceRobota[2] == 3) VpravoC(); else if(PoziceRobota[2] == 1) VlevoC(); else{ Vlevo(); Vlevo();} }else if(nejkratsiCesta[i] == '1'){ if(PoziceRobota[2] == 0) VpravoC(); else if(PoziceRobota[2] == 2) VlevoC(); else{ Vlevo(); Vlevo();} }else if(nejkratsiCesta[i] == '2'){ if(PoziceRobota[2] == 1) VpravoC(); else if(PoziceRobota[2] == 3) VlevoC(); else{ Vlevo(); Vlevo();} }else if(nejkratsiCesta[i] == '3'){ if(PoziceRobota[2] == 2) VpravoC(); else if(PoziceRobota[2] == 0) VlevoC(); else{ Vlevo(); Vlevo();} } } } return nejkratsiCesta_size(); }
int getSteps() { bool cont = true; int nSteps = 0; nxtDisplayCenteredBigTextLine(0, "#STEPS:"); while(cont) { if(nNxtButtonPressed == B_LEFT) { nSteps--; } else if(nNxtButtonPressed == B_RIGHT) { nSteps++; } else if(nNxtButtonPressed == B_ORANGE) { cont = false; } nxtDisplayCenteredTextLine(3, "%i", nSteps); wait1Msec(75); } return nSteps; }
task main() { int distance_in_cm =30; // Create variable 'distance_in_cm' and initialize it to 20(cm). while (true) { nxtDisplayCenteredTextLine(7, "%d", SensorValue[sonarSensor]); if (SensorValue[sonarSensor] > distance_in_cm) // While the Sonar Sensor readings are less than the specified, 'distance_in_cm': { motor[motorA] = 35; // Motor B is run at a 75 power level motor[motorB] = 35; // Motor C is run at a 75 power level } else { motor[motorA] = 0; motor[motorB] = 0; } } }
task main() { initializeRobot(); while(true) { getJoystickSettings(joystick); if(joy1_TopHat > 0) { for (int i = 1; i < 10; i++) { if (joy1Btn (i) == 1) { nxtDisplayCenteredTextLine( 1, "Button %d pushed.",i ); } } } } }
task main() { initializeRobot(); initialize_gyro(); starttask(process_gyro); while(true) { nxtDisplayCenteredTextLine(3, "A gyro=%d", gyro.total/1000.0); } //move(1, 22.5); //wait10Msec(500); //move(-1,22.5); //move forward, turn 45 degrees, move forward //move(1, 24); //wait10Msec(50); //move(1, 0); //turngyro_left(45.0, 50); //move(1, 33.941); }
task main() { ubyte msg=0; SensorType[TOUCH1]=sensorTouch; SensorType[TOUCH2]=sensorTouch; SensorType[TOUCH3]=sensorTouch; checkLink(); PlayTone(400,100); eraseDisplay(); while(true){ //do not attempt to do encoding until you know your bot // is able to communicate and send the simple incrementing number over // to the worker bot //msg=encodeByAdd(); //msg=encodeByBits(); msg = (msg<255 ? ++msg : 0); //simply just send 1, 2, ... up to 255, then recycle nxtDisplayCenteredTextLine(3,"%d", msg); sndOver(msg); wait1Msec(20); } }