Player::Player(std::string name)
: Entity()
, ENTITY_PROPERTY_DECL(health, 100)
, ENTITY_PROPERTY_DECL(sanity, 100)
, ENTITY_PROPERTY_DECL(focus, 1.f)
, ENTITY_PROPERTY_DECL(energy, 100)
, ENTITY_PROPERTY_DECL(depression, 0)
{
m_name = name;
m_type = entityType::PLAYER;
auto task = new PlayerTask(this, "Get a Task", "Find something to do.");
addTask(task);
}
CBotAttackPointSched :: CBotAttackPointSched ( Vector vPoint, int iRadius, int iArea, bool bHasRoute, Vector vRoute, bool bNest, edict_t *pLastEnemySentry )
{
int iDangerWpt = -1;
if ( pLastEnemySentry != NULL )
iDangerWpt = CWaypointLocations::NearestWaypoint(CBotGlobals::entityOrigin(pLastEnemySentry),200.0f,-1,true,true);
// First find random route
if ( bHasRoute )
{
CFindPathTask *toRoute = new CFindPathTask(vRoute);
addTask(toRoute); // first
toRoute->setDangerPoint(iDangerWpt);
if ( bNest )
addTask(new CBotNest());
}
CFindPathTask *toPoint = new CFindPathTask(vPoint);
addTask(toPoint); // second / first
toPoint->setDangerPoint(iDangerWpt);
addTask(new CBotTF2AttackPoint(iArea,vPoint,iRadius)); // third / second
}
std::shared_ptr< TimerTask > ExpiryTimerImpl::post(DelayInMillis delay, Callback cb)
{
if (delay < 0LL)
{
throw InvalidParameterException{ "delay can't be negative." };
}
if (!cb)
{
throw InvalidParameterException{ "callback is empty." };
}
return addTask(convertToTime(Milliseconds{ delay }), std::move(cb), generateId());
}
void module_video_camera::worker()
{
CvCapture* capture = cvCreateCameraCapture(0);//cvCaptureFromCAM(0);
if(!capture || currentTask() != INITIALIZE_CAPTURE){
message = "module||ERROR! Cannot initialize camera!!";
addTask(CLEANUP_CAPTURE);
return;
}
else message = "";
IplImage *frame;
Tasks task = INITIALIZE_CAPTURE;
while( task != TERMINATE_CAPTURE ){
// Fetch a frame if its asked for / couldnt fetch a previous frame / is the first time.
if( task == FETCH_FRAME || task == IGNORE_FRAME || task == INITIALIZE_CAPTURE ){
frame = cvQueryFrame(capture);
if(frame){
if( !m_bufferReady )
initializeBuffers(frame->width,frame->height, frame->depth, frame->nChannels);
cvConvertImage(frame,m_buffer[nextPage()], CV_CVTIMG_SWAP_RB);
addTask(CONSUME_FRAME);
}
else addTask(IGNORE_FRAME);
}
usleep(10);
task = currentTask();
}
//Cleanup
cvReleaseCapture(&capture);
freeBuffers();
addTask(CLEANUP_CAPTURE);
}
CBotTauntSchedule :: CBotTauntSchedule ( edict_t *pPlayer, float fYaw )
{
QAngle angles = QAngle(0,fYaw,0);
Vector forward;
Vector vOrigin;
Vector vGoto;
const float fTauntDist = 40.0f;
m_pPlayer = pPlayer;
m_fYaw = 180 - fYaw;
AngleVectors(angles,&forward);
forward = forward/forward.Length();
vOrigin = CBotGlobals::entityOrigin(pPlayer);
vGoto = vOrigin + (forward*fTauntDist);
CBotGlobals::fixFloatAngle(&m_fYaw);
addTask(new CFindPathTask(vOrigin));
addTask(new CMoveToTask(vOrigin));
addTask(new CTF2_TauntTask(vOrigin,vGoto,fTauntDist));
}
CBotTFEngiUpgrade :: CBotTFEngiUpgrade ( CBot *pBot, edict_t *pBuilding )
{
CFindPathTask *pathtask = new CFindPathTask(pBuilding);
addTask(pathtask);
pathtask->completeInRangeFromEdict();
pathtask->failIfTaskEdictDead();
pathtask->setRange(150.0f);
if ( !CTeamFortress2Mod::isSentryGun(pBuilding) )
{
pathtask->setInterruptFunction(new CBotTF2EngineerInterrupt(pBot));
CBotTF2UpgradeBuilding *upgbuilding = new CBotTF2UpgradeBuilding(pBuilding);
addTask(upgbuilding);
upgbuilding->setInterruptFunction(new CBotTF2EngineerInterrupt(pBot));
}
else
{
addTask(new CBotTF2UpgradeBuilding(pBuilding));
}
}
//Called from fileLoader
void Engine::loadDocumentAsync(const File & file){
clearTasks();
taskName = "Loading File";
ProgressTask * clearTask = addTask("clearing");
ProgressTask * parseTask = addTask("parsing");
ProgressTask * loadTask = addTask("loading");
clearTask->start();
clear();
clearTask->end();
// {
// MessageManagerLock ml;
// }
ScopedPointer<InputStream> is( file.createInputStream());
loadingStartTime = Time::currentTimeMillis();
setFile(file);
file.getParentDirectory().setAsCurrentWorkingDirectory();
{
parseTask->start();
jsonData = JSON::parse(*is);
parseTask->end();
loadTask->start();
loadJSONData(jsonData,loadTask);
loadTask->end();
}// deletes data before launching audio, (data not needed after loaded)
jsonData = var();
}
void ShellCommand::execute()
{
d->m_lastExecSuccess = false;
d->m_lastExecExitCode = -1;
if (d->m_jobs.empty())
return;
// For some reason QtConcurrent::run() only works on this
QFuture<void> task = QtConcurrent::run(&ShellCommand::run, this);
d->m_watcher.setFuture(task);
connect(&d->m_watcher, &QFutureWatcher<void>::canceled, this, &ShellCommand::cancel);
addTask(task);
}
void MainWindow::on_actionNewProject_triggered()
{
bool ok;
QString name = QInputDialog::getText(this,
tr("New project"),
tr("Enter the name of the new project:"),
QLineEdit::Normal,
QString(),
&ok);
if (!ok || name.isEmpty()) return;
ui->selectProject->addItem(name);
addTask(name, "", NULL, NULL);
}
void IOutputParser::appendOutputParser(IOutputParser *parser)
{
if (!parser)
return;
if (m_parser) {
m_parser->appendOutputParser(parser);
return;
}
m_parser = parser;
connect(parser, SIGNAL(addOutput(QString,ProjectExplorer::BuildStep::OutputFormat)),
this, SLOT(outputAdded(QString,ProjectExplorer::BuildStep::OutputFormat)), Qt::DirectConnection);
connect(parser, SIGNAL(addTask(ProjectExplorer::Task)),
this, SLOT(taskAdded(ProjectExplorer::Task)), Qt::DirectConnection);
}
GraphSize ClassGraph::updateGraph(const ModelData &modelData, bool geneRepositioning)
{
if(geneRepositioning)
{
stopAndWaitForCompletion();
addTask(ClassGraphBackgroundItem(&modelData, &mGraphOptions));
}
else
{
updateNodeSizes();
updateConnections(modelData);
mGraphListener->doneRepositioning();
}
return(getGraphSize());
}
void Executer::execute(Task& task){
int oldState = atomic_load(&m_state);
if(oldState >= EXECUTER_STATE_SHUTTINGDOWN){
// start the thread again
start();
}
if(atomic_load(&m_state) != EXECUTER_STATE_STARTED){
cerr << "Can't start the Executor!" << endl;
return;
}
addTask(task);
}
int TexturePreLoad::preLoadSctionSelectorTexture()
{
long numStart = mLoadTextureCalledNum;
// CurtainLayer
{
preLoadCurtainTexture(1,false); // 只用s1的
preLoadHDCurtainFrameLayerTexture(1);
}
// SectionItem
{
addTask(resMgr->getSharedFilePath("sectionItem_lock_bg.png"));
// 总共是3分，0,1,2,3
for (int i=0;i<4;i++)
{
addTask(resMgr->getSharedFilePath(SpriteHelper::splicingNum_String("sectionItem_%d_bg.png",i)));
}
}
// bug 修复 2013-4-10
return mLoadTextureCalledNum - numStart;
//return mLoadTextureCalledNum + numStart;
}
void MerUploadAndInstallRpmStep::run(QFutureInterface<bool> &fi)
{
const QString packageFile = m_packagingStep->packagesFilePath().first();
if(!packageFile.endsWith(QLatin1String(".rpm"))){
const QString message((tr("No package to deploy found in %1")).arg(packageFile));
emit addOutput(message, ErrorMessageOutput);
emit addTask(Task(Task::Error, message, FileName(), -1,
Core::Id(Constants::TASK_CATEGORY_BUILDSYSTEM)));
fi.reportResult(false);
emit finished();
return;
}
m_deployService->setPackageFilePath(packageFile);
AbstractRemoteLinuxDeployStep::run(fi);
}
void MainWindow::on_actionNewTask_triggered()
{
QTreeWidgetItem* parentWidget = selectedTreeWidgetItem();
Task* parentTask = selectedTask();
bool ok;
QString name = QInputDialog::getText(this,
tr("New sub task"),
tr("Enter the name of the new sub task:"),
QLineEdit::Normal,
QString(),
&ok);
if (!ok || name.isEmpty()) return;
addTask(name, "", parentWidget, parentTask);
}
/*****************************************************************************
******************************************************************************
Function Name : add_sample_task
Date : Feb 1999
Remarks:
adds the task to the task menu
******************************************************************************
Paramters: (i/o = input/output)
none
*****************************************************************************/
void
add_zero_task( void )
{
int i, j;
static int firsttime = TRUE;
if (firsttime) {
firsttime = FALSE;
target = (SL_DJstate *)my_calloc(n_dofs+1,sizeof(SL_DJstate), MY_STOP);
}
addTask("Zero position Task", init_zero_task,
run_zero_task, change_zero_task);
}
CTaskManage1::CTaskManage1(QWidget *parent)
: QDialog(parent)
{
setupUi(this);
connect(pbNewTask, SIGNAL(clicked()),this, SLOT(addTask()));
//connect(pbNewXaclTask,SIGNAL(clicked()),this, SLOT(addXaclTask()));
connect(pbDeleteTask, SIGNAL(clicked()),this, SLOT(deleteTask()));
connect(pbQueryTask, SIGNAL(clicked()),this, SLOT(queryTask()));
model=new QSqlTableModel(this);
model->setTable("taskinfo");
model->select();
tvTask->setItemDelegate(new CTaskDelegate(0));
tvTask->setModel(model);
tvTask->setColumnWidth(1,130);
}
void InsertProjectTester::testResourceRequest()
{
Part part;
addCalendar( part );
addResourceGroup( part );
addResource( part );
addTask( part );
addGroupRequest( part );
addResourceRequest( part );
Project &p = part.getProject();
Part part2;
part2.insertProject( p, 0, 0 );
Project &p2 = part2.getProject();
QVERIFY( p2.childNode( 0 )->requests().find( p2.resourceGroupAt( 0 )->resourceAt( 0 ) ) != 0 );
}
void MainWindow::loadFromIcsFile()
{
char* line;
icalcomponent *c;
icalparser *parser = icalparser_new();
FILE* stream = fopen("/home/quentin/Public/test.ics", "r");
icalparser_set_gen_data(parser, stream);
do
{
line = icalparser_get_line(parser, read_stream);
c = icalparser_add_line(parser, line);
if (c != 0)
{
icalcomponent *inner = icalcomponent_get_first_component(c, ICAL_ANY_COMPONENT);
while (inner != NULL)
{
if (icalcomponent_isa(inner) == ICAL_VTODO_COMPONENT)
{
const char* name = icalcomponent_get_summary(inner);
const char* uid = icalcomponent_get_uid(inner);
icalproperty *p = icalcomponent_get_first_property(inner, ICAL_RELATEDTO_PROPERTY);
const char* parent = icalproperty_get_relatedto(p);
addTask(name, uid, parent);
}
if (icalcomponent_isa(inner) == ICAL_VEVENT_COMPONENT)
{
const char* name = icalcomponent_get_summary(inner);
const char* uid = icalcomponent_get_uid(inner);
icalproperty *p = icalcomponent_get_first_property(inner, ICAL_RELATEDTO_PROPERTY);
const char* parent = icalproperty_get_relatedto(p);
p = icalcomponent_get_first_property(inner, ICAL_DTSTART_PROPERTY);
icaltimetype start = icalproperty_get_dtstart(p);
p = icalcomponent_get_first_property(inner, ICAL_DTEND_PROPERTY);
icaltimetype end = icalproperty_get_dtend(p);
Task* task = findTask(parent);
addEvent(task, uid, name, start, end);
}
inner = icalcomponent_get_next_component(c, ICAL_ANY_COMPONENT);
}
}
} while (line != 0);
}
void TaskManager::addTask( bool _canTaskManagerFreeScheduler , bool _canTaskManagerFreeRunnable , TaskManagerScheduler* taskManagerScheduler , Runnable* runnable )
{
TaskManagerMemoryConfigurator* memConf;
if( _canTaskManagerFreeScheduler && _canTaskManagerFreeRunnable )
memConf = memConfFreeSchedulerFreeRunnable;
else
if( _canTaskManagerFreeScheduler && !_canTaskManagerFreeRunnable )
memConf = memConfFreeSchedulerLeaveRunnable;
else
if( !_canTaskManagerFreeScheduler && _canTaskManagerFreeRunnable )
memConf = memConfLeaveSchedulerFreeRunnable;
else
memConf = memConfLeaveSchedulerLeaveRunnable;
addTask( memConf , taskManagerScheduler , runnable );
}
void InsertProjectTester::testExistingRequiredResourceRequest()
{
Part pp(0);
MainDocument part( &pp );
pp.setDocument( &part );
addCalendar( part );
addResourceGroup( part );
Resource *r = addResource( part );
ResourceGroup *g = addResourceGroup( part );
g->setType( ResourceGroup::Type_Material );
QList<Resource*> m; m << addResource( part, g );
m.first()->setType( Resource::Type_Material );
r->setRequiredIds( QStringList() << m.first()->id() );
addTask( part );
addGroupRequest( part );
addResourceRequest( part );
QDomDocument doc = part.saveXML();
Project &p = part.getProject();
Part pp2(0);
MainDocument part2( &pp2 );
pp2.setDocument( &part2 );
part2.insertProject( p, 0, 0 );
Project &p2 = part2.getProject();
ResourceRequest *rr = p2.childNode( 0 )->requests().find( p2.resourceGroupAt( 0 )->resourceAt( 0 ) );
QVERIFY( rr );
QVERIFY( ! rr->requiredResources().isEmpty() );
QCOMPARE( rr->requiredResources().at( 0 ), m.first() );
KoXmlDocument xdoc;
xdoc.setContent( doc.toString() );
part.loadXML( xdoc, 0 );
part2.insertProject( part.getProject(), 0, 0 );
rr = p2.childNode( 0 )->requests().find( p2.resourceGroupAt( 0 )->resourceAt( 0 ) );
QVERIFY( rr );
QVERIFY( ! rr->requiredResources().isEmpty() );
QCOMPARE( rr->requiredResources().at( 0 ), m.first() );
rr = p2.childNode( 1 )->requests().find( p2.resourceGroupAt( 0 )->resourceAt( 0 ) );
QVERIFY( rr );
QVERIFY( ! rr->requiredResources().isEmpty() );
QCOMPARE( rr->requiredResources().at( 0 ), m.first() );
}
void InsertProjectTester::testTask()
{
Part pp(0);
MainDocument part( &pp );
pp.setDocument( &part );
addTask( part );
Project &p = part.getProject();
QVERIFY( p.numChildren() == 1 );
Part pp2(0);
MainDocument part2( &pp2 );
pp2.setDocument( &part2 );
part2.insertProject( p, 0, 0 );
QVERIFY( part2.getProject().numChildren() == 1 );
}
int main(void) {
/*
* Initialize the System Timer, UART, TWI, SPI,
* ADC and the UART menu task for user or software
* interaction. Also enables interrupts!
* Also, the UART will be tied to stdin, stdout and stderr.
* This allows you to use stdio.h utilities like printf()
*/
xyInit();
printf("Initializing Hardware Test...\n");
/*
* Initialize Hardware
*/
xyLed(LED_GREEN, LED_OFF);
xyLed(LED_RED, LED_ON);
motorInit();
orientationInit();
/*
* Register Tasks in the Scheduler. A UART task
* is already registered...
*/
addTask(&ledTask); // Blink LED
/*
* Add commands for the UART menu
*/
addMenuCommand('b', bluetoothString, &bluetoothTest);
addMenuCommand('r', sensorString, &printRaw);
addMenuCommand('t', ramString, &ramTest);
addMenuCommand('v', voltageString, &printVoltage);
printf("Hardware Test Initialized!\n");
/*
* Execute all registered tasks, forever.
*/
for(;;) {
tasks();
}
return 0;
}
static void
doDNS( void * vtask )
{
tr_address addr;
int port = -1;
char * host = NULL;
struct hostent *he;
struct sockaddr_in adr;
struct tr_web_task * task = vtask;
tr_dns_result lookup_result = TR_DNS_UNTESTED;
assert( task->resolved_host == NULL );
if( !tr_urlParse( task->url, -1, NULL, &host, &port, NULL ) )
{
task->port = port;
task->host = host;
/* If 'host' is an IPv4 or IPv6 address in text form, use it as-is.
* Otherwise, see if its resolved name is in our DNS cache */
if( tr_pton( task->host, &addr ) != NULL )
{
task->resolved_host = task->host;
lookup_result = TR_DNS_OK;
}
else
{
if( (he = gethostbyname(host)) ) {
memcpy(&adr.sin_addr, he->h_addr_list[0], he->h_length);
task->resolved_host = strdup(inet_ntoa(adr.sin_addr));
lookup_result = TR_DNS_OK;
}
}
}
if( lookup_result != TR_DNS_UNTESTED )
{
addTask( task );
}
else if( !host || evdns_resolve_ipv4( host, 0, dns_ipv4_done_cb, task ) )
{
dns_ipv4_done_cb( DNS_ERR_UNKNOWN, DNS_IPv4_A, 0, 0, NULL, task );
}
}
int find(char * dirName){
char fileName[1000];
int lineNum=0;
int dirLen=strlen(dirName);
int error;
DIR *dir;
struct dirent entry;
struct dirent *result;
struct stat fstat;
strcpy(fileName,dirName);
fileName[dirLen]='/';
dir = opendir(dirName);
int len;
for (;;) {
fileName[dirLen+1]='\0';
error = readdir_r(dir, &entry, &result);
if (error != 0) {
perror("readdir");
return ;//EXIT_FAILURE;
}
if (result == NULL)
break;
strcat(fileName,result->d_name);
stat(fileName,&fstat);
if(S_ISDIR(fstat.st_mode)){
if((strcmp(".",result->d_name)==0)||(strcmp("..",result->d_name)==0))
continue;
//printf("DIR :%s/%s**\n",dirName, result->d_name);
//find(fileName);
addTask(fileName);
}else{
// len=strlen(result->d_name);
// if(len<2)
// continue;
// if((result->d_name[len-1]!='h')||(result->d_name[len-2]!='.'))
// continue;
// printf("FILE:%s/%s**\n",dirName, result->d_name);
lineNum+=countDefine(fileName);
}
}
closedir(dir);
return lineNum;
}
/*****************************************************************************
******************************************************************************
Function Name : add_gravityComp_task
Date : Feb 1999
Remarks:
adds the task to the task menu
******************************************************************************
Paramters: (i/o = input/output)
none
*****************************************************************************/
void
add_gravityComp_task( void )
{
int i, j;
static int firsttime = TRUE;
if (firsttime) {
firsttime = FALSE;
addTask("Gravity Compensation Task", init_gravityComp_task,
run_gravityComp_task, change_gravityComp_task);
/* add variables to data collection */
addVarToCollect((char *)&(fieldon),"force-field","-",INT,FALSE);
addVarToCollect((char *)&(joint_filt_state[1].thd),"R_SFE_filt_thd","rad/s",DOUBLE,FALSE);
addVarToCollect((char *)&(joint_filt_state[2].thd),"R_SAA_filt_thd","rad/s",DOUBLE,FALSE);
addVarToCollect((char *)&(joint_filt_state[3].thd),"R_HR_filt_thd","rad/s",DOUBLE,FALSE);
addVarToCollect((char *)&(joint_filt_state[4].thd),"R_EB_filt_thd","rad/s",DOUBLE,FALSE);
addVarToCollect((char *)&(joint_filt_state[5].thd),"R_WR_filt_thd","rad/s",DOUBLE,FALSE);
addVarToCollect((char *)&(joint_filt_state[6].thd),"R_WFE_filt_thd","rad/s",DOUBLE,FALSE);
addVarToCollect((char *)&(joint_filt_state[7].thd),"R_WAA_filt_thd","rad/s",DOUBLE,FALSE);
addVarToCollect((char *)&(joint_filt_state[1].thdd),"R_SFE_filt_thdd","rad/s^2",DOUBLE,FALSE);
addVarToCollect((char *)&(joint_filt_state[2].thdd),"R_SAA_filt_thdd","rad/s^2",DOUBLE,FALSE);
addVarToCollect((char *)&(joint_filt_state[3].thdd),"R_HR_filt_thdd","rad/s^2",DOUBLE,FALSE);
addVarToCollect((char *)&(joint_filt_state[4].thdd),"R_EB_filt_thdd","rad/s^2",DOUBLE,FALSE);
addVarToCollect((char *)&(joint_filt_state[5].thdd),"R_WR_filt_thdd","rad/s^2",DOUBLE,FALSE);
addVarToCollect((char *)&(joint_filt_state[6].thdd),"R_WFE_filt_thdd","rad/s^2",DOUBLE,FALSE);
addVarToCollect((char *)&(joint_filt_state[7].thdd),"R_WAA_filt_thdd","rad/s^2",DOUBLE,FALSE);
addVarToCollect((char *)&(fieldtorque),"fieldtorque","N/m",DOUBLE,FALSE);
}
/* read the control gains and max controls */
if (!read_gains("Gains.cf",controller_gain_th, controller_gain_thd, controller_gain_int))
//if (!read_gains(controller_gain_th, controller_gain_thd, controller_gain_int))
printf("Error reading Gains.cf\n");
}
/**
* 测试创建临时账号
*/
void RobotManager::onCreateGuests()
{
static bool newconn = true;
if ((m_currGuestNum < m_limitGuestNum) && newconn)
{
uint16 port = accountport + m_connectCount % m_gateCount;
pushConnectCmd(accountip, port, TaskType_Account);
}
newconn = false;
int fd = getAccountFD();
if (fd > 0)
{
Robot* pRobot = new Robot(fd);
M_CHECKIN(pRobot);
pRobot->setType(TaskType_Player);
pRobot->applyTempAccount();
m_connectCount++;
m_currGuestNum++;
M_CHECKOUT(pRobot);
newconn = true;
}
return;
if (vec_fd_account.size() > 0)
{
int fd_account = vec_fd_account.back();
// Account act = m_accounts.back();
Robot* pRobot = new Robot(fd_account);
M_CHECKIN(pRobot);
// pRobot->applyAccount();
// pRobot->setAccount(act.account);
// pRobot->setPassword(act.password);
pRobot->getZoneList();
insert(pRobot);
addTask(pRobot);
pRobot->setType(TaskType_Player);
m_accounts.pop_back();
vec_fd_account.pop_back();
newconn = true;
}
}
void connectControllerAndModel( Controller* controller, CharmDataModel* model )
{
QObject::connect( controller, SIGNAL(eventAdded(Event)),
model, SLOT(addEvent(Event)) );
QObject::connect( controller, SIGNAL(eventModified(Event)),
model, SLOT(modifyEvent(Event)) );
QObject::connect( controller, SIGNAL(eventDeleted(Event)),
model, SLOT(deleteEvent(Event)) );
QObject::connect( controller, SIGNAL(allEvents(EventList)),
model, SLOT(setAllEvents(EventList)) );
QObject::connect( controller, SIGNAL(definedTasks(TaskList)),
model, SLOT(setAllTasks(TaskList)) );
QObject::connect( controller, SIGNAL(taskAdded(Task)),
model, SLOT(addTask(Task)) );
QObject::connect( controller, SIGNAL(taskUpdated(Task)),
model, SLOT(modifyTask(Task)) );
QObject::connect( controller, SIGNAL(taskDeleted(Task)),
model, SLOT(deleteTask(Task)) );
}
/*****************************************************************************
Name: void init_BSP(void)
Parameters:
Returns:
Description: Intializes borad support firmware.
*****************************************************************************/
void init_BSP(void)
{
ENABLE_LEDS
#if USE_LCD_DISPLAY == 1
init_disp();
#endif
init_Task_Timers();
ALL_LED_ON
t1ck1 = 0; t1ck0 = 1; // Set Timer 1 count source to 1/8
pre1 = 100; // Load prescaler with 1
t1 = 82; // load t1 with 4 2 x 5 = 10 :// 32.768 KHz / 32 / 10 = 102.4 times a second = 10 msec
DISABLE_INTS
t1ic = 0x01; // timer 1 underflow interrut. (S4).
ENABLE_INTS
#if USE_KEY_INPUT_BUFFER == 1
addTask(Keyinput_task, 5,(MAX_TASKS-1)); // Sample key input every 25 ms.
#endif
ALL_LED_OFF
}
void
JobCtrl::onDaemonRegistration(TaskEvent &event)
{
ComRegistrationTask *task =
dynamic_cast<ComRegistrationTask*>(event.getTask());
if (task != regTask_) {
delete task;
event.Skip();
return;
}
regTask_ = NULL;
if (task->getAction() == ComRegistrationTask::ACTION_REGISTER) {
if (task->getComTaskResult() == ComTask::RESULT_SUCCESS) {
/* Next, fetch versions from daemon */
versionTask_ = new ComVersionTask;
addTask(versionTask_);
} else {
/* Registration failed, disconnect again */
sendComEvent(JobCtrl::ERR_REG);
disconnect();
}
} else { /* ACTION_UNREGISTER */
ComThread *t;
if (task->getComTaskResult() != ComTask::RESULT_SUCCESS) {
sendComEvent(JobCtrl::ERR_REG);
}
/* Disconnect independent from unregistration-result */
while ((t = findComThread()) != 0) {
threadList_.DeleteObject(t);
t->stop();
delete t;
}
sendComEvent(JobCtrl::DISCONNECTED);
}
delete task;
event.Skip();
}
