static int duf_sqlite_execcb( const char *sql, duf_sqexe_cb_t sqexe_cb, void *sqexe_data, int *pchanges, char **pemsg ) { int r3 = SQLITE_OK; char *emsg = ( char * ) NULL; assert( pDb ); if ( pemsg ) *pemsg = NULL; /* */ DEBUG_START( ); DUF_TRACE( sqlite, 2, "[%s] ", sql ); if ( pchanges ) *pchanges = 0; if ( duf_config->cli.dbg.nosqlite ) { DUF_TRACE( sqlite, 0, "SKIP %s", sql ); } else { r3 = sqlite3_exec( pDb, sql, sqexe_cb, sqexe_data, &emsg ); } if ( r3 == SQLITE_OK && pchanges ) *pchanges = sqlite3_changes( pDb ); DUF_TRACE( sqlite, 0, " [%s]", sql ); DUF_TRACE( sqlite, 1, "r3:%d; changes:%d", r3, pchanges ? *pchanges : -1 ); /* */ DEBUG_STEP( ); if ( pemsg ) *pemsg = emsg; else if ( emsg ) sqlite3_free( emsg ); /* */ DEBUG_ENDR3( r3 ); DUF_TRACE( sqlite, 3, "[%s] : %d", sql, r3 ); return r3; }
unsigned long long duf_sqlite_last_insert_rowid( void ) { unsigned long long li = 0; DEBUG_START( ); assert( pDb ); li = ( unsigned long long ) sqlite3_last_insert_rowid( pDb ); DUF_TRACE( sqlite, 2, " last_insert_rowid" ); DEBUG_ENDULL( li ); return ( li ); }
int duf_sqlite_close( void ) { int r3 = 0; /* */ DEBUG_START( ); if ( pDb ) r3 = sqlite3_close_v2( pDb ); pDb = NULL; DUF_TRACE( action, 0, "DB Close %s (%d)", r3 == SQLITE_OK ? "OK" : "FAIL", r3 ); r3 = sqlite3_shutdown( ); DUF_TRACE( action, 0, "DB Shutdown %s (%d)", r3 == SQLITE_OK ? "OK" : "FAIL", r3 ); /* */ DEBUG_END( ); return ( r3 ); }
int duf_sqlite_open( const char *dbpath ) { int r3 = 0; /* */ DEBUG_START( ); if ( !pDb ) { r3 = sqlite3_initialize( ); DUF_TRACE( action, 0, "DB Initialize %s (%d)", r3 == SQLITE_OK ? "OK" : "FAIL", r3 ); if ( r3 == SQLITE_OK ) { /* r3 = sqlite3_open( dbpath, &pDb ); */ r3 = sqlite3_open_v2( dbpath, &pDb, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL ); sqlite3_extended_result_codes( pDb, 1 ); DUF_TRACE( action, 0, "DB Open %s %s (%d)", dbpath, r3 == SQLITE_OK ? "OK" : "FAIL", r3 ); } } /* */ DEBUG_END( ); return ( r3 ); }
int duf_vsqlite_c( const char *fmt, int constraint_ignore, int *pchanges, va_list args ) { int r3 = 0; char *sql; DEBUG_START( ); DUF_TRACE( sqlite, 2, "[%s] ", fmt ); sql = duf_sqlite_vmprintf( fmt, args ); DUF_TRACE( sqlite, 2, "[%s] ", sql ); r3 = duf_sqlite_exec_c( sql, constraint_ignore, pchanges ); DUF_TRACE( sqlite, 3, "[%s] : %d", sql, r3 ); sqlite3_free( sql ); sql = NULL; DUF_TRACE( sqlite, 3, "r3: %d", r3 ); DEBUG_ENDR3( r3 ); return ( r3 ); }
/* ------------------------------------- *\ Subroutine used to kill DDI processes \* ------------------------------------- */ void Filicide() { char c=0; int i,nsocks = gv(nprocs); int *sockets = gv(sockets); if(USING_DATA_SERVERS()) nsocks *= 2; if(sockets == NULL) { fprintf(stdout," ddikick.x: No DDI processes to kill.\n"); } else { fprintf(stdout," ddikick.x: Sending kill signal to DDI processes.\n"); for(i=0; i<nsocks; i++) { if(sockets[i] < 0) continue; # if DDI_DEBUG DEBUG_START(DEBUG_MAX) fprintf(stdout," ddikick.x: Sending kill signal to DDI process %i.\n",i); DEBUG_END() # endif send(sockets[i],&c,1,MSG_OOB); close(sockets[i]); sockets[i] = -1; } } }
void Kickoff_PBS(const Node_info *ddinodes,const Cmdline_info *info) { char ddiinfo[] = "-ddi"; char procid[8]; char portid[8]; char nodeid[8]; char snodes[8]; char sprocs[8]; char **rargs; char **argv = info->argv; int i,j,r,iarg,nargs = info->ddiarg + info->nnodes + 8; int inode,ncpus,np = info->nprocs; int ntests; if(info->nnodes == 1) return; int tm_errno; tm_task_id *tid; tm_event_t *spawn; tm_event_t polled; struct tm_roots roots; tm_node_id *nodelist; /* ---------------------------------- *\ Initialize PBS Task Management API \* ---------------------------------- */ if(tm_init(0, &roots) != TM_SUCCESS) { fprintf(stderr, " ddikick.x: tm_init failed\n"); Fatal_error(911); } if(tm_nodeinfo(&nodelist, &np) != TM_SUCCESS) { fprintf(stderr, " ddikick.x: tm_nodeinfo failed.\n"); Fatal_error(911); } tid = (tm_task_id *) Malloc(2*np*sizeof(tm_task_id)); spawn = (tm_event_t *) Malloc(2*np*sizeof(tm_event_t)); for(i=0; i<2*np; i++) { *(tid + i) = TM_NULL_TASK; *(spawn + i) = TM_NULL_EVENT; } /* ----------------------------------------- *\ Initialize arguments to kickoff DDI tasks \* ----------------------------------------- */ rargs = (char **) Malloc(nargs*sizeof(char*)); sprintf(portid, "%d", info->kickoffport); sprintf(snodes, "%d", info->nnodes); sprintf(sprocs, "%d", info->nprocs); for(i=1,r=0; i<info->ddiarg-1; i++) rargs[r++] = argv[i]; rargs[r++] = ddiinfo; rargs[r++] = info->kickoffhost; /* kickoff host name */ rargs[r++] = portid; /* kickoff port number */ rargs[r++] = nodeid; /* rank of this node */ rargs[r++] = procid; /* rank of this process */ rargs[r++] = snodes; /* number of nodes */ rargs[r++] = sprocs; /* number of processors */ for(i=0,iarg=info->nodearg; i<info->nnodes; i++,iarg++) { rargs[r++] = argv[iarg]; } rargs[r] = NULL; /* ------------------------ *\ Spawn DDI tasks to nodes \* ------------------------ */ ncpus=ddinodes[0].cpus+ddinodes[1].cpus; for(i=ddinodes[0].cpus,inode=1; i<np; i++) { if(i == ncpus) ncpus += ddinodes[++inode].cpus; sprintf(nodeid,"%d",inode); sprintf(procid,"%d",i); # if DDI_DEBUG DEBUG_START(DEBUG_MAX) fprintf(stdout,"DDI Process %i PBS tm_spawn arguments: ",i); for(iarg=0; iarg<r; iarg++) fprintf(stdout,"%s ",rargs[iarg]); fprintf(stdout,"\n"); DEBUG_END() # endif /* ------------------------- *\ Spawn DDI Compute Process \* ------------------------- */ if(tm_spawn(r,rargs,NULL,*(nodelist+i),(tid+i),spawn+i) != TM_SUCCESS) { fprintf(stderr," ddikick.x: tm_spawn failed.\n"); Fatal_error(911); } /* ---------------------------------- *\ No data server on single node runs \* ---------------------------------- */ if(info->nnodes == 1) continue; # if DDI_DEBUG DEBUG_START(DEBUG_MAX) fprintf(stdout,"DDI Process %i PBS tm_spawn arguments: ",j); for(iarg=0; iarg<r; iarg++) fprintf(stdout,"%s ",rargs[iarg]); fprintf(stdout,"\n"); DEBUG_END() # endif j = i+np; sprintf(procid,"%d",j); /* --------------------- *\ Spawn DDI Data Server \* --------------------- */ if(tm_spawn(r,rargs,NULL,*(nodelist+i),(tid+j),spawn+j) != TM_SUCCESS) { fprintf(stderr," ddikick.x: tm_spawn failed.\n"); Fatal_error(911); } } /* -------------------------------------------------------- *\ Poll PBS to ensure each DDI process started successfully \* -------------------------------------------------------- */ ntests = np-ddinodes[0].cpus; if(USING_DATA_SERVERS()) ntests *= 2; for(i=ntests; i--; ) { if(tm_poll(TM_NULL_EVENT,&polled,1,&tm_errno) != TM_SUCCESS) { fprintf(stderr," ddikick.x: tm_poll failed.\n"); Fatal_error(911); } for(j=0; j<np; j++) { if(polled == *(spawn+j)) { if(tm_errno) { fprintf(stderr," ddikick.x: error spawning DDI task %i.\n",j); Fatal_error(911); } else { # if DDI_DEBUG DEBUG_START(DEBUG_MAX) fprintf(stdout," ddikick.x: DDI task %i started.\n",j); DEBUG_END() # endif } } if(info->nnodes == 1) continue; if(polled == *(spawn+j+np)) { if(tm_errno) { fprintf(stderr," ddikick.x: error spawning DDI task %i.\n",j+np); Fatal_error(911); } else { # if DDI_DEBUG DEBUG_START(DEBUG_MAX) fprintf(stdout," ddikick.x: DDI task %i started.\n",j+np); DEBUG_END() # endif } } } } /* -------------------------------------- *\ Close the link to the PBS Task Manager \* -------------------------------------- */ tm_finalize(); /* ---------------- *\ Free used memory \* ---------------- */ free(tid); free(spawn); free(rargs); }
int main(int argc, char *argv[]) { RedditUserLogged *user = NULL; char *subreddit = NULL; char *password = NULL, *username = NULL; optParser parser; DEBUG_START(DEBUG_FILE, DEBUG_FILENAME); memset(&parser, 0, sizeof(optParser)); parser.argc = argc; parser.argv = argv; optAddOptions (&parser, mainOptions, MOPT_ARG_COUNT); handleArguments(&parser); if (mainOptions[MOPT_HELP].isSet) { displayHelp(&parser); return 0; } optClearParser(&parser); setlocale(LC_CTYPE, ""); initscr(); raw();//We want character for character input keypad(stdscr,1);//Enable extra keys like arrowkeys noecho(); start_color(); use_default_colors(); init_pair(1, -1, -1); init_pair(2, COLOR_BLACK, COLOR_WHITE); DEBUG_PRINT(L"Starting...\n"); /* Start libreddit */ redditGlobalInit(); globalState = redditStateNew(); globalState->userAgent = redditCopyString("cReddit/0.0.1"); redditStateSet(globalState); if (mainOptions[MOPT_USERNAME].isSet) { username = mainOptions[MOPT_USERNAME].svalue; if (!mainOptions[MOPT_PASSWORD].isSet) password = getPassword(); else password = mainOptions[MOPT_PASSWORD].svalue; user = redditUserLoggedNew(); redditUserLoggedLogin(user, username, password); /* Don't want to leave that important Reddit password in memory */ memset(password, 0, strlen(password)); if (!mainOptions[MOPT_PASSWORD].isSet) free(password); } if (mainOptions[MOPT_SUBREDDIT].isSet) { subreddit = mainOptions[MOPT_SUBREDDIT].svalue; if (!startsWith("/r/", subreddit) && strcmp("/", subreddit) != 0) prepend("/r/", subreddit); } else { subreddit = "/"; } showSubreddit(subreddit); redditUserLoggedFree(user); redditStateFree(globalState); redditGlobalCleanup(); endwin(); DEBUG_END(DEBUG_FILE); return 0; }
/** * Turn servo towards 'pos' in 1 microsecond steps, waiting delay_ms * milliseconds between steps (speed = 1/delay). If check_weight weight * is true, might abort with WHERE_THE_FUCK_IS_THE_CUP error. If a valid pointer * stable_weight is passed, turns bottle until a stable weight is measured * (returns WEIGHT_NOT_STABLE if pos is reached before weight stable). * * Returns 0 when the position is reached or SERVO_OUT_OF_RANGE on error. * * For details about the built-in Servo class see: * /usr/share/arduino/libraries/Servo/Servo.cpp * */ errv_t Bottle::turn_to(int pos, int delay_ms, bool check_weight, int* stable_weight, bool enable_abortcheck) { int weight_previous1 = -9999; // just any impossible value int weight_previous2 = -9999; // ..before we have real values if (pos < SERVO_MIN || pos > SERVO_MAX) { DEBUG_MSG_LN("Invalid pos"); return SERVO_OUT_OF_RANGE; } int current_pos = servo.readMicroseconds(); if (pos == current_pos) return 0; int step = (current_pos < pos) ? 1 : -1; DEBUG_START(); DEBUG_MSG("turn "); DEBUG_MSG(number); DEBUG_MSG(", params "); DEBUG_VAL(current_pos); DEBUG_VAL(step); DEBUG_VAL(pos); DEBUG_VAL(delay_ms); DEBUG_END(); unsigned long last_called = millis(); for (int i = current_pos + step; i * step <= pos * step; i += step) { // ˆˆˆˆˆˆ ˆˆˆˆˆˆ // this inverts the relation if turning down // Warning: printing to serial delays turning! // Might help to to debug servo movement. Not necessary now, commenting // out to save bytes. //if (print_steps && i % 10 == 0) { // DEBUG_VAL_LN(i); //} // check abort only if not already aborted... if (enable_abortcheck) { // turn up and return if we should abort... errv_t ret = check_aborted(); if (ret) { // turn_up might not be necessary here, called another time // later (does not matter if called twice) turn_up(FAST_TURN_UP_DELAY, false); return ret; } } if (check_weight || stable_weight) { int weight; int ret = ads1231_get_noblock(weight); if (ret == 0) { // we got a valid weight from scale if (check_weight && weight < WEIGHT_EPSILON) { return WHERE_THE_FUCK_IS_THE_CUP; } // get next weight sample and return if weight is stable if (stable_weight) { if (weight_previous2 == weight_previous1 && weight_previous1 == weight) { *stable_weight = weight; return 0; } weight_previous2 = weight_previous1; weight_previous1 = weight; } } else if (ret != ADS1231_WOULD_BLOCK) { // ignoring if it would take too long to get weight, but // return in case of other error != 0 return ret; } } // turn servo one step delay(delay_ms); servo.writeMicroseconds(i); } // pos reached before weight stable if (stable_weight) { return WEIGHT_NOT_STABLE; } return 0; }
/** * Pour requested_amount grams from bottle.. * Return 0 on success, other values are return values of * delay_until (including scale error codes). */ errv_t Bottle::pour(int requested_amount, int& measured_amount) { // orig_weight is weight including ingredients poured until now int orig_weight, ret; while (1) { // get weight while turning bottle, because ads1231_stable_millis() // blocks bottle in pause position too long int below_pause = (pos_down + get_pause_pos()) / 2; ret = turn_to(below_pause, TURN_DOWN_DELAY, true, &orig_weight); // Note that checking weight here is a critical issue, allows hacking // the robot. If a heavy weight is placed while measuring and then // removed while pouring (results in more alcohol). Stable weight // should resolve most problems. if (ret == WEIGHT_NOT_STABLE) { ret = ads1231_get_stable_grams(orig_weight); } if (ret != 0 && ret != WHERE_THE_FUCK_IS_THE_CUP) { return ret; } if (ret == WHERE_THE_FUCK_IS_THE_CUP || orig_weight < WEIGHT_EPSILON) { // no cup... RETURN_IFN_0(wait_for_cup()); } else { // everything fine break; } } // loop until successfully poured or aborted or other fatal error while(1) { // petres wants POURING message also after resume... // https://github.com/rfjakob/barwin-arduino/issues/10 MSG(String("POURING ") + String(number) + String(" ") + String(orig_weight)); DEBUG_MSG_LN("Turn down"); ret = turn_down(TURN_DOWN_DELAY, true); // enable check_weight // wait for requested weight // FIXME here we do not want WEIGHT_EPSILON and sharp > if (ret == 0) { DEBUG_MSG_LN("Waiting"); ret = delay_until(POURING_TIMEOUT, orig_weight + requested_amount - UPGRIGHT_OFFSET, true); } if (ret == 0) break; // All good DEBUG_MSG_LN(String("pour: got err ") + String(ret)); // Bottle empty // Note that this does not work if requested_amount is less than // UPGRIGHT_OFFSET! if(ret == BOTTLE_EMPTY) { ERROR(strerror(BOTTLE_EMPTY) + String(" ") + String(number) ); // TODO other speed here? it is empty already! RETURN_IFN_0(turn_to(pos_up + BOTTLE_EMPTY_POS_OFFSET, TURN_UP_DELAY)); RETURN_IFN_0(wait_for_resume()); // might return ABORTED } // Cup was removed early else if(ret == WHERE_THE_FUCK_IS_THE_CUP) { ERROR(strerror(WHERE_THE_FUCK_IS_THE_CUP)); RETURN_IFN_0(turn_to_pause_pos(FAST_TURN_UP_DELAY)); RETURN_IFN_0(wait_for_cup()); } // other error - turn bottle up and return error code // includes: scale error, user abort, ... else { return ret; } } // We turn to pause pos and not completely up so we can crossfade RETURN_IFN_0(turn_to_pause_pos(TURN_UP_DELAY)); RETURN_IFN_0(ads1231_get_grams(measured_amount)); measured_amount -= orig_weight; DEBUG_START(); DEBUG_MSG("Stats: "); DEBUG_VAL(requested_amount); DEBUG_VAL(measured_amount); DEBUG_END(); return 0; }
static unsigned long long duf_insert_sd5_uni( duf_depthinfo_t * pdi, unsigned long long *md64, const char *msg, int need_id, int *pr ) { unsigned long long sd5id = -1; int lr = 0; int changes = 0; #ifdef MAS_TRACING const char *real_path = duf_levinfo_path( pdi ); #endif DEBUG_START( ); if ( md64 && md64[1] && md64[0] ) { if ( !DUF_CONFIGG( cli.disable.flag.insert ) ) { if ( 1 ) { static const char *sql = "INSERT OR IGNORE INTO " DUF_SQL_TABLES_SD5_FULL " ( sd5sum1, sd5sum2 ) VALUES ( :sd5sum1, :sd5sum2 )"; DUF_TRACE( sd5, 0, "%016llx%016llx %s%s", md64[1], md64[0], real_path, msg ); DUF_SQL_START_STMT( pdi, insert_sd5, sql, lr, pstmt ); DUF_TRACE( insert, 0, "S:%s", sql ); DUF_SQL_BIND_LL( sd5sum1, md64[1], lr, pstmt ); DUF_SQL_BIND_LL( sd5sum2, md64[0], lr, pstmt ); DUF_SQL_STEP( lr, pstmt ); DUF_SQL_CHANGES( changes, lr, pstmt ); DUF_SQL_END_STMT( insert_sd5, lr, pstmt ); } else { lr = duf_sql( "INSERT OR IGNORE INTO " DUF_SQL_TABLES_SD5_FULL " (sd5sum1,sd5sum2) VALUES ('%lld','%lld')", &changes, md64[1], md64[0] ); } } duf_pdi_reg_changes( pdi, changes ); if ( ( lr == DUF_SQL_CONSTRAINT || !lr ) && !changes ) { if ( need_id ) { duf_scan_callbacks_t sccb = {.leaf.fieldset = "sd5id" }; duf_sccb_handle_t csccbh = {.sccb = &sccb }; lr = duf_sql_select( duf_sel_cb_field_by_sccb, &sd5id, STR_CB_DEF, STR_CB_UDATA_DEF, &csccbh, "SELECT " DUF_SQL_IDNAME " AS sd5id FROM " DUF_SQL_TABLES_SD5_FULL " WHERE sd5sum1='%lld' AND sd5sum2='%lld'", md64[1], md64[0] ); } } else if ( !lr /* assume SQLITE_OK */ ) { if ( need_id && changes ) { sd5id = duf_sql_last_insert_rowid( ); } } else { DUF_SHOW_ERROR( "insert sd5 %d", lr ); } } else {
/* * sel_cb -- callback called for each row with: * sel_cb_udata passed * str_cb + str_cb_udata passed to be called there * fmt + args - sql * */ int duf_sqlite_vselect( duf_sel_cb_t sel_cb, void *sel_cb_udata, duf_str_cb_t str_cb, void *str_cb_udata, duf_sccb_handle_t * sccbh /*, const duf_dirhandle_t * pdhu_off */ , const char *fmt, va_list args ) { int r3 = 0; int row, column; char *sql, **presult = NULL; const char *const *pcresult = NULL; va_list qargs; DEBUG_START( ); assert( pDb ); va_copy( qargs, args ); { char *emsg = NULL; DUF_TRACE( sqlite, 2, "in for %s", fmt ); sql = sqlite3_vmprintf( fmt, args ); if ( !sql ) { DUF_SHOW_ERROR( "what happend to sql? [%s] => [%s]", fmt, sql ); } r3 = sqlite3_get_table( pDb, sql, &presult, &row, &column, &emsg ); assert( r3 != SQLITE_CORRUPT ); DUF_TRACE( sqlite, 0, " [%s]", sql ); DUF_TRACE( sqlite, 1, "r3=%d; %u rows", r3, row ); DEBUG_STEPS( sql ); /* if ( trace ) */ /* printf( "(%d) trace:[%s]\x1b[K\n", r3, sql ); */ pcresult = ( const char *const * ) presult; if ( r3 == SQLITE_OK ) { DEBUG_STEPIS( row, "rows SQLITE_OK" ); if ( row ) { int rcb = 0; for ( int ir = 1; ir <= row && rcb == 0; ir++ ) { va_list cargs; duf_record_t rrecord; va_copy( cargs, qargs ); /* * sel_cb is of duf_sel_cb_t: * */ #ifdef DUF_RECORD_WITH_NROWS rrecord.nrow = ir - 1; rrecord.nrows = row; #endif rrecord.ncolumns = column; rrecord.pnames = &pcresult[0 * column]; rrecord.presult = &pcresult[ir * column]; { rcb = ( sel_cb ) ( &rrecord, sel_cb_udata, str_cb, str_cb_udata, sccbh ); DUF_TEST_R( rcb ); DUF_TRACE( sqlite, 2, "row #%u; <sel_cb(%p) = %d", ir, ( void * ) ( unsigned long long ) sel_cb, rcb ); } } if ( rcb ) { if ( rcb == DUF_ERROR_MAX_REACHED ) { /* DUF_TRACE( action, 0, "Maximum reached" ); */ } else { /* DUF_SHOW_ERROR( "rcb:%d", rcb ); */ } } DUF_TEST_R( rcb ); DUF_TEST_R3( r3 ); DUF_TRACE( sqlite, 4, "rcb:%d; r3:%d sel_cb:%s; str_cb:%s", rcb, r3, DUF_FUNN( sel_cb ), DUF_FUNN( str_cb ) ); r3 = rcb ? rcb : r3; DUF_TEST_R3( r3 ); } else { DUF_TRACE( sqlite, 0, "Nothing by [%s]", sql ); } } else if ( r3 == SQLITE_CONSTRAINT ) { DUF_TEST_R3( r3 ); DUF_SHOW_ERROR( "SQL : %s [%s]", emsg ? emsg : "no error", sql ); } else { DUF_TEST_R3( r3 ); DUF_SHOW_ERROR( "SQL : %s [%s]", emsg ? emsg : "no error", sql ); } if ( emsg ) sqlite3_free( emsg ); emsg = NULL; sqlite3_free_table( presult ); presult = NULL; sqlite3_free( sql ); sql = NULL; } DEBUG_ENDR3( r3 ); return ( r3 ); }
int main() { int TempAngleGrab; //because the pod takes time to move, //grab the current angle, start moving the pod //then call the body turn function //(pod moves while body is turning int WhiteLine = 1; int Old, done=0; int RoomNum = 0; //------------------------------------------------------------------- // DO NOT EDIT BELOW THIS LINE! //------------------------------------------------------------------- Initialize(); // Function sets port direction bits and calls // setup routines for all of the chip's systems #if DEBUG>0 DEBUG_START(); #endif //------------------------------------------------------------------- // DO NOT EDIT ABOVE THIS LINE! //------------------------------------------------------------------- if(SOUNDSTART_ENABLE == 1) { char x = 1; LED_Turret(0); // Turn off LED turret. while(x == 1) { x = SoundStart(); } START_ENABLED = 1; } LED_Turret(2); // Turn on LED turret showing we are running. LATFbits.LATF6 = 1; // Turn on Status LED //HardwareDelayNmSec(500); while(1) { Forward_Dist(5800); // Forward over the stairs and to the first room. (about 60 inches) SERVO_ADJUST_TURRET(-70); // Look to the left HardwareDelayNmSec(100); // wait for turret to move if (UVCheck()) { HOTROOM = 1; // Set room number //TempAngleGrab = SERVO_TURRET_ANGLE; SERVO_ADJUST_TURRET(0); // turn the turret first, it turns while the body is turning Turn(-90); // Forward_Dist(1200); // Drive into the room (about 6 inches) HardwareDelayNmSec(100); Turn(30); Forward_Dist(500); // Drive into the room. LocateAndExtinguish(); } else //not in room 1, move on to two { SERVO_ADJUST_TURRET(0); // straight //Forward_Dist(1700); // Forward to Room 2. Turn(30); Forward_Dist(600); HardwareDelayNmSec(100); Turn(-30); Forward_Dist(1180); SERVO_ADJUST_TURRET(90); // Look to the right HardwareDelayNmSec(100); // wait for turret to move if(UVCheck()) { HOTROOM = 2; // Set room number TempAngleGrab = SERVO_TURRET_ANGLE; SERVO_ADJUST_TURRET(0); // straight Turn(TempAngleGrab); // Adjust body to turret position Forward_Dist(1200); // Drive into the room. HardwareDelayNmSec(100); Turn(30); Forward_Dist(500); // Drive into the room. LocateAndExtinguish(); } else//not in room 2, move on to three { SERVO_ADJUST_TURRET(0); Reverse_Dist(3400); ///3900); // Reverse to center of the room. HardwareDelayNmSec(1000); Turn(90); // Turn to the right Reverse_Dist(1900); // Back up to room 3. //Stop in front of room 3 SERVO_ADJUST_TURRET(90); // Look to the right HardwareDelayNmSec(100); // wait for turret to move if(UVCheck()) {//Flame Found! HOTROOM = 3; // Set room number TempAngleGrab = SERVO_TURRET_ANGLE; SERVO_ADJUST_TURRET(0); Turn(TempAngleGrab); // Adjust body to turret position Forward_Dist(1000); // Drive into the room. HardwareDelayNmSec(100); Turn(30); Forward_Dist(300); // Drive into the room. LocateAndExtinguish(); } else //not in room three - must be in four { SERVO_ADJUST_TURRET(0); //Forward_Dist(4400); // Drive to room 4 Forward_Dist(1550); HardwareDelayNmSec(100); Turn(45); Forward_Dist(848); HardwareDelayNmSec(100); Turn(-45); Forward_Dist(2200); //don't bother checking for UV - it's the only room left HOTROOM = 4; // Set room number HardwareDelayNmSec(1000); Turn(90); // Turn to the right Forward_Dist(1200); // Drive into the room. HardwareDelayNmSec(100); Turn(30); Forward_Dist(500); // Drive into the room. LocateAndExtinguish(); } } } ReturnFromLocateAndExtinguish(); HardwareDelayNmSec(0xFFFF); } }