void
main_init(int argc, char* argv[])
{
char** ptr;
MyString job_queue_name;
int argc_count = 1;
for(ptr = argv + 1, argc_count = 1; argc_count<argc && *ptr; ptr++,argc_count++)
{
if(ptr[0][0] != '-')
{
usage(argv[0]);
}
switch(ptr[0][1])
{
case 'n':
if (Name) {
free(Name);
}
Name = build_valid_daemon_name( *(++ptr) );
break;
default:
usage(argv[0]);
}
}
// Tell Attrlist to publish the server time
AttrList_setPublishServerTime( true );
// Initialize DaemonCore's use of ProcFamily. We do this so that we
// launch a ProcD if necessary so that any Starters that we launch
// for Local Universe jobs can share a single ProcD, instead of
// each creating their own
daemonCore->Proc_Family_Init();
#if defined(HAVE_DLOPEN)
ClassAdLogPluginManager::Load();
ScheddPluginManager::Load();
ScheddPluginManager::EarlyInitialize();
ClassAdLogPluginManager::EarlyInitialize();
#endif
/* schedd doesn't care about other daemons. only that it has the ability
* to run jobs. so the following code is for now not needed.
// ZKM HACK TO MAKE SURE SCHEDD HAS USER CREDENTIALS
//
// if we are using the credd and credmon, we need to init them before
// doing anything!
char* p = param("SEC_CREDENTIAL_DIRECTORY");
if(p) {
free(p);
dprintf(D_ALWAYS, "SCHEDD: INITIALIZING USER CREDS\n");
Daemon *my_credd;
// we will abort if we can't locate the credd, so let's try a
// few times. locate() caches the result so we have to destroy
// the object and make a new one each time.
int retries = 20;
bool success = false;
do {
// allocate a credd
my_credd = new Daemon(DT_CREDD);
if(my_credd) {
// call locate
bool loc_rc = my_credd->locate();
if(loc_rc) {
// get a connected relisock
CondorError errstack;
ReliSock* r = (ReliSock*)my_credd->startCommand(
CREDD_REFRESH_ALL, Stream::reli_sock, 20, &errstack);
if ( r ) {
// ask the credd to get us some fresh user creds
ClassAd ad;
putClassAd(r, ad);
r->end_of_message();
r->decode();
getClassAd(r, ad);
r->end_of_message();
dprintf(D_SECURITY | D_FULLDEBUG, "SCHEDD: received ad from CREDD:\n");
dPrintAd(D_SECURITY | D_FULLDEBUG, ad);
MyString result;
ad.LookupString("Result", result);
if(result == "success") {
success = true;
} else {
dprintf(D_FULLDEBUG, "SCHEDD: warning, creddmon returned failure.\n");
}
// clean up.
delete r;
} else {
dprintf(D_FULLDEBUG, "SCHEDD: warning, startCommand failed, %s\n", errstack.getFullText(true).c_str());
}
} else {
dprintf(D_FULLDEBUG, "SCHEDD: warning, locate failed.\n");
}
// clean up.
delete my_credd;
} else {
dprintf(D_FULLDEBUG, "SCHEDD: warning, new Daemon(DT_CREDD) failed.\n");
}
// if something went wrong, sleep and retry (finit number of times)
if(!success) {
dprintf(D_FULLDEBUG, "SCHEDD: sleeping and trying again %i times.\n", retries);
sleep(1);
retries--;
}
} while ((retries > 0) && (success == false));
// except if fail
if (!success) {
EXCEPT("FAILED TO INITIALIZE USER CREDS (locate failed)");
}
}
// END ZKM HACK
*/
#ifndef WIN32
// if using the SEC_CREDENTIAL_DIRECTORY, confirm we are "up-to-date".
// at the moment, we take an "all-or-nothing" approach. ultimately, this
// should be per-user, and the SchedD should start normally and run jobs
// for users who DO have valid credentials, and simply holding on to jobs
// in idle state for users who do NOT have valid credentials.
//
char* p = param("SEC_CREDENTIAL_DIRECTORY");
if(p) {
free(p);
bool success = false;
int retries = 60;
do {
// look for existence of file that says everything is up-to-date.
success = credmon_poll(NULL, false, false);
if(!success) {
dprintf(D_ALWAYS, "SCHEDD: User credentials not up-to-date. Start-up delayed. Waiting 10 seconds and trying %i more times.\n", retries);
sleep(10);
retries--;
}
} while ((!success) && (retries > 0));
// we tried, we give up.
if(!success) {
EXCEPT("User credentials unavailable after 10 minutes");
}
}
// User creds good to go, let's start this thing up!
#endif // WIN32
// Initialize all the modules
scheduler.Init();
scheduler.Register();
// Initialize the job queue
char *job_queue_param_name = param("JOB_QUEUE_LOG");
if (job_queue_param_name == NULL) {
// the default place for the job_queue.log is in spool
job_queue_name.formatstr( "%s/job_queue.log", Spool);
} else {
job_queue_name = job_queue_param_name; // convert char * to MyString
free(job_queue_param_name);
}
// Make a backup of the job queue?
if ( param_boolean_crufty("SCHEDD_BACKUP_SPOOL", false) ) {
MyString hostname;
hostname = get_local_hostname();
MyString job_queue_backup;
job_queue_backup.formatstr( "%s/job_queue.bak.%s.%ld",
Spool, hostname.Value(), (long)time(NULL) );
if ( copy_file( job_queue_name.Value(), job_queue_backup.Value() ) ) {
dprintf( D_ALWAYS, "Failed to backup spool to '%s'\n",
job_queue_backup.Value() );
} else {
dprintf( D_FULLDEBUG, "Spool backed up to '%s'\n",
job_queue_backup.Value() );
}
}
int max_historical_logs = param_integer( "MAX_JOB_QUEUE_LOG_ROTATIONS", DEFAULT_MAX_JOB_QUEUE_LOG_ROTATIONS );
InitJobQueue(job_queue_name.Value(),max_historical_logs);
PostInitJobQueue();
// Initialize the dedicated scheduler stuff
dedicated_scheduler.initialize();
// Do a timeout now at startup to get the ball rolling...
scheduler.timeout();
#if defined(HAVE_DLOPEN)
ScheddPluginManager::Initialize();
ClassAdLogPluginManager::Initialize();
#endif
daemonCore->InstallAuditingCallback( AuditLogNewConnection );
}
void mcu_conf()
{
//kruciální řádky - odpojit jtag; nechat jenom swd - sou na nem piny pro SPI1
//premapovat SPI1 na PB3;4;5
RCC->APB2ENR |= RCC_APB2ENR_AFIOEN;
AFIO->MAPR |= AFIO_MAPR_SPI1_REMAP;
AFIO->MAPR |= 0b010 << 24;
#if 1
//setup SPI pins and spi itself
const static SPIConfig spi_conf =
{ NULL, CS_PORT, CS_PIN, SPI_BR };
spiStart(&SPID1, &spi_conf);
palSetPadMode(spi_conf.ssport, spi_conf.sspad, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(SPI_SCK_PORT, SPI_SCK_PIN, SPI_SCK_MODE);
palSetPadMode(SPI_MISO_PORT, SPI_MISO_PIN, SPI_MISO_MODE);
palSetPadMode(SPI_MOSI_PORT, SPI_MOSI_PIN, SPI_MOSI_MODE);
//SETUP I2C pins
palSetPadMode(I2C_SDA_PORT, I2C_SDA_PIN2, PAL_MODE_INPUT);
palSetPadMode(I2C_SCL_PORT, I2C_SCL_PIN2, PAL_MODE_INPUT);
palSetPadMode(I2C_SDA_PORT, I2C_SDA_PIN,
PAL_MODE_STM32_ALTERNATE_OPENDRAIN);
palSetPadMode(I2C_SCL_PORT, I2C_SCL_PIN,
PAL_MODE_STM32_ALTERNATE_OPENDRAIN);
AFIO->MAPR |= AFIO_MAPR_I2C1_REMAP;
#else
palSetPadMode(config.ssport, config.sspad, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(SPI_SCK_PORT, SPI_SCK_PIN, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(SPI_MISO_PORT, SPI_MISO_PIN, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(SPI_MOSI_PORT, SPI_MOSI_PIN, PAL_MODE_OUTPUT_PUSHPULL);
palClearPad(config.ssport, config.sspad);
palClearPad(SPI_SCK_PORT, SPI_SCK_PIN);
palClearPad(SPI_MISO_PORT, SPI_MISO_PIN);
palClearPad(SPI_MOSI_PORT, SPI_MOSI_PIN);
palSetPad(config.ssport, config.sspad);
palClearPad(config.ssport, config.sspad);
palClearPad(SPI_SCK_PORT, SPI_SCK_PIN);
palClearPad(SPI_MISO_PORT, SPI_MISO_PIN);
palClearPad(SPI_MOSI_PORT, SPI_MOSI_PIN);
palSetPad(SPI_SCK_PORT, SPI_SCK_PIN);
palClearPad(config.ssport, config.sspad);
palClearPad(SPI_SCK_PORT, SPI_SCK_PIN);
palClearPad(SPI_MISO_PORT, SPI_MISO_PIN);
palClearPad(SPI_MOSI_PORT, SPI_MOSI_PIN);
palSetPad(SPI_MISO_PORT, SPI_MISO_PIN);
palClearPad(config.ssport, config.sspad);
palClearPad(SPI_SCK_PORT, SPI_SCK_PIN);
palClearPad(SPI_MISO_PORT, SPI_MISO_PIN);
palClearPad(SPI_MOSI_PORT, SPI_MOSI_PIN);
palSetPad(SPI_MOSI_PORT, SPI_MOSI_PIN);
palClearPad(config.ssport, config.sspad);
palClearPad(SPI_SCK_PORT, SPI_SCK_PIN);
palClearPad(SPI_MISO_PORT, SPI_MISO_PIN);
palClearPad(SPI_MOSI_PORT, SPI_MOSI_PIN);
//
#endif
palSetPadMode(TEST_LED_PORT, TEST_LED_PIN, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(TEST_LED_PORT2, TEST_LED_PIN2, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(TEST_LED_PORT3, TEST_LED_PIN3, PAL_MODE_OUTPUT_PUSHPULL);
palSetPad(TEST_LED_PORT, TEST_LED_PIN);
palSetPad(TEST_LED_PORT2, TEST_LED_PIN2);
palClearPad(TEST_LED_PORT3, TEST_LED_PIN3);
s1.Register();
}
void
main_init(int argc, char* argv[])
{
char** ptr;
MyString job_queue_name;
int argc_count = 1;
for(ptr = argv + 1, argc_count = 1; argc_count<argc && *ptr; ptr++,argc_count++)
{
if(ptr[0][0] != '-')
{
usage(argv[0]);
}
switch(ptr[0][1])
{
case 'n':
Name = build_valid_daemon_name( *(++ptr) );
break;
default:
usage(argv[0]);
}
}
// Tell Attrlist to publish the server time
AttrList_setPublishServerTime( true );
// Initialize DaemonCore's use of ProcFamily. We do this so that we
// launch a ProcD if necessary so that any Starters that we launch
// for Local Universe jobs can share a single ProcD, instead of
// each creating their own
daemonCore->Proc_Family_Init();
#if defined(WANT_CONTRIB) && defined(WITH_MANAGEMENT)
#if defined(HAVE_DLOPEN)
// Intialization of the plugin manager, i.e. loading all
// plugins, should be performed before the job queue log is
// read so plugins have a chance to learn about all jobs
// already in the queue
ClassAdLogPluginManager::Load();
// Load all ScheddPlugins. In reality this doesn't do much
// since initializing any plugin manager loads plugins for all
// plugin manager.
ScheddPluginManager::Load();
// Tell all ScheddPlugins to initialze themselves
ScheddPluginManager::EarlyInitialize();
// Tell all plugins to initialize themselves
ClassAdLogPluginManager::EarlyInitialize();
#endif
#endif
// Initialize all the modules
scheduler.Init();
scheduler.Register();
// Initialize the job queue
char *job_queue_param_name = param("JOB_QUEUE_LOG");
if (job_queue_param_name == NULL) {
// the default place for the job_queue.log is in spool
job_queue_name.sprintf( "%s/job_queue.log", Spool);
} else {
job_queue_name = job_queue_param_name; // convert char * to MyString
free(job_queue_param_name);
}
// Make a backup of the job queue?
if ( param_boolean_crufty("SCHEDD_BACKUP_SPOOL", false) ) {
MyString hostname;
UtcTime now(true);
hostname = get_local_hostname();
MyString job_queue_backup;
job_queue_backup.sprintf( "%s/job_queue.bak.%s.%ld",
Spool, hostname.Value(), now.seconds() );
if ( copy_file( job_queue_name.Value(), job_queue_backup.Value() ) ) {
dprintf( D_ALWAYS, "Failed to backup spool to '%s'\n",
job_queue_backup.Value() );
} else {
dprintf( D_FULLDEBUG, "Spool backed up to '%s'\n",
job_queue_backup.Value() );
}
}
int max_historical_logs = param_integer( "MAX_JOB_QUEUE_LOG_ROTATIONS", DEFAULT_MAX_JOB_QUEUE_LOG_ROTATIONS );
InitJobQueue(job_queue_name.Value(),max_historical_logs);
mark_jobs_idle();
// The below must happen _after_ InitJobQueue is called.
if ( scheduler.autocluster.config() ) {
// clear out auto cluster id attributes
WalkJobQueue( (int(*)(ClassAd *))clear_autocluster_id );
}
//
// Update the SchedDInterval attributes in jobs if they
// have it defined. This will be for JobDeferral and
// CronTab jobs
//
WalkJobQueue( (int(*)(ClassAd *))::updateSchedDInterval );
// Initialize the dedicated scheduler stuff
dedicated_scheduler.initialize();
// Do a timeout now at startup to get the ball rolling...
scheduler.timeout();
#if defined(WANT_CONTRIB) && defined(WITH_MANAGEMENT)
#if defined(HAVE_DLOPEN)
// Tell all ScheddPlugins to initialze themselves
ScheddPluginManager::Initialize();
// Tell all plugins to initialize themselves
ClassAdLogPluginManager::Initialize();
#endif
#endif
}
int main(void)
{
halInit();
chSysInit();
//kruciální řádky - odpojit jtag; nechat jenom swd - sou na nem piny pro SPI1
//premapovat SPI1 na PB3;4;5
RCC->APB2ENR |= RCC_APB2ENR_AFIOEN;
AFIO->MAPR |= AFIO_MAPR_SPI1_REMAP;
AFIO->MAPR |= 0b010 << 24;
#if 1
spiStart(&SPID1, &config);
palSetPadMode(config.ssport, config.sspad, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(SPI_SCK_PORT, SPI_SCK_PIN, SPI_SCK_MODE);
palSetPadMode(SPI_MISO_PORT, SPI_MISO_PIN, SPI_MISO_MODE);
palSetPadMode(SPI_MOSI_PORT, SPI_MOSI_PIN, SPI_MOSI_MODE);
#else
palSetPadMode(config.ssport, config.sspad, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(SPI_SCK_PORT, SPI_SCK_PIN, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(SPI_MISO_PORT, SPI_MISO_PIN, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(SPI_MOSI_PORT, SPI_MOSI_PIN, PAL_MODE_OUTPUT_PUSHPULL);
palClearPad(config.ssport, config.sspad);
palClearPad(SPI_SCK_PORT, SPI_SCK_PIN);
palClearPad(SPI_MISO_PORT, SPI_MISO_PIN);
palClearPad(SPI_MOSI_PORT, SPI_MOSI_PIN);
palSetPad(config.ssport, config.sspad);
palClearPad(config.ssport, config.sspad);
palClearPad(SPI_SCK_PORT, SPI_SCK_PIN);
palClearPad(SPI_MISO_PORT, SPI_MISO_PIN);
palClearPad(SPI_MOSI_PORT, SPI_MOSI_PIN);
palSetPad(SPI_SCK_PORT, SPI_SCK_PIN);
palClearPad(config.ssport, config.sspad);
palClearPad(SPI_SCK_PORT, SPI_SCK_PIN);
palClearPad(SPI_MISO_PORT, SPI_MISO_PIN);
palClearPad(SPI_MOSI_PORT, SPI_MOSI_PIN);
palSetPad(SPI_MISO_PORT, SPI_MISO_PIN);
palClearPad(config.ssport, config.sspad);
palClearPad(SPI_SCK_PORT, SPI_SCK_PIN);
palClearPad(SPI_MISO_PORT, SPI_MISO_PIN);
palClearPad(SPI_MOSI_PORT, SPI_MOSI_PIN);
palSetPad(SPI_MOSI_PORT, SPI_MOSI_PIN);
palClearPad(config.ssport, config.sspad);
palClearPad(SPI_SCK_PORT, SPI_SCK_PIN);
palClearPad(SPI_MISO_PORT, SPI_MISO_PIN);
palClearPad(SPI_MOSI_PORT, SPI_MOSI_PIN);
//
#endif
palSetPadMode(TEST_LED_PORT, TEST_LED_PIN, PAL_MODE_INPUT);
palSetPadMode(TEST_LED_PORT2, TEST_LED_PIN2, PAL_MODE_OUTPUT_PUSHPULL);
palClearPad(TEST_LED_PORT, TEST_LED_PIN);
palClearPad(TEST_LED_PORT2, TEST_LED_PIN2);
s1.Register();
palSetPadMode(GPIOA, 2, PAL_MODE_STM32_ALTERNATE_PUSHPULL);
// palSetPad(GPIOA,2);
//DBGMCU->CR |= DBGMCU_CR_DBG_TIM2_STOP;
pwmStart(&PWMD2, &pwmcfg);
pwmEnableChannel(&PWMD2,2,PWM_PERCENTAGE_TO_WIDTH(&PWMD2,5000));
//setup watchdog
DBGMCU->CR |= DBGMCU_CR_DBG_IWDG_STOP;
IWDG->KR = 0x5555;
IWDG->PR = 6;
IWDG->RLR = 0xFFF;
IWDG->KR = 0xCCCC;
#if 1
ser.Init();
rf.begin();
rf.enableAckPayload();
rf.enableDynamicPayloads();
for (int i = 0; i < 5; i++)
rf.openReadingPipe(i, pipe + i);
rf.startListening();
#endif
while (TRUE)
{
Scheduler::Play();
ser.Loop();
sysTime = chTimeNow();
}
return 1;
}
