int XDownloadTask::Process( float dt )
{
// 다운로드 시작
if( m_bGo ) {
// 다운로더가 다운받는 동작을 하고 있지 않을때
if( m_pDownloader->GetbGo() == FALSE ) {
if( m_itor != m_listReq.end() ) {
// 다운로드 리스트에서 하나씩 꺼내서 요청
xREQ_INFO info = *m_itor;
std::string strURL = info.strSubPath;
strURL += info.strURL;
bool result = m_pDownloader->RequestFile( strURL.c_str(), info.strDstFullpath.c_str() );
if( result ) {
} else
++m_Error;
}
} else {
auto& refTimer = m_pDownloader->GettimerTimeout();
if( !m_pDownloader->IsDownloading() ) {
// 요청은 했으나 다운로드가 시작이 안되고 있음.
if( refTimer.IsOff() )
refTimer.Set( 10.f );
// 일정시간 지나도 응답이 없으면 에러 출력.
if( refTimer.IsOver() ) {
refTimer.Off();
if( m_RiseError == 0 ) {
m_RiseError = 1;
CallEventHandler( XWM_ERROR_DOWNLOAD, (DWORD)XDownloader::xERR_NO_RESPONSE );
}
}
} else {
// 다운로드가 한번이라도 시작됐으면 타임아웃 타이머 꺼줌.(다운받다가 서버연결안되면 멈출수도 있음)
refTimer.Off();
}
// 에러가 있었으나 방금 해결됨.
if( m_RiseError ) {
// 문제가 해결된걸 알려줘야 함. <= 어따쓰는거지 -_-?
CallEventHandler( XWM_ERROR_DOWNLOAD, (DWORD)XDownloader::xOK );
m_RiseError = 0;
}
// 파일 하나를 다 받음.
if( m_pDownloader->GetbComplete() ) {
m_lastInfo = *m_itor++;;
if( m_lastInfo.strToRename.empty() == false ) {
// 받은 파일을 리네임 시킴
// 원래 파일 삭제
XSYSTEM::RemoveFile( m_lastInfo.strToRename.c_str() );
XSYSTEM::RenameFile( m_lastInfo.strDstFullpath, m_lastInfo.strToRename );
}
if( m_itor == m_listReq.end() ) {
// 모든 파일을 다 다운받음.
XTRACE("XDownloadTask: %d files download Complete", m_listReq.size() );
m_bComplete = TRUE;
m_bCallbackAll = FALSE;
m_bGo = FALSE;
} else {
XTRACE("XDownloadTask each Complete.%s", C2SZ( m_lastInfo.strDstFullpath ) );
XTRACE("-Next file:.%s", C2SZ( m_itor->strDstFullpath ) );
CallEventHandler( XWM_EACH_COMPLETE, 0/*, (DWORD)(&reqInfo)*/ );
// complete상태를 풀어줘서 Go 대기상태로 만듬.
m_pDownloader->ClearComplete();
}
}
}
}
if( m_Error ) {
CallEventHandler( XWM_ERROR_DOWNLOAD, XDownloader::xERR_FAILED_REQUEST );
m_Error = 0;
}
// 다운로드가 다 끝나고 콜백호출을 아직 안했으면 호출함.
if( m_bComplete && m_bCallbackAll == FALSE ) {
// 콜백호출까지 하면 다 마무리
m_itor = m_listReq.begin();
m_bCallbackAll = TRUE;
m_bComplete = FALSE;
m_listComplete = m_listReq;
m_listReq.clear();
BOOL bSuccess = TRUE;
XDownloader::xtError codeErr = XDownloader::xERR_UNKNOWN;
// 받은 파일의 에러검사.
if( XBREAK( m_listComplete.size() == 0 ) )
bSuccess = FALSE;
for( auto& info : m_listComplete ) {
if( XBREAK( info.strDstFullpath.empty() == true ) )
bSuccess = FALSE;
if( XBREAK( info.strURL.empty() == true ) )
bSuccess = FALSE;
}
//
if( bSuccess )
{
// 다운 다받은후 이벤트 발생시킬땐 에러가 없음을 보증하고 발생시킬것.
XTRACE("XDownloadTask: Call handler: XWM_ALL_COMPLETE");
CallEventHandler( XWM_ALL_COMPLETE );
ClearEvent( XWM_ALL_COMPLETE );
} else {
CallEventHandler( XWM_ERROR_DOWNLOAD, codeErr );
ClearEvent( XWM_ERROR_DOWNLOAD );
}
m_pDownloader->ClearComplete();
}
return 1;
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t1_instance(void)
{
AlarmBaseType AlarmBaseType_inst_1;
EventMaskType EventMaskType_inst_1;
StatusType result_inst_2, result_inst_3, result_inst_4, result_inst_5, result_inst_6, result_inst_7, result_inst_8, result_inst_9, result_inst_10, result_inst_11, result_inst_12, result_inst_13, result_inst_14, result_inst_15, result_inst_16, result_inst_17, result_inst_18, result_inst_19;
TaskStateType TaskStateType_inst_1;
TaskType TaskType_inst_1;
TickType TickType_inst_1;
SCHEDULING_CHECK_STEP(1);
SCHEDULING_CHECK_STEP(2);
SuspendAllInterrupts();
SCHEDULING_CHECK_INIT(3);
result_inst_2 = ActivateTask(t2);
SCHEDULING_CHECK_AND_EQUAL_INT(4,E_OS_DISABLEDINT, result_inst_2);
SCHEDULING_CHECK_INIT(5);
result_inst_3 = TerminateTask();
SCHEDULING_CHECK_AND_EQUAL_INT(6,E_OS_DISABLEDINT, result_inst_3);
SCHEDULING_CHECK_INIT(7);
result_inst_4 = ChainTask(t2);
SCHEDULING_CHECK_AND_EQUAL_INT(8,E_OS_DISABLEDINT, result_inst_4);
SCHEDULING_CHECK_INIT(9);
result_inst_5 = Schedule();
SCHEDULING_CHECK_AND_EQUAL_INT(10,E_OS_DISABLEDINT, result_inst_5);
SCHEDULING_CHECK_INIT(11);
result_inst_6 = GetTaskID(&TaskType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(12,E_OS_DISABLEDINT, result_inst_6);
SCHEDULING_CHECK_INIT(13);
result_inst_7 = GetTaskState(t2, &TaskStateType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(14,E_OS_DISABLEDINT, result_inst_7);
SCHEDULING_CHECK_INIT(15);
result_inst_8 = GetResource(Resource1);
SCHEDULING_CHECK_AND_EQUAL_INT(16,E_OS_DISABLEDINT, result_inst_8);
SCHEDULING_CHECK_INIT(17);
result_inst_9 = ReleaseResource(Resource1);
SCHEDULING_CHECK_AND_EQUAL_INT(18,E_OS_DISABLEDINT, result_inst_9);
SCHEDULING_CHECK_INIT(19);
result_inst_10 = SetEvent(t2, Event1);
SCHEDULING_CHECK_AND_EQUAL_INT(20,E_OS_DISABLEDINT, result_inst_10);
SCHEDULING_CHECK_INIT(21);
result_inst_11 = ClearEvent(Event1);
SCHEDULING_CHECK_AND_EQUAL_INT(22,E_OS_DISABLEDINT, result_inst_11);
SCHEDULING_CHECK_INIT(23);
result_inst_12 = GetEvent(t2, &EventMaskType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(24,E_OS_DISABLEDINT, result_inst_12);
SCHEDULING_CHECK_INIT(25);
result_inst_13 = WaitEvent(Event1);
SCHEDULING_CHECK_AND_EQUAL_INT(26,E_OS_DISABLEDINT, result_inst_13);
SCHEDULING_CHECK_INIT(27);
result_inst_14 = GetAlarmBase(Alarm1, &AlarmBaseType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(28,E_OS_DISABLEDINT, result_inst_14);
SCHEDULING_CHECK_INIT(29);
result_inst_15 = GetAlarm(Alarm1, &TickType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(30,E_OS_DISABLEDINT, result_inst_15);
SCHEDULING_CHECK_INIT(31);
result_inst_16 = SetRelAlarm(Alarm1, 1, 0);
SCHEDULING_CHECK_AND_EQUAL_INT(32,E_OS_DISABLEDINT, result_inst_16);
SCHEDULING_CHECK_INIT(33);
result_inst_17 = SetAbsAlarm(Alarm1, 1, 0);
SCHEDULING_CHECK_AND_EQUAL_INT(34,E_OS_DISABLEDINT, result_inst_17);
SCHEDULING_CHECK_INIT(35);
result_inst_18 = CancelAlarm(Alarm1);
SCHEDULING_CHECK_AND_EQUAL_INT(36,E_OS_DISABLEDINT, result_inst_18);
SCHEDULING_CHECK_INIT(37);
result_inst_19 = GetActiveApplicationMode();
SCHEDULING_CHECK_AND_EQUAL_INT(38,OSDEFAULTAPPMODE, result_inst_19);
SCHEDULING_CHECK_STEP(39);
ResumeAllInterrupts();
}
void HandleEvent()
{
U8 RefrashCounter;
EVENT Evt = Player.Event;
ClearEvent();
switch(Evt)
{
case EV_NULL:
break;
case EV_DREQ:
if(BufCnt>=32)
{
VS_Send32Byte(DataPtr);
DataPtr += 32;
BufCnt -= 32;
}
else
GenerateEvent(EV_BUFEMPTY);
break;
case EV_BUFEMPTY:
if(f_eof(Player.currFile))
GenerateEvent(EV_END);
else
{
f_read((Player.currFile), DataBuf, BUFSIZE, &BufCnt);
DataPtr = DataBuf;
}
RefrashCounter++;
if(RefrashCounter == Refrash){
LCDClean();
LCDPutString("Now Playing #");
LCDPutUInt(Player.SongNum);}
break;
case EV_NEXT:
VS_CancelDecoding();
if(++Player.SongNum > Player.TotalSongNum)
Player.SongNum= 1;
scan_files_open (Player.currFile,"/",Player.SongNum);
GenerateEvent(EV_BUFEMPTY);
RefrashCounter = Reset;
break;
case EV_PREVIOUS:
VS_CancelDecoding();
if(--Player.SongNum == 0)
Player.SongNum= Player.TotalSongNum;
scan_files_open (Player.currFile,"/",Player.SongNum);
GenerateEvent(EV_BUFEMPTY);
RefrashCounter = Reset;
break;
case EV_MODE:
Player.Mode++;
Player.Mode %= 3;
SetLED(Player.Mode);
LCDClean();
LCDPutString("Mode: ");
if(Player.Mode==SM_BASS)
LCDPutString("Bass");
if(Player.Mode==SM_TREBLE)
LCDPutString("Treble");
if(Player.Mode==SM_SONG)
LCDPutString("Song");
RefrashCounter = Reset;
break;
case EV_BASSTREB:
VS_SetBassTreble(Player.Bass,Player.Treble);
LCDClean();
LCDPutString("Bass: ");
LCDPutUInt(Player.Bass);
if(Player.Mode==SM_BASS)
LCDPutString(" <--");
LCDChangeLine();
LCDPutString("Treble: ");
LCDPutInt(Player.Treble);
if(Player.Mode==SM_TREBLE)
LCDPutString(" <--");
RefrashCounter = Reset;
break;
case EV_VOLUME:
VS_SetVol(Player.Volume);
LCDClean();
LCDPutString("Now Playing #");
LCDPutUInt(Player.SongNum);
LCDChangeLine();
LCDPutString("Volume: ");
LCDPutUInt(((ADC0+48)/41));//0~100
LCD_DataWrite('%');
RefrashCounter = Reset;
break;
case EV_PAUSE:
// ConsoleWrite("Paused.\n");
Player.Status = PS_PAUSED;
LCDClean();
LCDPutString("|| Paused....");
break;
case EV_PLAY:
// ConsoleWrite("Resume Playing...\n");
Player.Status = PS_PLAYING;
LCDClean();
LCDPutString("Now Playing: #");
LCDPutUInt(Player.SongNum);
break;
case EV_END:
Player.Event = EV_NEXT;
LCDClean();
LCDPutString("End.");
break;
default:
break;
}
}
//--------------------------------------------------------------------
AEvent::~AEvent()
//--------------------------------------------------------------------
{
ClearEvent();
}
void Dcm_Ex1Receiver(void)
{
WaitEvent(0x01);
ClearEvent(0x01);
ex1SendFC();
}
SiliconData::~SiliconData()
{
// printf("Destructor called for SiliconData");
ClearEvent();
}
boolean Plugin_005(byte function, struct NodoEventStruct *event, char *string)
{
boolean success=false;
static byte Call_Status = 0x00; // Each bit represents one relative port. 0=not called before, 1=already called before.
switch(function)
{
#ifdef PLUGIN_005_CORE
case PLUGIN_COMMAND:
{
int DSTemp; // Temperature in 16-bit Dallas format.
byte ScratchPad[12]; // Scratchpad buffer Dallas sensor.
byte var=event->Par2; // Variabele die gevuld moet worden.
byte RelativePort=event->Par1-1;
UserVariablePayload(var,0x0011);
// De Dallas sensor kan worden aangesloten op iedere digitale poort van de Arduino. In ons geval kiezen we er voor
// om de sensor aan te sluiten op de Wired-Out poorten van de Nodo. Met Par2 is de Wired poort aangegeven.
// 1 = WiredOut poort 1.
DallasPin=PIN_WIRED_OUT_1+event->Par1-1;
ClearEvent(event); // Ga uit van een default schone event. Oude eventgegevens wissen.
noInterrupts();
while (!(bitRead(Call_Status, RelativePort)))
{
// if this is the very first call to the sensor on this port, reset it to wake it up
boolean present=DS_reset();
bitSet(Call_Status, RelativePort);
}
boolean present=DS_reset();DS_write(0xCC /* rom skip */); DS_write(0x44 /* start conversion */);
interrupts();
if(present)
{
delay(800); // uitleestijd die de sensor nodig heeft
noInterrupts();
DS_reset(); DS_write(0xCC /* rom skip */); DS_write(0xBE /* Read Scratchpad */);
// Maak de lijn floating zodat de sensor de data op de lijn kan zetten.
digitalWrite(DallasPin,LOW);
pinMode(DallasPin,INPUT);
for (byte i = 0; i < 9; i++) // copy 8 bytes
ScratchPad[i] = DS_read();
interrupts();
DSTemp = (ScratchPad[1] << 8) + ScratchPad[0];
TempFloat=float(DSTemp)*0.0625; // DS18B20 variant. Waarde terugstoppen in de variabele
success=(UserVariableSet(var,TempFloat,PLUGIN_05_EVENT)!=-1);
}
break;
}
#endif // CORE
#if NODO_MEGA
case PLUGIN_MMI_IN:
{
char *TempStr=(char*)malloc(INPUT_COMMAND_SIZE);
if(GetArgv(string,TempStr,1))
{
if(strcasecmp(TempStr,PLUGIN_NAME)==0)
{
// Par1 en Par2 hoeven niet te worden geparsed omdat deze default al door de MMI invoer van de Nodo
// worden gevuld indien het integer waarden zijn. Toetsen op bereiken moet nog wel plaats vinden.
if(event->Par1>0 && event->Par1<=HARDWARE_WIRED_OUT_PORTS && event->Par2>0 && event->Par2<=USER_VARIABLES_MAX_NR)
{
success=true;
event->Type = NODO_TYPE_PLUGIN_COMMAND;
event->Command = 5; // Plugin nummer
}
}
}
free(TempStr);
break;
}
case PLUGIN_MMI_OUT:
{
strcpy(string,PLUGIN_NAME); // Eerste argument=het commando deel
strcat(string," ");
strcat(string,int2str(event->Par1));
strcat(string,",");
strcat(string,int2str(event->Par2));
break;
}
#endif //MMI
}
return success;
}
boolean Plugin_026(byte function, struct NodoEventStruct *event, char *string)
{
boolean success=false;
#ifdef PLUGIN_026_CORE
static byte portValue=0;
switch(function)
{
case PLUGIN_INIT:
{
// get the current pin status
uint8_t address = 0x20;
Wire.requestFrom(address, (uint8_t)0x1);
if(Wire.available()) portValue = Wire.read();
break;
}
case PLUGIN_ONCE_A_SECOND:
{
byte tmpPortValue=0;
uint8_t address = 0x20;
// get the current pin status
Wire.requestFrom(address, (uint8_t)0x1);
if(Wire.available())
{
tmpPortValue = Wire.read();
if (tmpPortValue != portValue)
{
for (byte x=0; x<8; x++)
{
if ((portValue & (1 << x)) != (tmpPortValue & (1 << x)))
{
struct NodoEventStruct tmpEvent;
ClearEvent(&tmpEvent);
tmpEvent.Type = NODO_TYPE_PLUGIN_EVENT;
tmpEvent.Command = PLUGIN_ID;
tmpEvent.Par1 = x+1;
tmpEvent.Par2 = VALUE_ON;
if (tmpPortValue & (1 << x)) tmpEvent.Par2 = VALUE_OFF;
ProcessEvent(&tmpEvent);
//QueueAdd(&tmpEvent);
}
}
portValue = tmpPortValue;
}
success=true;
}
break;
}
#endif // CORE
#if NODO_MEGA // alleen relevant voor een Nodo Mega want de Small heeft geen MMI!
case PLUGIN_MMI_IN:
{
char *TempStr=(char*)malloc(INPUT_COMMAND_SIZE);
if(GetArgv(string,TempStr,1))
{
if(strcasecmp(TempStr,PLUGIN_NAME_026)==0)
{
if(GetArgv(string,TempStr,2))
{
if(GetArgv(string,TempStr,3))
{
if(event->Par1>0 && event->Par1<65 && (event->Par2==VALUE_ON || event->Par2==VALUE_OFF))
{
event->Type = NODO_TYPE_PLUGIN_EVENT;
event->Command = 26; // Plugin nummer
success=true;
}
}
}
}
}
free(TempStr);
break;
}
case PLUGIN_MMI_OUT:
{
strcpy(string,PLUGIN_NAME_026);
strcat(string," ");
strcat(string,int2str(event->Par1));
strcat(string,",");
if(event->Par2==VALUE_ON)
strcat(string,"On");
else strcat(string,"Off");
break;
}
#endif //MMI
}
return success;
}
/** 走行中の処理 */
SINT Driver::state_driving(void){
//DEBUG_PRINT1("s", "state_driving()");
RobotInfo r_info;
NavInfo n_info;
RobotCmd cmd;
bool ret;
navigator_.Init();
//Position prePos;
//Position now_position;
// F32 r = 41.34; // タイヤの半径 []
// F32 d = 82.6; // 左右のタイヤ間距離 [mm]
// S32 angR = nxt_motor_get_count(1);
// S32 angL = nxt_motor_get_count(2);
// S32 angR_bak;
// S32 angL_bak;
navigator_.Init();
r_info = robot_.GetInfo();
//angR = r_info.rot_encoderR_val;
//angL = r_info.rot_encoderL_val;
n_info = navigator_.GetInfo(r_info);
// 最初のミッションを設定＆初期化
cur_mission_iter_ = this->mission_list_.Begin();
if ( cur_mission_iter_ != this->mission_list_.End() ){
(*cur_mission_iter_)->Init(r_info, n_info);
} else {
this->status_ = STATE_ERROR;
}
this->ClearEventFlag();
SetRelAlarm(Alarm4msec, 1, DRIVE_PERIOD); // ドライブ用Alarmタイマーのセット
// 走行開始
// ステータスが運転中ならループを繰り返す
while(this->status_ == STATE_DRIVING){
//DEBUG_PRINT1("s", (*cur_mission_iter_)->Name());
ClearEvent(EventDrive); // ドライブイベントのクリア
WaitEvent(EventDrive); // ドライブイベント待ち
// タッチセンサON,もしくは転倒情報より走行停止
if ( event_flag_.is_SetEvent(Robot::EVENT_TOUCH_SENSOR_ON) || event_flag_.is_SetEvent(Robot::EVENT_FAIL) ){
status_ = STATE_WAIT_START;
break;
}
// デバッグ用
if ( event_flag_.is_SetEvent(Robot::EVENT_GYRO) ){
// robot_.Beep();
}
if ( event_flag_.is_SetEvent(Robot::EVENT_GYRO2) ){
// robot_.Beep();
}
if ( event_flag_.is_SetEvent(Robot::EVENT_SONAR_SENSOR_ON) ){
// robot_.Beep();
}
r_info = robot_.GetInfo();
n_info = navigator_.GetInfo(r_info);
//prePos = now_position;
//angR_bak = angR;
//angL_bak = angL;
//angR = r_info.rot_encoderR_val;
//angL = r_info.rot_encoderL_val;
//now_position = getPositionEstimation(prePos, angR - angR_bak, angL - angL_bak, r, d);
while(1){
ret = (*cur_mission_iter_)->Run(r_info, n_info, this->event_flag_, cmd);
if ( ret == true ){
robot_.Drive(cmd);
break;
} else if ( ret == false ){
// 次のミッションに遷移
++cur_mission_iter_;
if ( cur_mission_iter_ == mission_list_.End() ){
// ミッションリストがなくなったので終了
// ただし、最後のミッションは倒立したまま停止を続けるはずなので、
// 基本的にこの処理には入らない
this->status_ = STATE_COMPLETE;
break;
} else {
(*cur_mission_iter_)->Init(r_info, n_info);
continue;
}
} else {
// ここに入ることはないはず
this->status_ = STATE_WAIT_START;
break;
}
}
#if 1
// Bluetooth データ送信
if ( this->is_bt_connect_ ){
robot_.BTSend(cmd, r_info, n_info);
//robot_.BTSend(cmd, now_position);
}
#endif
this->ClearEventFlag();
}
robot_.Stop();
this->ClearEventFlag();
CancelAlarm(Alarm4msec); // ドライブ用Alarmタイマーのキャンセル
ClearEvent(EventDrive); // ドライブイベントのクリア
return 0;
}
inline std_return RTE_Manager_Input_GetValue_Event_In(char *a)
{
WaitEvent(RTE_Manager_Input_GetValue_Event_In_EVENT);
ClearEvent(RTE_Manager_Input_GetValue_Event_In_EVENT);
return 0;
}
void Looper::Loop()
{
unsigned long nEntries = tree_->GetEntries();
//ostringstream os; os<<"Running on "<<nEntries<<" entries" ;
Log(__FUNCTION__,"INFO", Form("Running on %d entries",nEntries) );
sw_. Reset();
try{
for(unsigned long iEntry = 0 ;iEntry< nEntries ;++iEntry)
{
if(iEntry %10000 == 0 ) {
sw_.Stop();
Log(__FUNCTION__,"INFO",Form("Getting Entry %lu / %lu in (Cpu) %.4f (Real) %.4f",iEntry,nEntries, sw_.CpuTime(),sw_.RealTime()) );
//LogErr(__FUNCTION__,"INFO",Form("Getting Entry %lu / %lu in (Cpu) %.4f (Real) %.4f",iEntry,nEntries, sw_.CpuTime(),sw_.RealTime()) );
static int slow_machine=0;
// min entries per second
if (iEntry >30000 and minEntries_>0 and 10000./sw_.RealTime() < minEntries_){
Log(__FUNCTION__,"WARNING",Form("Machine is too slow e/s=%.3f",10000./sw_.RealTime()));
++slow_machine;
if (slow_machine> 3)throw slow();
}
// check that real time is within a ord of magn of cpu time
else if (iEntry >30000 and minEntries_>0 and sw_.RealTime() > 100* sw_.CpuTime()){
Log(__FUNCTION__,"WARNING","Real time too big wrt cpu time. I/O Problems?");
++slow_machine;
if(slow_machine>3)throw slow();
}
else
{
slow_machine=0;
}
sw_ .Reset();
sw_ .Start();
}
#ifdef VERBOSE
if (VERBOSE > 1) cout <<"[Looper]::[Loop] Getting Entry "<<iEntry << " of "<<nEntries<<endl;
#endif
ClearEvent();
// load tree
tree_ -> GetEntry(iEntry);
fEntry=iEntry;
//move content into the event
FillEvent();
// for each smearing
for(auto s : systs_)
{
#ifdef VERBOSE
if (VERBOSE > 1) cout <<"[Looper]::[Loop] Doing syst "<< s -> name() <<endl;
#endif
for(int i=-1; i<=1 ;++i)
{
if ( s->name().find("NONE") != string::npos and i!=0) continue;
if ( s->name().find("NONE") == string::npos and i==0) continue; // for the
#ifdef VERBOSE
if (VERBOSE > 1) cout <<"[Looper]::[Loop] Doing syst "<< s -> name() <<" : (Up,Down)"<<i <<endl;
#endif
//reset
event_->clearSyst();
//
s->SetSyst(i);
//smear
s->smear(event_);
//do the corrections on top
for(auto& c : correctors_)
{
#ifdef VERBOSE
if (VERBOSE > 1) Log(__FUNCTION__,"DEBUG", string("Doing Corrector: ") + c->name());
#endif
s->smear(c);
c->correct(event_);
}
//do the analysis
for(auto a : analysis_)
{
#ifdef VERBOSE
if (VERBOSE > 1) Log(__FUNCTION__,"DEBUG", string("Doing Analysis: ") + a->name());
#endif
//event_->validate(); // validate the objects -- after setting cuts now in doAnalyze
// each analysis step will apply the SF accordingly to the object it is using
event_ -> GetWeight() -> clearSF() ;
event_ -> GetWeight() -> clearPU() ; // for target
if ( a->doAnalyze(event_,s->name()) > 0 ) break; // go on analyzing event, if no analysis returns >0
#ifdef VERBOSE
if (VERBOSE > 1) Log(__FUNCTION__,"DEBUG", string("Done: ") + a->name());
#endif
}
}
// necessary for corrector smearer!
s->SetSyst(0); // not necessary, but cleaner in this way
}
}
}
catch( sigint_exception &e)
{
Log(__FUNCTION__,"SIGNAL"," Caught SIGINT/SIGTERM: exiting! ");
Write();
Close();
dump_->Close();
throw e;
}
//call end procedures for the analyis
for(auto a : analysis_)
a->doEnd();
// save output
dump_->Close();
Write();
Close();
return;
}
extern int8_t ciaaModbus_masterCmd0x17ReadWriteMultipleRegisters(
int32_t hModbusMaster,
uint16_t startAddressR,
uint16_t quantityR,
int16_t *hrValueR,
uint16_t startAddressW,
uint16_t quantityW,
int16_t *hrValueW,
uint8_t slaveId,
modbusMaster_cbEndOfCommType cbEndComm)
{
int8_t ret;
/* check if no command pending and valid slave id */
if ( (ciaaModbus_masterObj[hModbusMaster].cmd == 0) &&
(0 != slaveId) )
{
/* no exception code */
ciaaModbus_masterObj[hModbusMaster].exceptioncode = 0;
/* set start address */
ciaaModbus_masterObj[hModbusMaster].startAddressR = startAddressR;
ciaaModbus_masterObj[hModbusMaster].startAddressW = startAddressW;
/* set quantity of registers */
ciaaModbus_masterObj[hModbusMaster].quantityR = quantityR;
ciaaModbus_masterObj[hModbusMaster].quantityW = quantityW;
/* set pointer to store data read */
ciaaModbus_masterObj[hModbusMaster].pDataR = hrValueR;
ciaaModbus_masterObj[hModbusMaster].pDataW = hrValueW;
/* set slave id */
ciaaModbus_masterObj[hModbusMaster].slaveId = slaveId;
/* set retry count */
ciaaModbus_masterObj[hModbusMaster].retryCount = ciaaModbus_masterObj[hModbusMaster].retryComm;
/* set task id to set event if blocking operation */
GetTaskID(&ciaaModbus_masterObj[hModbusMaster].taskID);
/* set call back if non-blocking operation */
ciaaModbus_masterObj[hModbusMaster].cbEndComm = cbEndComm;
/* set command to execute */
ciaaModbus_masterObj[hModbusMaster].cmd = CIAA_MODBUS_FCN_READ_WRITE_MULTIPLE_REGISTERS;
/* if no callback wait event... */
if (NULL == cbEndComm)
{
/* wait for event */
WaitEvent(MODBUSE);
ClearEvent(MODBUSE);
/* return exception code */
ret = ciaaModbus_masterObj[hModbusMaster].exceptioncode;
}
else
{
/* if non-blocking, return 0 */
ret = 0;
}
}
else
{
/* return -1 if it was not possible execute the function */
ret = -1;
}
return ret;
}
extern int8_t ciaaModbus_masterCmd0x06WriteSingleRegister(
int32_t hModbusMaster,
uint16_t startAddress,
int16_t value,
uint8_t slaveId,
modbusMaster_cbEndOfCommType cbEndComm)
{
int8_t ret;
/* check if no command pending and valid slave id */
if ( (ciaaModbus_masterObj[hModbusMaster].cmd == 0) &&
(0 != slaveId) )
{
/* no exception code */
ciaaModbus_masterObj[hModbusMaster].exceptioncode = 0;
/* set start address */
ciaaModbus_masterObj[hModbusMaster].startAddressW = startAddress;
/* set register value */
ciaaModbus_masterObj[hModbusMaster].dataW = value;
/* set slave id */
ciaaModbus_masterObj[hModbusMaster].slaveId = slaveId;
/* set retry count */
ciaaModbus_masterObj[hModbusMaster].retryCount = ciaaModbus_masterObj[hModbusMaster].retryComm;
/* set task id to set event if blocking operation */
GetTaskID(&ciaaModbus_masterObj[hModbusMaster].taskID);
/* set call back if non-blocking operation */
ciaaModbus_masterObj[hModbusMaster].cbEndComm = cbEndComm;
/* set command to execute */
ciaaModbus_masterObj[hModbusMaster].cmd = CIAA_MODBUS_FCN_WRITE_SINGLE_REGISTER;
/* if no callback wait event... */
if (NULL == cbEndComm)
{
/* wait for event */
WaitEvent(MODBUSE);
ClearEvent(MODBUSE);
/* return exception code */
ret = ciaaModbus_masterObj[hModbusMaster].exceptioncode;
}
else
{
/* if non-blocking, return 0 */
ret = 0;
}
}
else
{
/* return -1 if it was not possible execute the function */
ret = -1;
}
return ret;
}
/** \brief Perform read operation in modbus master
**
** This function start read operation and wait for
** end or return if callback not NULL
**
** \param[in] handler handler modbus master
** \param[in] startAddress starting address to read
** \param[in] quantity of coils/register to read
** \param[out] pData pointer to store data reads
** \param[in] slaveId slave identification number
** \param[in] cbEndComm call back function
** if NULL pointer is passed, this function block until
** end of communication (using MODBUSE).
** if call back is passed, this function return and
** call back will be executed at end of communication
** \return -1 if master is busy or invalid id passed
** 0 successful
** 1 function not supported
** 2 wrong starting address
** 3 wrong quantity
** 4 function error
** 5 the slave not respond
** 6 pdu received wrong
**/
static int8_t ciaaModbus_masterRead(
int32_t hModbusMaster,
uint16_t startAddress,
uint16_t quantity,
void *pData,
uint8_t slaveId,
uint8_t cmd,
modbusMaster_cbEndOfCommType cbEndComm)
{
int8_t ret;
/* check if no command pending and valid slave id */
if ( (ciaaModbus_masterObj[hModbusMaster].cmd == 0) &&
(0 != slaveId) )
{
/* no exception code */
ciaaModbus_masterObj[hModbusMaster].exceptioncode = 0;
/* set start address */
ciaaModbus_masterObj[hModbusMaster].startAddressR = startAddress;
/* set quantity of registers */
ciaaModbus_masterObj[hModbusMaster].quantityR = quantity;
/* set pointer to store data read */
ciaaModbus_masterObj[hModbusMaster].pDataR = pData;
/* set slave id */
ciaaModbus_masterObj[hModbusMaster].slaveId = slaveId;
/* set retry count */
ciaaModbus_masterObj[hModbusMaster].retryCount = ciaaModbus_masterObj[hModbusMaster].retryComm;
/* set task id to set event if blocking operation */
GetTaskID(&ciaaModbus_masterObj[hModbusMaster].taskID);
/* set call back if non-blocking operation */
ciaaModbus_masterObj[hModbusMaster].cbEndComm = cbEndComm;
/* set command to execute */
ciaaModbus_masterObj[hModbusMaster].cmd = cmd;
/* if no callback wait event... */
if (NULL == cbEndComm)
{
/* wait for event */
WaitEvent(MODBUSE);
ClearEvent(MODBUSE);
/* return exception code */
ret = ciaaModbus_masterObj[hModbusMaster].exceptioncode;
}
else
{
/* if non-blocking, return 0 */
ret = 0;
}
}
else
{
/* return -1 if it was not possible execute the function */
ret = -1;
}
return ret;
}
boolean Plugin_011(byte function, struct NodoEventStruct *event, char *string)
{
boolean success=false;
// Deze plugin code wordt vanuit meerdere plaatsen in de Nodo code aangeroepen, steeds met een doel. Dit doel bevindt zich
// in de variabele [function]. De volgende zijn gedefinieerd:
//
// PLUGIN_RAWSIGNAL_IN => Afhandeling van een via RF/IR ontvangen event
// PLUGIN_COMMAND => Commando voor afhandelen/uitsturen van een event.
// PLUGIN_MMI_IN => Invoer van de gebruiker/script omzetten naar een event. (Alleen voor mega)
// PLUGIN_MMI_OUT => Omzetten van een event naar een voor de gebruiker leesbare tekst (Alleen voor Mega)
// DEVIDE_ONCE_A_SECOND => ongeveer iedere seconde.
// PLUGIN_INIT => Eenmalig, direct na opstarten van de Nodo
// PLUGIN_EVENT_IN => Vlak voor verwerking van een binnengekomen event.
// PLUGIN_SERIAL_IN => Zodra er bytes via de seriele poort zijn ontvangen
// PLUGIN_ETHERNET_IN => Zodra er bytes via de seriele poort zijn ontvangen
switch(function)
{
#ifdef PLUGIN_011_CORE
case PLUGIN_INIT:
{
Serial.println(F("*** debug: BRC Plugin started.")); //??? Debug
break;
}
case PLUGIN_EVENT_IN:
{
Serial.println(F("*** debug: BRC: PLUGIN_EVENT_IN"));
break;
}
case PLUGIN_ONCE_A_SECOND:
{
break;
}
case PLUGIN_RAWSIGNAL_IN:
{
Serial.println(F("*** debug: BRC: PLUGIN_RAWSIGNAL_IN"));
break;
}
case PLUGIN_COMMAND:
{
Serial.print(F("*** debug: BRC: PLUGIN_COMMAND"));
Serial.print(", Par1="); Serial.print(event->Par1);
Serial.print(", Par2="); Serial.println(event->Par2);
// Als voorbeeld wordt hier variabele 5 gevuld met 123.45
byte Variable = 5;
float Value = 123.45;
ClearEvent(event); // Ga uit van een default schone event. Oude eventgegevens wissen.
event->Type = NODO_TYPE_COMMAND; // Het event is een uit te voeren commando
event->Command = CMD_VARIABLE_SET; // Commando "VariableSet"
event->Par1 = Variable; // Par1 draagt het variabelenummer
event->Par2 = float2ul(Value); // Par2 de waarde. float2ul() zet de waarde m naar een geschikt format.
success=true; // Als verlaten wordt met een true, en er is een nieuw event in de struct geplaatst
// dan wordt deze automatisch uitgevoerd.
// Een plugin kan geen andere plugin aanroepen.
// verder is er geen beperking en kunnen alle events/commando's worden
// opgegeven voor verdere verwerking.
break;
}
#endif // CORE
#if NODO_MEGA // alleen relevant voor een Nodo Mega want de Small heeft geen MMI!
case PLUGIN_MMI_IN:
{
Serial.print(F("*** debug: BRC: PLUGIN_MMI_IN, string="));Serial.println(string); //??? Debug
// Zodra er via een script, HTTP, Telnet of Serial een commando wordt ingevoerd, wordt dit deel van de code langs gelopen.
// Op deze plek kan de invoer [string] worden geparsed en omgezet naar een struct [event]. Als parsen van de invoerstring [string]
// is gelukt en de struct is gevuld, dan de variabele [success] vullen met true zodat de Nodo zorg kan dragen voor verdere verwerking van het event.
char *TempStr=(char*)malloc(INPUT_COMMAND_SIZE);
// Met PLUGIN_MMI_IN wordt de invoer van de gebruiker (string) omgezet naar een event zodat de Nodo deze intern kan verwerken.
// Hier aangekomen bevat string het volledige commando. Test als eerste of het opgegeven commando overeen komt met PLUGIN_NAME
// Dit is het eerste argument in het commando.
if(GetArgv(string,TempStr,1))
{
// Als het door de gebruiker ingegeven ommando/event overeenkomt met de naam van dit plugin...
if(strcasecmp(TempStr,PLUGIN_NAME)==0)
{
// in dit voorbeeld even laten weten dat de code wordt geraakt. Directe output naar
// Serial is normaal gesproken NIET wenselijk in een plugin.
// Vervolgens tweede parameter gebruiken
if(GetArgv(string,TempStr,2))
{
// plaats hier je code die de eerste parameter die zich in [TempStr] bevindt verder uitparsed
// De byte Par1 en unsigned long Par2 die zich in de struct [event] bevindt kunnen worden gebruikt.
if(GetArgv(string,TempStr,3))
{
// indien gewenst kan een tweede parameter worden gebruikt (=derde argument)
// Plaats wederom de code paar uitparsen van de parameter hier.
// heb je het laatste parameter geparsen, dan de variabele [success] vullen
// met een true zodat verdere verwerking van het event plaats kan vinden.
// Een plugin kan worden verwerkt als een commando of een event. Geef dit aan want
// op moment van invoer moet de Nodo t.b.v. latere verwerking weten hoe de zaken afgehandeld moeten worden
event->Type = NODO_TYPE_PLUGIN_COMMAND;
event->Command = PLUGIN_ID; // nummer van dit plugin
// Als success wordt gevuld met true, dan wordt het commando/event
// geaccepteerd als geldig.
success=true;
}
}
}
}
free(TempStr);
break;
}
case PLUGIN_MMI_OUT:
{
// De code die zich hier bevindt zorgt er voor dan een event met het unieke ID in de struct [event] weer wordt
// omgezet naar een leesbaar event voor de gebruiker. het resultaat moet worden geplaatst in de string [string]
// let op dat het totale commando niet meer dan 25 posities in beslag neemt.
// Dit deel van de code wordt alleen uitgevoerd door een Nodo Mega, omdat alleen deze over een MMI beschikt.
Serial.println(F("*** debug: BRC: PLUGIN_MMI_OUT")); //??? Debug
strcpy(string,PLUGIN_NAME); // Commando
strcat(string," ");
strcat(string,int2str(event->Par1)); // Parameter-1 (8-bit)
strcat(string,",");
strcat(string,int2str(event->Par2)); // Parameter-2 (32-bit)
break;
}
#endif //MMI
}
return success;
}
Event::~Event(){
ClearEvent();
delete weight_;
}
~Looper(){ClearEvent();}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t1_instance(void)
{
StatusType result_inst_1, result_inst_2, result_inst_3, result_inst_4, result_inst_5, result_inst_6, result_inst_7, result_inst_8, result_inst_9, result_inst_10, result_inst_11, result_inst_12, result_inst_13, result_inst_14, result_inst_15, result_inst_16, result_inst_17, result_inst_18, result_inst_19, result_inst_20, result_inst_21, result_inst_22, result_inst_23, result_inst_24;
SCHEDULING_CHECK_INIT(1);
result_inst_1 = ActivateTask(t2);
SCHEDULING_CHECK_AND_EQUAL_INT(1,E_OK , result_inst_1);
SCHEDULING_CHECK_INIT(2);
result_inst_2 = ActivateTask(t3);
SCHEDULING_CHECK_AND_EQUAL_INT(2,E_OK , result_inst_2);
SCHEDULING_CHECK_INIT(3);
result_inst_3 = ActivateTask(t4);
SCHEDULING_CHECK_AND_EQUAL_INT(3,E_OK , result_inst_3);
SCHEDULING_CHECK_INIT(4);
result_inst_4 = ActivateTask(t5);
SCHEDULING_CHECK_AND_EQUAL_INT(4,E_OK , result_inst_4);
SCHEDULING_CHECK_INIT(5);
result_inst_5 = ActivateTask(t6);
SCHEDULING_CHECK_AND_EQUAL_INT(5,E_OK , result_inst_5);
SCHEDULING_CHECK_INIT(6);
result_inst_6 = ActivateTask(t7);
SCHEDULING_CHECK_AND_EQUAL_INT(6,E_OK , result_inst_6);
SCHEDULING_CHECK_INIT(7);
result_inst_7 = ActivateTask(t8);
SCHEDULING_CHECK_AND_EQUAL_INT(7,E_OK , result_inst_7);
SCHEDULING_CHECK_INIT(8);
result_inst_8 = ActivateTask(t9);
SCHEDULING_CHECK_AND_EQUAL_INT(8,E_OK , result_inst_8);
SCHEDULING_CHECK_INIT(9);
result_inst_9 = ActivateTask(t10);
SCHEDULING_CHECK_AND_EQUAL_INT(9,E_OK , result_inst_9);
SCHEDULING_CHECK_INIT(10);
result_inst_10 = ActivateTask(t11);
SCHEDULING_CHECK_AND_EQUAL_INT(10,E_OK , result_inst_10);
SCHEDULING_CHECK_INIT(11);
result_inst_11 = ActivateTask(t12);
SCHEDULING_CHECK_AND_EQUAL_INT(11,E_OK , result_inst_11);
SCHEDULING_CHECK_INIT(12);
result_inst_12 = ActivateTask(t13);
SCHEDULING_CHECK_AND_EQUAL_INT(12,E_OK , result_inst_12);
SCHEDULING_CHECK_INIT(13);
result_inst_13 = ActivateTask(t14);
SCHEDULING_CHECK_AND_EQUAL_INT(13,E_OK , result_inst_13);
SCHEDULING_CHECK_INIT(14);
result_inst_14 = ActivateTask(t15);
SCHEDULING_CHECK_AND_EQUAL_INT(14,E_OK , result_inst_14);
SCHEDULING_CHECK_INIT(15);
result_inst_15 = ActivateTask(t16);
SCHEDULING_CHECK_AND_EQUAL_INT(15,E_OK , result_inst_15);
SCHEDULING_CHECK_INIT(16);
result_inst_16 = ClearEvent(Task1_Event1);
SCHEDULING_CHECK_AND_EQUAL_INT(16,E_OK , result_inst_16);
SCHEDULING_CHECK_INIT(17);
result_inst_17 = ClearEvent(Task1_Event2);
SCHEDULING_CHECK_AND_EQUAL_INT(17,E_OK , result_inst_17);
SCHEDULING_CHECK_INIT(18);
result_inst_18 = ClearEvent(Task1_Event3);
SCHEDULING_CHECK_AND_EQUAL_INT(18,E_OK , result_inst_18);
SCHEDULING_CHECK_INIT(19);
result_inst_19 = ClearEvent(Task1_Event4);
SCHEDULING_CHECK_AND_EQUAL_INT(19,E_OK , result_inst_19);
SCHEDULING_CHECK_INIT(20);
result_inst_20 = ClearEvent(Task1_Event5);
SCHEDULING_CHECK_AND_EQUAL_INT(20,E_OK , result_inst_20);
SCHEDULING_CHECK_INIT(21);
result_inst_21 = ClearEvent(Task1_Event6);
SCHEDULING_CHECK_AND_EQUAL_INT(21,E_OK , result_inst_21);
SCHEDULING_CHECK_INIT(22);
result_inst_22 = ClearEvent(Task1_Event7);
SCHEDULING_CHECK_AND_EQUAL_INT(22,E_OK , result_inst_22);
SCHEDULING_CHECK_INIT(23);
result_inst_23 = ClearEvent(Task1_Event8);
SCHEDULING_CHECK_AND_EQUAL_INT(23,E_OK , result_inst_23);
SCHEDULING_CHECK_INIT(24);
result_inst_24 = TerminateTask();
SCHEDULING_CHECK_AND_EQUAL_INT(24,E_OK , result_inst_24);
}
