int main(int argc, char **argv) {
struct cmd_args args;
newt_config config;
int ret;
/* register signal handler */
init_signal_handler();
// parse command-line arguments
parse_opt(argc, argv, &args);
if(args.config_path == NULL) {
perror("failed to load configuration file");
exit(1);
}
ret = load_config(args.config_path, &config);
if(ret == RET_ERROR) {
perror("failed to load configuration file");
exit(1);
}
if(daemon_initialize() == RET_ERROR) {
exit(1);
}
if(daemon_start(config) == RET_ERROR) {
exit(1);
}
return 0;
}
int main(void) {
start_threads();
init_signal_handler();
sigprocmask(SIG_BLOCK, &mask, &oldmask);
while(ts_alive){
sigsuspend(&oldmask); // wait here until the program is killed
}
sigprocmask(SIG_UNBLOCK, &mask, &oldmask);
/*SIGINT caught, ending program*/
join_threads();
return 0;
}
int main(int argc, char ** argv)
{
init_signal_handler();
atc_init();
init_UI();
init_time();
create_plane();
state.airports_num = get_airports(state.airports);
while(1){
update_state();
draw_UI();
input(wgetch(ui.cmd_log));
}
atc_deinit();
dispose_UI();
return 0;
}
int main(int argc, char **argv)
{
openlog(argv[0], 0, LOG_DAEMON);
setlogmask(~LOG_MASK(LOG_DEBUG));
syslog(LOG_INFO, "--- separator ---\n");
tpm_log = my_log;
info("starting TPM Emulator daemon (1.2.%d.%d-%d)",
VERSION_MAJOR, VERSION_MINOR, VERSION_BUILD);
parse_options(argc, argv);
/* switch uid/gid if required */
switch_uid_gid();
/* init signal handlers */
init_signal_handler();
/* unless requested otherwiese, fork and daemonize process */
if (!opt_foreground) daemonize();
/* start main processing loop */
main_loop();
info("stopping TPM Emulator daemon");
closelog();
return EXIT_SUCCESS;
}
int main(int argc, char** argv) {
Timer* logTimer = new Timer();
QApplication app(argc, argv);
Logger logger("Main");
Logger::initialize(Logger::Level::TRACE,true, true, logTimer);
logger.trace("Logger initialized.");
PropertyReader* propReader;
Properties* settings;
if (argc > 1) {
propReader = new PropertyReader(argv[1]);
} else {
propReader = new PropertyReader("../src/settings/settings.txt");
}
// Set logging level
settings = propReader->load();
std::string loggingLevel = settings->getProperty("LOGGING_LEVEL");
if (loggingLevel == "OFF") {
Logger::setLoggingLevel(Logger::Level::OFF);
} else if (loggingLevel == "TRACE") {
Logger::setLoggingLevel(Logger::Level::TRACE);
} else if (loggingLevel == "INFO") {
Logger::setLoggingLevel(Logger::Level::INFO);
} else if (loggingLevel == "DEBUG") {
Logger::setLoggingLevel(Logger::Level::DEBUG);
} else if (loggingLevel == "WARN") {
Logger::setLoggingLevel(Logger::Level::WARN);
} else if (loggingLevel == "ERROR") {
Logger::setLoggingLevel(Logger::Level::ERROR);
}
// Set default HSV Filter values
if (!settings->getProperty("LOW_HUE").empty()) {
HSVFilter::defaultLowH = std::stoi(settings->getProperty("LOW_HUE"));
}
if (!settings->getProperty("HIGH_HUE").empty()) {
HSVFilter::defaultHighH = std::stoi(settings->getProperty("HIGH_HUE"));
}
if (!settings->getProperty("LOW_SATURATION").empty()) {
HSVFilter::defaultLowS = std::stoi(settings->getProperty("LOW_SATURATION"));
}
if (!settings->getProperty("HIGH_SATURATION").empty()) {
HSVFilter::defaultHighS = std::stoi(settings->getProperty("HIGH_SATURATION"));
}
if (!settings->getProperty("LOW_VALUE").empty()) {
HSVFilter::defaultLowV = std::stoi(settings->getProperty("LOW_VALUE"));
}
if (!settings->getProperty("HIGH_VALUE").empty()) {
HSVFilter::defaultHighV = std::stoi(settings->getProperty("HIGH_VALUE"));
}
std::string mode = settings->getProperty("MODE");
if (mode == "HSVTEST") {
VideoTesting vt(0); //camera id or file name
vt.run(1); //0 = video; 1 = webcam; 2 = image
} else {
init_signal_handler();
SubZeroFactory* subZeroFactory = new SubZeroFactory(settings);
Stage* mainStage = new Stage(NULL, subZeroFactory);
mainStage->setViewContent(mode);
mainStage->initialize();
delete propReader;
}
return app.exec();
}
// non realtime context
int RackModule::moduleInit(void)
{
int64_t offset;
int ret;
#ifdef __XENO__
// disable memory swapping for this program
mlockall(MCL_CURRENT | MCL_FUTURE);
#endif
// init signal handler
ret = init_signal_handler(this);
if (ret)
{
goto exit_error;
}
// create command mailbox
ret = createCmdMbx();
if (ret)
{
GDOS_ERROR("Can't create command mailbox\n");
goto exit_error;
}
moduleInitBits.setBit(INIT_BIT_CMDMBX_CREATED);
GDOS_DBG_INFO("Command mailbox created\n");
// create gdos --> Messages are transmitted to GUI now
gdos = new GdosMailbox(&cmdMbx, gdosLevel);
if (!gdos)
{
ret = -ENOMEM;
GDOS_ERROR("Can't create gdos, code = %d\n", ret);
goto exit_error;
}
moduleInitBits.setBit(INIT_BIT_GDOS_CREATED);
GDOS_PRINT("Init\n");
// init rack time
ret = rackTime.init(cmdMbx.getFd());
if (ret)
{
GDOS_ERROR("Can't init rack time, code = %d\n", ret);
goto exit_error;
}
offset = rackTime.getOffset();
if (offset)
GDOS_DBG_INFO("Using global time, offset: %.2f ms\n", (double)offset / 1000000);
else
GDOS_DBG_INFO("Using local time\n");
// init random generation
srand((unsigned int)rackTime.get());
// create command task
snprintf(cmdTaskName, sizeof(cmdTaskName), "%.28s%uC", classname, (unsigned int)inst);
ret = cmdTask.create(cmdTaskName, 0, cmdTaskPrio,
RACK_TASK_FPU | RACK_TASK_JOINABLE | RACK_TASK_CPU(cpu));
if (ret)
{
GDOS_ERROR("Can't init command task, code = %d\n", ret);
goto exit_error;
}
moduleInitBits.setBit(INIT_BIT_CMDTSK_CREATED);
// create data task
snprintf(dataTaskName, sizeof(dataTaskName), "%.28s%uD", classname, (unsigned int)inst);
ret = dataTask.create(dataTaskName, 0, dataTaskPrio,
RACK_TASK_FPU | RACK_TASK_JOINABLE | RACK_TASK_CPU(cpu));
if (ret)
{
GDOS_ERROR("Can't init data task, code = %d\n", ret);
goto exit_error;
}
moduleInitBits.setBit(INIT_BIT_DATATSK_CREATED);
// fill rackParameterMsg
ret = parseArgTable(module_argTab, NULL);
ret += parseArgTable(arg_table, NULL);
ret += 1;
paramMsg = (rack_param_msg*)malloc(sizeof(rack_param_msg) + ret * sizeof(rack_param));
if (!paramMsg)
{
GDOS_ERROR("Can't allocate memory for paramMsg\n");
goto exit_error;
}
moduleInitBits.setBit(INIT_BIT_MALLOC_PARAM_MSG);
strncpy(paramMsg->parameter[0].name, "name", RACK_PARAM_MAX_STRING_LEN);
paramMsg->parameter[0].type = RACK_PARAM_STRING;
strncpy(paramMsg->parameter[0].valueString, classname, RACK_PARAM_MAX_STRING_LEN);
paramMsg->parameterNum = 1;
parseArgTable(module_argTab, paramMsg);
parseArgTable(arg_table, paramMsg);
return 0;
exit_error:
GDOS_ERROR("+++++++++++++++++++++++++++++++++++\n");
GDOS_ERROR("+ Error while initializing module +\n");
GDOS_ERROR("+++++++++++++++++++++++++++++++++++\n");
// !!! call local cleanup function !!!
RackModule::moduleCleanup();
return ret;
}
