/** * Creates an array of string pointer where each non null entry is malloced and * needs to be freed * * * @param basedir* * @param JVMUserArgs* initialize JVMUserArgs with values from developer config file */ void JVMUserArgs_initializeDefaults(JVMUserArgs *userArgs, TCHAR* basedir) { TCHAR jvmArgID[MAX_OPTION_NAME + 1] = {0}; TCHAR argvalue[LAUNCHER_MAXPATH + 1] ={0}; JVMUserArg* keys = userArgs->args; int index = 0; int found = 0; do { _stprintf_s(jvmArgID, MAX_OPTION_NAME, _T("jvmuserarg.%d.name"), (index+1)); found = getConfigValue(basedir, jvmArgID, argvalue, LAUNCHER_MAXPATH); if (found) { keys->name = wcsdup(argvalue); _stprintf_s(jvmArgID, MAX_OPTION_NAME, _T("jvmuserarg.%d.value"), (index+1)); found = getConfigValue(basedir, jvmArgID, argvalue, LAUNCHER_MAXPATH); if (found) { //allow use to specify everything in name only keys->value = wcsdup(argvalue); } else { keys->value = wcsdup(_T("")); } index++; keys++; userArgs->initialElements++; userArgs->currentSize++; } } while (found && index < userArgs->maxSize); }
int bartlby_extension_startup(void * shm_addr, void * dataLoaderHandle, char * configfile) { _log(LH_MOD, B_LOG_INFO, "extlogger: %s", configfile); /* extlogger_type= extlogger_host= extlogger_user= extlogger_password= extlogger_db= */ cType = getConfigValue("extlogger_type", configfile); cHost = getConfigValue("extlogger_host", configfile); cUser = getConfigValue("extlogger_user", configfile); cPassword = getConfigValue("extlogger_password", configfile); cDB = getConfigValue("extlogger_db", configfile); if(cType == NULL || cHost == NULL || cUser == NULL || cPassword == NULL || cDB == NULL) { _log(LH_MOD, B_LOG_CRIT, "extlogger: configuration failed 'extlogger_type', 'extlogger_host', 'extlogger_user', 'extlogger_password', 'extlogger_db'"); } gHdr=bartlby_SHM_GetHDR(shm_addr); gDataLoaderHandle=dataLoaderHandle; gCFG=configfile; _log(LH_MOD, B_LOG_INFO, "Extlogger initiated"); return EXTENSION_OK; }
int UpdateServerGroup(struct servergroup * svc, char *config) { /* modify worker */ MYSQL *mysql; int rtc; char * sqlupd; char * mysql_host = getConfigValue("mysql_host", config); char * mysql_user = getConfigValue("mysql_user", config); char * mysql_pw = getConfigValue("mysql_pw", config); char * mysql_db = getConfigValue("mysql_db", config); mysql=mysql_init(NULL); BARTLBY_SQL_PROTECTION_INIT; CHK_ERR(mysql,NULL); mysql_real_connect(mysql, mysql_host, mysql_user, mysql_pw, NULL, 0, NULL, 0); CHK_ERR(mysql,NULL); mysql_select_db(mysql, mysql_db); CHK_ERR(mysql,NULL); CHECKED_ASPRINTF(&sqlupd, UPDATE_SERVERGROUP, BARTLBY_SQL_PROTECTION(svc->servergroup_name), svc->servergroup_notify, svc->servergroup_active, BARTLBY_SQL_PROTECTION(svc->servergroup_members), svc->servergroup_dead, BARTLBY_SQL_PROTECTION(svc->enabled_triggers), svc->orch_id, svc->servergroup_id ); mysql_query(mysql, sqlupd); CHK_ERR(mysql,NULL); free(sqlupd); rtc=1; BARTLBY_MYSQL_CLOSE(mysql); free(mysql_host); free(mysql_user); free(mysql_pw); free(mysql_db); return rtc; }
string Triggerconf::getConfigValue (string path) { if (! checkItemCount (path, 3)) return ""; STRING_LIST items = tokenize (path); return getConfigValue (items [0], items [1], items [2]); }
long ZLIntegerRangeOption::value() const { if (!myIsSynchronized) { myValue = stringToInteger(getConfigValue(), myDefaultValue, myMinValue, myMaxValue); myIsSynchronized = true; } return myValue; }
double ZLDoubleOption::value() const { if (!myIsSynchronized) { myValue = stringToDouble(getConfigValue(), myDefaultValue); myIsSynchronized = true; } return myValue; }
const std::string &ZLStringOption::value() const { if (!myIsSynchronized) { myValue = getConfigValue(myDefaultValue); myIsSynchronized = true; } return myValue; }
ZLColor ZLColorOption::value() const { if (!myIsSynchronized) { myIntValue = stringToInteger(getConfigValue(), myDefaultIntValue); myIsSynchronized = true; } return ZLColor(myIntValue); }
void notifyWaitingStart(StartMatch* startMatch, OutputStream* pcOutputStream) { appendString(pcOutputStream, NOTIFY_TO_PC_RESET); appendString(getAlwaysOutputStreamLogger(), "CFG:"); appendBinary16(getAlwaysOutputStreamLogger(), getConfigValue(startMatch->robotConfig), 4); println(getAlwaysOutputStreamLogger()); appendString(getAlwaysOutputStreamLogger(), "Waiting start:"); }
void getConfigValueGroup( const char *name, char *setting, const char *formStart, const char *formEnd ) { char *p, *q, *r; char target[BUFSIZ]; sprintf( target, "name=\"%s\"", name ); p = strstr( formStart, target ); while ( p && (p < formEnd) ) { q = strchr( p, '>' ); if ( q < formEnd ) { while ( p > formStart ) { p--; if ( *p == '<' ) { r = strstr( p, "checked" ); if ( r && (r < q) ) getConfigValue( name, setting, p, q ); p = strstr( q + 1, target ); break; } } } } }
bool ZLBooleanOption::value() const { if (!myIsSynchronized) { myValue = stringToBoolean(getConfigValue(), myDefaultValue); myIsSynchronized = true; } return myValue; }
void getConfigValueChecked( const char *name, char *setting, const char *formStart, const char *formEnd ) { char *p, *q, *r, *s; char target[BUFSIZ]; sprintf( target, "name=\"%s\"", name ); p = strstr( formStart, target ); if ( p && (p < formEnd) ) { r = p; while ( p > formStart ) { p--; if ( !strncmp( p, "<input ", 7 ) ) { s = p; p += 7; q = strstr( p, "checked" ); if ( q ) { if ( q < r ) { getConfigValue( name, setting, s, formEnd ); } else { s = r + strlen( target ); getConfigValueChecked( name, setting, s, formEnd ); } break; } } } } }
bool DirectorCore::buildProcessMap(void) noexcept { // search existing processes for those we should be managing (not 100% foolproof) process_state_t state; std::set<pid_t> pidlist; const pid_t thispid = posix::getpid(); if(proclist(pidlist) == posix::success_response) { for(pid_t pid : pidlist) { posix::memset(reinterpret_cast<void*>(&state), 0, sizeof(state)); if(procstat(pid, state) && // if get process state works AND (!state.parent_process_id || state.parent_process_id == thispid)) // process has unknown parent process OR director is the parent process for(const std::string& config : getConfigList()) // try each config if(getConfigValue(config, "/Process/Executable") == state.executable) // if the executable matches { m_process_map[config]->add(thispid, pid); // claim this as a managed process posix::memset(reinterpret_cast<void*>(&state), 0, sizeof(state)); // wipe process state for safety for(pid_t childpid : pidlist) if(procstat(childpid, state) && // if get process state works AND state.parent_process_id == pid) // process is a child of this parent pid m_process_map[config]->add(pid, childpid); // claim this as a managed process } } return true; } return false; }
ZLBoolean3 ZLBoolean3Option::value() const { if (!myIsSynchronized) { myValue = (ZLBoolean3)stringToInteger(getConfigValue(), myDefaultValue); myIsSynchronized = true; } return myValue; }
QString ProgramOptions::getHomeQFDirectory() const { QString cfg=getConfigValue("quickfit/homedir", "").toString(); if (!cfg.isEmpty() && QDir(cfg).exists()) return cfg; QDir d=QDir::home(); if (!QDir(d.absolutePath()+"/quickfit3").exists()) d.mkdir("quickfit3"); return d.absolutePath()+"/quickfit3/"; }
int DeleteServerGroup(long servergroup_id, char * config) { MYSQL *mysql; char * sqlupd; char * mysql_host = getConfigValue("mysql_host", config); char * mysql_user = getConfigValue("mysql_user", config); char * mysql_pw = getConfigValue("mysql_pw", config); char * mysql_db = getConfigValue("mysql_db", config); mysql=mysql_init(NULL); BARTLBY_SQL_PROTECTION_INIT; CHK_ERR(mysql,NULL); mysql_real_connect(mysql, mysql_host, mysql_user, mysql_pw, NULL, 0, NULL, 0); CHK_ERR(mysql,NULL); mysql_select_db(mysql, mysql_db); CHK_ERR(mysql,NULL); CHECKED_ASPRINTF(&sqlupd, DEL_SERVERGROUP, servergroup_id); //Log("dbg", sqlupd); mysql_query(mysql, sqlupd); CHK_ERR(mysql,NULL); free(sqlupd); BARTLBY_MYSQL_CLOSE(mysql); free(mysql_host); free(mysql_user); free(mysql_pw); free(mysql_db); return 1; }
void loadMatchSide() { matchSide = getConfigValue() & CONFIG_COLOR_BLUE_MASK; if (matchSide != 0) { matchSide = SIDE_BLUE; } else { matchSide = SIDE_YELLOW; } writeStringCR(getMatchSideAsString()); }
bool ProNovoConfig::getParameters() { string sTemp; istringstream issStream; // Extract the elements inside <Peptide_Identification> getConfigValue("[Peptide_Identification]Search_Type", sSearchType); getConfigValue("[Peptide_Identification]Search_Name", sSearchName); getConfigValue("[Peptide_Identification]FASTA_Database", sFASTAFilename); getConfigValue("[Peptide_Identification]Fragmentation_Method", sFragmentationMethod); if(sSearchType == "Regular") { getConfigValue("[Peptide_Identification]Max_PTM_Count", sTemp); issStream.clear(); issStream.str( sTemp ); issStream >> iMaxPTMcount; }
long ServerGroupChangeId(long from, long to, char * config) { MYSQL *mysql; char * sqlupd; char * mysql_host = getConfigValue("mysql_host", config); char * mysql_user = getConfigValue("mysql_user", config); char * mysql_pw = getConfigValue("mysql_pw", config); char * mysql_db = getConfigValue("mysql_db", config); mysql=mysql_init(NULL); BARTLBY_SQL_PROTECTION_INIT; CHK_ERR(mysql,NULL); mysql_real_connect(mysql, mysql_host, mysql_user, mysql_pw, NULL, 0, NULL, 0); CHK_ERR(mysql,NULL); mysql_select_db(mysql, mysql_db); CHK_ERR(mysql,NULL); CHECKED_ASPRINTF(&sqlupd, SERVERGROUP_CHANGE_ID, to, from); mysql_query(mysql, sqlupd); CHK_ERR(mysql,NULL); free(sqlupd); BARTLBY_MYSQL_CLOSE(mysql); free(mysql_host); free(mysql_user); free(mysql_pw); free(mysql_db); return to; }
void setConfigValue(const std::string &configKey, const std::string &value) { if (configKey == APPBUILD) { SetAppBuild(value); return; } else if (configKey == APPID) { SetAppBranch(value); return; } dbCreateTables(); sqlite3x::sqlite3_connection db(CONFIG_DB()); ERROR_OUTPUT(gcString("Setting key \"{0}\" to value \"{1}\"", configKey, value).c_str()); if(getConfigValue(configKey).length() > 0) { try { sqlite3x::sqlite3_command cmd(db, "UPDATE config_string SET value=? WHERE key=?;"); cmd.bind(1, value); cmd.bind(2, configKey); cmd.executenonquery(); } catch(std::exception &e) { ERROR_OUTPUT(gcString("Failed to update key \"{0}\" with value \"{1}\": \"{2}\"!\n", configKey, value, e.what()).c_str()); } } else { try { sqlite3x::sqlite3_command cmd(db, "INSERT INTO config_string VALUES(?,?);"); cmd.bind(1, configKey); cmd.bind(2, value); cmd.executenonquery(); } catch(std::exception &e) { ERROR_OUTPUT(gcString("Failed to insert key \"{0}\" with value \"{1}\": \"{2}\"!\n", configKey, value, e.what()).c_str()); } } return; }
void bartlby_check_sirene(char * configfile, void * bartlby_address) { struct service svc; char * cfg_sirene_wait; int sirene_retry; int diff; cfg_sirene_wait=getConfigValue("sirene_interval", configfile); if(cfg_sirene_wait == NULL) { _log(LH_ACK, B_LOG_INFO,"'sirene_interval' not set defaulting to 600 seconds re-notify"); sirene_retry=600; } else { sirene_retry=atoi(cfg_sirene_wait); free(cfg_sirene_wait); } diff=time(NULL)-last_sirene; if(diff <= sirene_retry) { sleep(2); //usually ok and be nice to CPU return; } last_sirene=time(NULL); svc.srv=malloc(sizeof(struct server)); if(svc.srv == NULL) { _log(LH_ACK, B_LOG_CRIT,"malloc failed in bartlby_check_sirene()"); return; } sprintf(svc.srv->client_ip, "0.0.0.0"); sprintf(svc.srv->server_name, "CORE"); sprintf(svc.service_name, "SIRENE"); sprintf(svc.new_server_text, "Your system is in sirene mode all checks have been disabled please give the UI a bit attention"); svc.current_state=STATE_SIRENE; //svc.client_port=0; svc.last_state=STATE_SIRENE; _log(LH_PERF, B_LOG_CRIT,"!!! System is in sirene Mode !!!!"); bartlby_trigger(&svc,configfile, bartlby_address, 0, 0); }
//Constructs full path to the main jar file //return false if not found bool getMainJar(TCHAR* basedir, TCHAR* jar, int buffer_size) { TCHAR jarname[LAUNCHER_MAXPATH] = {0}; TCHAR jar_relative[LAUNCHER_MAXPATH] = {0}; TCHAR jar_full[LAUNCHER_MAXPATH] = {0}; if (!getConfigValue(basedir, CONFIG_MAINJAR_KEY, jarname, LAUNCHER_MAXPATH)) { return false; } _tcscat_s(jar_relative, LAUNCHER_MAXPATH, MAINJAR_FOLDER); _tcscat_s(jar_relative, LAUNCHER_MAXPATH - _tcslen(jar_relative), jarname); bool ret = getFileInPackage(basedir, jar_relative, jar_full, LAUNCHER_MAXPATH); _tcscat_s(jar, LAUNCHER_MAXPATH - _tcslen(jar), jar_full); return ret; }
//Constructs full path to the main jar file //return false if not found int getMainJar(char* basedir, char* jar, int buffer_size) { char jarname[MAX_PATH] = {0}; char jar_relative[MAX_PATH] = {0}; char jar_full[MAX_PATH] = {0}; if (!getConfigValue(basedir, CONFIG_MAINJAR_KEY, jarname, MAX_PATH)) { return FALSE; } strcat(jar_relative, MAINJAR_FOLDER); strcat(jar_relative, jarname); int ret = getFileInPackage(basedir, jar_relative, jar_full, MAX_PATH); strcat(jar, jar_full); return ret; }
int bartlby_extension_startup(void * shm_addr, void * dataLoaderHandle, char * configfile) { _log(LH_MOD, B_LOG_INFO, "distributive: %s", configfile); distr_command = getConfigValue("distributive_command", configfile); if(distr_command == NULL) { _log(LH_MOD, B_LOG_CRIT, "distributive: configuration failed 'distributive_command'"); } gHdr=bartlby_SHM_GetHDR(shm_addr); gDataLoaderHandle=dataLoaderHandle; gCFG=configfile; _log(LH_MOD, B_LOG_INFO, "distributive initiated"); return EXTENSION_OK; }
/* * Get use options from either defaults or from user preferences in registry */ int addUserOptions(TCHAR* basedir, JavaVMOption* options, int cnt) { JVMUserArg args[MAX_OPTIONS]; //Make sure we don't go over JVMUserArgs jvmUserArgs; TCHAR appid[LAUNCHER_MAXPATH + 1] = {0}; TCHAR argvalue[LAUNCHER_MAXPATH + 1] = {0}; jvmUserArgs.args = args; jvmUserArgs.currentSize = 0; jvmUserArgs.initialElements = 0; jvmUserArgs.maxSize = MAX_OPTIONS - cnt; memset(&args, 0, sizeof (JVMUserArg)*(MAX_OPTIONS - cnt)); //Add property to command line for preferences id if (getConfigValue(basedir, CONFIG_APP_ID_KEY, appid, LAUNCHER_MAXPATH)) { _stprintf_s(argvalue, LAUNCHER_MAXPATH, _T("-D%s=%s"), CONFIG_APP_ID_KEY, appid); char* result = convertToDupedChar(argvalue); if (result != NULL) { //optionString is malloced options[cnt].optionString = result; cnt++; } JVMUserArgs_initializeDefaults(&jvmUserArgs, basedir); //Copy all user args to options int i; for (i = 0; i < jvmUserArgs.currentSize; i++) { getJvmUserArg(appid, &args[i]); //optionString needs to be malloced - JVMUserArg_toString returns malloced string char* jvmOption = JVMUserArg_toString(basedir, args[i], TRUE); if (jvmOption != NULL) { options[cnt].optionString = jvmOption; cnt++; } } } else { printf("WARNING: %s not defined:", CONFIG_APP_ID_KEY); } return cnt; }
//Constructs full path to the main jar file //return false if not found int getMainJar(char* basedir, char* jar, int buffer_size) { char jarname[MAX_PATH] = {0}; char jar_relative[MAX_PATH] = {0}; char jar_full[MAX_PATH] = {0}; if (!getConfigValue(basedir, CONFIG_MAINJAR_KEY, jarname, MAX_PATH)) { return FALSE; } strcat(jar_relative, MAINJAR_FOLDER); //strcat(jar_relative, jarname); if(boinc_resolve_filename(jarname, (jar_relative+strlen(MAINJAR_FOLDER)), MAX_PATH-strlen(MAINJAR_FOLDER))) { printf("Unable to resolve file (%s) via boinc_resolve_filename!\n", jarname); return FALSE; } int ret = getFileInPackage(basedir, jar_relative, jar_full, MAX_PATH); strcat(jar, jar_full); return ret; }
int bartlby_extension_startup(void * shm_addr, void * dataLoaderHandle, char * configfile) { int x; struct service * svcmap; unsigned char new_hash_bin[SHA_DIGEST_LENGTH]; char new_hash_str[40]; _log("statehistory: %s", configfile); cfg_statehistory_dir = getConfigValue("statehistory_logdir", configfile); gHdr=bartlby_SHM_GetHDR(shm_addr); gDataLoaderHandle=dataLoaderHandle; gCFG=configfile; svcmap=bartlby_SHM_ServiceMap(shm_addr); if(cfg_statehistory_dir == NULL) { _log("statehistory you have to set 'statehistory_logdir'"); } _log("statehistory: servicescount->%ld", gHdr->svccount); state_hash_map = malloc(sizeof(struct service_hash_map)*(gHdr->svccount+1)); //initial hashing for(x=0; x<gHdr->svccount; x++) { state_hash_map[x].service_id=svcmap[x].service_id; SHA1(svcmap[x].new_server_text, strlen(svcmap[x].new_server_text), new_hash_bin); convertSHA1BinaryToCharStr(new_hash_bin, new_hash_str); sprintf(state_hash_map[x].sha1_hash, "%s", new_hash_str); state_hash_map[x].last_write = time(NULL); } return EXTENSION_OK; }
const std::string &ZLOption::getConfigValue() const { return getConfigValue(EMPTY_STRING); }
int main(void) { setBoardName("TITAN ELECTRONICAL MAIN BOARD 32bits V-JJ_7"); i2cMasterInitialize(); //setRobotMustStop(false); // Open the serial Link for debug openSerialLink(&debugSerialStreamLink, &debugInputBuffer, &debugInputBufferArray, MAIN_BOARD_DEBUG_INPUT_BUFFER_LENGTH, &debugOutputBuffer, &debugOutputBufferArray, MAIN_BOARD_DEBUG_OUTPUT_BUFFER_LENGTH, &debugOutputStream, SERIAL_PORT_DEBUG, DEFAULT_SERIAL_SPEED); // Open the serial Link for the PC openSerialLink(&pcSerialStreamLink, &pcInputBuffer, &pcInputBufferArray, MAIN_BOARD_PC_INPUT_BUFFER_LENGTH, &pcOutputBuffer, &pcOutputBufferArray, MAIN_BOARD_PC_OUTPUT_BUFFER_LENGTH, &pcOutputStream, SERIAL_PORT_PC, DEFAULT_SERIAL_SPEED); // LCD (LCD03 via Serial interface) initLCDOutputStream(&lcdOutputStream); initTimerList(&timerListArray, MAIN_BOARD_TIMER_LENGTH); // Init the logs initLog(DEBUG); addLogHandler(&debugSerialLogHandler, "UART", &debugOutputStream, DEBUG); addLogHandler(&lcdLogHandler, "LCD", &lcdOutputStream, ERROR); appendString(getAlwaysOutputStreamLogger(), getBoardName()); println(getAlwaysOutputStreamLogger()); initDevicesDescriptor(); initDriversDescriptor(); i2cMasterInitialize(); // Initialize EEPROM and RTC initClockPCF8563(&globalClock); init24C512Eeprom(&eeprom_); initRobotConfigPic32(&robotConfig); initStartMatchDetector32(&startMatchDetector); // Initializes the opponent robot // initOpponentRobot(); /* // Creates a composite to notify both PC and Debug initCompositeOutputStream(&compositePcAndDebugOutputStream); addOutputStream(&compositePcAndDebugOutputStream, &debugOutputStream); addOutputStream(&compositePcAndDebugOutputStream, &pcOutputStream); // Creates a composite to redirect to driverRequest and Debug initCompositeOutputStream(&compositeDriverAndDebugOutputStream); addOutputStream(&compositeDriverAndDebugOutputStream, &debugOutputStream); addOutputStream(&compositeDriverAndDebugOutputStream, getDriverRequestOutputStream()); */ appendString(&debugOutputStream, "DEBUG\n"); // Start interruptions //startTimerList(); //////RALENTI FORTEMENT LE PIC!!! PLANTE I2C !!!!!!!! // Configure data dispatcher //addLocalDriverDataDispatcher(); // Stream for motorBoard /* addI2CDriverDataDispatcher(&motorI2cDispatcher, "MOTOR_BOARD_DISPATCHER", &motorBoardInputBuffer, &motorBoardInputBufferArray, MAIN_BOARD_LINK_TO_MOTOR_BOARD_BUFFER_LENGTH, &motorBoardOutputStream, &motorBoardInputStream, MOTOR_BOARD_I2C_ADDRESS); */ /* // Stream for Mechanical Board 2 addI2CDriverDataDispatcher(&mechanical2I2cDispatcher, "MECHANICAL_BOARD_2_DISPATCHER", &mechanical2BoardInputBuffer, &mechanical2BoardInputBufferArray, MAIN_BOARD_LINK_TO_MECA_BOARD_2_BUFFER_LENGTH, &mechanical2BoardOutputStream, &mechanical2BoardInputStream, MECHANICAL_BOARD_2_I2C_ADDRESS); */ /* // Stream for Air Conditioning addI2CDriverDataDispatcher(&airConditioningI2cDispatcher, "AIR_CONDITIONING_DISPATCHER", &airConditioningBoardInputBuffer, &airConditioningBoardInputBufferArray, MAIN_BOARD_LINK_TO_AIR_CONDITIONING_BOARD_BUFFER_LENGTH, &airConditioningBoardOutputStream, &airConditioningBoardInputStream, AIR_CONDITIONING_BOARD_I2C_ADDRESS); */ // I2C Debug initI2CDebugBuffers(&i2cMasterDebugInputBuffer, &i2cMasterDebugInputBufferArray, MAIN_BOARD_I2C_DEBUG_MASTER_IN_BUFFER_LENGTH, &i2cMasterDebugOutputBuffer, &i2cMasterDebugOutputBufferArray, MAIN_BOARD_I2C_DEBUG_MASTER_OUT_BUFFER_LENGTH); appendStringConfig(&lcdOutputStream); //pingDriverDataDispatcherList(getDebugOutputStreamLogger()); // Inform PC waiting showWaitingStart(&debugOutputStream); // wait other board initialization delaymSec(1500); // 2012 VALUE unsigned int configValue = getConfigValue(); unsigned int homologationIndex = configValue & CONFIG_STRATEGY_MASK; unsigned int color = configValue & CONFIG_COLOR_BLUE_MASK; appendString(getAlwaysOutputStreamLogger(), "Homologation:"); appendCRLF(getAlwaysOutputStreamLogger()); appendDec(getAlwaysOutputStreamLogger(), homologationIndex); appendString(getAlwaysOutputStreamLogger(), "Config:"); appendHex4(getAlwaysOutputStreamLogger(), configValue); appendCRLF(getAlwaysOutputStreamLogger()); useBalise = configValue & CONFIG_USE_BALISE_MASK; useInfrared = configValue & CONFIG_USE_SONAR_MASK; if (color != 0) { appendString(getAlwaysOutputStreamLogger(), "COLOR:VIOLET\n"); } else { appendString(getAlwaysOutputStreamLogger(), "COLOR:RED\n"); } // TODO 2012 SV motionDriverMaintainPosition(); // wait for start // setInitialPosition(color); // notify game strategy // sendStrategyConfiguration(configValue); loopUntilStart(&waitForInstruction); // Enable the sonar Status only after start //setSonarStatus(configValue & CONFIG_USE_SONAR_MASK); // mark that match begins markStartMatch(); // write begin of match showStarted(&pcOutputStream); if (homologationIndex == 0) { // MATCH while (1) { waitForInstruction(); //CLOCK Read if (isEnd()) { break; } } } else { setReadyForNextMotion(true); while (1) { portableStartI2C(i2cBus); WaitI2C(i2cBus); portableMasterWriteI2C(FREE_ADDRESS_2);//0x54 WaitI2C(i2cBus); portableMasterWriteI2C('H'); WaitI2C(i2cBus); portableMasterWriteI2C('E'); WaitI2C(i2cBus); portableMasterWriteI2C('L'); WaitI2C(i2cBus); portableMasterWriteI2C('L'); WaitI2C(i2cBus); portableMasterWriteI2C('O'); portableStopI2C(i2cBus); WaitI2C(i2cBus); int data1,data2,data3; while(1){ waitForInstruction(); //globalClock.readClock(&globalClock); //printClock(&debugOutputStream,&globalClock); //appendCR(&debugOutputStream); int data = 0; portableMasterWaitSendI2C(i2cBus); portableStartI2C(i2cBus); IdleI2C1(); portableMasterWriteI2C(FREE_ADDRESS_2 + 1);//0x54 WaitI2C(i2cBus); data = portableMasterReadI2C(i2cBus); portableAckI2C(i2cBus); IdleI2C1(); data1 = portableMasterReadI2C(i2cBus); portableAckI2C(i2cBus); IdleI2C1(); data2= portableMasterReadI2C(i2cBus); portableAckI2C(i2cBus); IdleI2C1(); data3 = portableMasterReadI2C(i2cBus); portableNackI2C(i2cBus); IdleI2C1(); append(&lcdOutputStream,data); append(&lcdOutputStream,data1); append(&lcdOutputStream,data2); append(&lcdOutputStream,data3); portableStopI2C(i2cBus); IdleI2C1(); delaymSec(500); } homologation(homologationIndex, color); // We stop if we are in homologation mode if (isRobotMustStop()) { motionDriverStop(); break; } // ultimate tentative to restart the robot if it is blocked forceRobotNextStepIfNecessary(); } } showEnd(&lcdOutputStream); while (1) { // Avoid reboot even at end } }
int main(int argc,char *argv[]) { const int BUF_SIZE=1024; const int CMDLEN=50; int sockfd;//atoi(argv[1]); struct FTS fts; char command[BUF_SIZE]; int index; struct COMMAND cmd; char user[CMDLEN]; char arg[BUF_SIZE]; const char* prompt="FTS> "; int numlogs,logfilesize; struct CONFIG_READER cfg; struct LOGGER lg; char ip[CMDLEN]; llg=≶ signal(SIGKILL,handle); createConfigReader(&cfg,"config.cfg"); //printf("after config reader\n"); getConfigValue("NLOGFILES",arg,&cfg); numlogs=atoi(arg); getConfigValue("LOGFILESIZE",arg,&cfg); logfilesize=atoi(arg); destroyConfigReader(&cfg); //printf("after destroy config reader\n"); createLogger(&lg,"client_log","./client_logs",numlogs,logfilesize); //printf("after create logger\n"); strncpy(arg,argv[1],BUF_SIZE); //printf("arg: %s\n",arg); strncpy(user,strtok(arg,"@"),BUF_SIZE); //printf("user: %s\n",user); strncpy(ip,strtok(NULL,"@"),BUF_SIZE); //printf("before connections\n"); fts.sockfd=sockfd=connectToServer(ip); fts.mode=FTS_MODE_ASCII; //printf("sock: %d\n",sockfd); //printf("user: %s\n",user); write(sockfd,user,strlen(user)); read(sockfd,&index,sizeof(index)); //printf("%d\n",index); if(index==-1) { puts("user not found"); exit(0); } puts("connected successfully"); while(1) { printf("%s",prompt); fflush(stdout); fgets(command,BUF_SIZE,stdin); while(command[0]=='\0' || command[0]==' ' || command[0]=='\n') fgets(command,BUF_SIZE,stdin); if(command[strlen(command)-1]=='\n') command[strlen(command)-1]='\0'; //printf("cmd: %s\n",command); writeToLogFile(command,&lg); fillCommandObject(command,&cmd); index=getCommandIndex(&cmd,(struct CMD_MAP *)&cmd_map); if(index < 0) { puts("Command not found"); continue; } cmd_map[index].handler(&cmd,&fts); destroyCommandObject (&cmd); } return (0); }