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);
}
}
