int jieshiqi___::switch__(qu___* qu,size_t& offi,size_t to,string& buf,deque<string>* eval_p){
int err;
size_t from2,to2,to4;
string buf2;
if((err=jieshi_buf__(qu,offi,to,buf,buf2,kwsm_jieheshi_|kwsm_bijiaoyunsuanfu_|kwsm_juhao_,
keyword_switch_,false,&from2,&to2,&to4)))
return err;
zhi___ zuo;
zuo=buf2;
int kw2;
try{
for(;from2<to2;){
size_t from3,to3;
if((err=find__(qu,from2,to2,kwsm_juhao_,from3,to3,kw2,buf,false)))
return err;
bool luoji;
if((err=if_then_else__(keyword_if_,qu,from3,to3,buf,zuo,luoji,eval_p)))
return err;
if(kw2>keyword_no_){
#ifdef debug_liucheng_
out_kw__(syn_[kw2]);
#endif
from2+=syn_[kw2].length();
}
if(kw2!=keyword_juhao_)
break;
}
}catch(int ex){
if(ex==keyword_break_){
}else
throw ex;
}
offi=to4;
return 0;
}
void Amt::DiagLImpl::s(CORBA::Long _l ){
DiagLImplBase::s(_l);
char *markup;
GdkColor color;
if (old_l != _l )
switch (_l){
case 0:
gdk_color_parse("red", &color);
gtk_widget_modify_bg(_lMev, GTK_STATE_NORMAL, &color );
if( crtc::ItemImpl* logger = find__("mony_logger") ){
char buff[80];
snprintf (buff, sizeof(buff), "Модуль: %s; %s", _in_modul.c_str(), _in_place.c_str() );
logger->setAttr__("type","Amt_modul_answ_fault" );
logger->setAttr__("title", buff );
}
break;
case 2:
gdk_color_parse("#00aa00", &color);
gtk_widget_modify_bg(_lMev, GTK_STATE_NORMAL, &color );
break;
case 1:
gdk_color_parse("#14BD68", &color);
gtk_widget_modify_bg(_lMev, GTK_STATE_NORMAL, &color );
break;
}
old_l = _l;
}
/*---------------------------------- Циклические телеизмерения ИЗОЛЯЦИИ ---------------------------------*/
void stdc::ControllerImpl::circleIsolIn(CORBA::Long _l){
_in_circleIsolIn = _l;
if(_l){
if (_in_debug) printf("Analog:: Циклические телеизмерения изоляции Включены.\n");
circleIn(0); //выключаем циклические измерения напряжений
circleIsolIter = _in_items.begin();
circleIsolOnItem();
}
else{
if (_in_debug) printf("Analog:: Циклические телеизмерения изоляции ВЫключены.\n");
if ( crtc::ItemImpl *cid = find__("stdc_circleIsol") ){
cid->setAttr__("stop", "1");
char ak[10];
snprintf(ak, sizeof(ak),"ak%s", circleIsolIter->second->ak );
uart->off(ak, atol(circleIsolIter->second->side) );
}
}
}
void stdc::ControllerImpl::circleViewData(){
if ( ( viewItem == _in_items.begin() ) && ( circleItem == _in_items.begin() ) )
return;
char ak[10];
snprintf(ak, sizeof(ak),"ak%s", viewItem->second->ak );
int isch = 2 * uart->getChan4Ak( ak ) + atol(viewItem->second->side);
const char* uns = uart->getUns4Ak( ak );
char buff[10];
snprintf(buff, sizeof(buff),"%s_%d", viewItem->second->source, isch );
if( crtc::ItemImpl *ii = find__(uns) ){
CORBA::Any _a;
ii->getAttr__(std::string(buff), _a);
CORBA::Double _d;
_a>>=_d;
/*сохранили значение напряжения*/
viewItem->second->value[0] = _d;
saveData();
syncData();
/*Проверим пороги, и обновим их в ТЗК*/
if (limits)
limits->checkLimit( viewItem->second->unit, _d, true );
}
void stdc::ControllerImpl::circleIsolOnItem(){
if (!_in_circleIsolIn)
return;
CORBA::Any _a;
circleIsolIter->second->sp->getAttr__("cond", _a);
CORBA::Long _l=0; _a>>=_l;
if (_l){
circleIsolNext();
return;
}
if (!circleIsolIter->second->isIsol){
circleIsolNext();
return;
}
char ak[10];
snprintf(ak, sizeof(ak),"ak%s", circleIsolIter->second->ak );
uart->uns4i_Isol( uart->getUns4Ak(ak), 1 );
uart->on(ak, atol(circleIsolIter->second->side), atol(circleIsolIter->second->key), atol(circleIsolIter->second->mode),
circleIsolIter->second->unit, (CORBA::Long)atol(circleIsolIter->second->fasa) );
if ( crtc::ItemImpl *cid = find__("stdc_circleIsol") ){
int isch = 2 * uart->getChan4Ak( ak ) + atol(circleIsolIter->second->side);
char tmp[4];
snprintf(tmp, sizeof(tmp),"%d", isch);
cid->setAttr__("isch", tmp);
cid->setAttr__("side", circleIsolIter->second->side );
cid->setAttr__("uns", uart->getUns4Ak( ak ));
cid->setAttr__("ion", uart->getIon4Ak( ak ));
cid->setAttr__("mode", circleIsolIter->second->mode);
cid->setAttr__("work", "1");
}
char tit[150];
snprintf(tit,sizeof(tit), "Объект %s подключен, измеряется изоляция.", circleIsolIter->second->label.c_str() );
if (_in_debug) printf("Analog:: %s\n",tit);
}
int jieshiqi___::if_then_else__(int kw,qu___* qu,size_t& offi,size_t to,string& buf,zhi___& zuo,bool& result,deque<string>* eval_p){
size_t from2,to2;
int kw2;
int err;
string buf2;
size_t to3=offi;
//|kwsm_if_
if((err=find__(qu,to3,to,kwsm_juhao_,from2,to2,kw2,buf2,false)))
return err;
if(kw==keyword_if_){
if((err=find__(qu,offi,to3,kwsm_juhao_|kwsm_then_else_|kwsm_douhao_,from2,to2,kw2,buf2,false)))
return err;
result=true;
if((err=and_or__(qu,from2,to2,result,zuo))){
err_add__(qu,from2,to2);
return err;
}
switch(kw2){
case keyword_then_:
case keyword_else_:
break;
default:
offi=to3;
case keyword_douhao_:
#ifdef debug_liucheng_
out_kw__(syn_[kw2],out_clr_if_);
#endif
return 0;
}
}else{
kw2=kw;
offi-=syn_[kw2].length();
}
for(;;){
unsigned long kwsm;
int kw3;
if(result){
if(kw2==keyword_then_){
kwsm=kwsm_else_|kwsm_juhao_|kwsm_douhao_;
kw3=keyword_no_;
}else{
kwsm=kwsm_then_|kwsm_juhao_;
kw3=keyword_then_;
}
}else{
if(kw2==keyword_else_){
kwsm=kwsm_juhao_|kwsm_douhao_;
kw3=keyword_no_;
}else{
kwsm=kwsm_else_|kwsm_juhao_;
kw3=keyword_else_;
}
}
if(kw2>keyword_no_){
#ifdef debug_liucheng_
out_kw__(syn_[kw2],out_clr_if_);
#endif
offi+=syn_[kw2].length();
}
if((err=find__(qu,offi,to3,kwsm,from2,to2,kw2,buf2,false)))
return err;
if(kw3==keyword_no_){
for(;;){
/*size_t from4,to4;
int kw4;
if((err=find__(qu,from2,to2,0,from4,to4,kw4,buf)))
return err;
if((err=jieshi__(qu,from4,to4,buf)))
return err;*/
if((err=jieshi__(qu,from2,to2,buf,NULL,NULL,keyword_no_,kwsm_1_,kwsm_1t_,NULL,eval_p)))
return err;
if(kw2>keyword_no_){
#ifdef debug_liucheng_
out_kw__(syn_[kw2],out_clr_if_);
#endif
offi+=syn_[kw2].length();
}
if(kw2!=keyword_douhao_)
break;
if((err=find__(qu,offi,to3,kwsm,from2,to2,kw2,buf2,false)))
return err;
}
break;
}else{
if(kw2!=kw3)
break;
}
}
offi=to3;
return 0;
}
int jieshiqi___::and_or__(qu___* qu,size_t from,size_t to,bool& result,zhi___& zuo){
#ifdef debug_liucheng_
out_f_t__(qu->src_,from,to,out_clr_if_);
#endif
const string& fei=syn_[keyword_fei_];
int fei_len=fei.length();
for(;from<to;){
size_t from2,to2;
int err;
bool jiehe=false;
err=syn_.jiehe__(qu->src_,from,to,from2,to2,&jiehe,err_);
if(err)
return err;
if(jiehe){
//这里还有先之前的一段的怎么处理
if((err=and_or__(qu,from2,to2,result,zuo)))
return err;
from=to2+syn_[keyword_jiehezhong_].length();
if(from>=to)
break;
}
int kw2;
string buf2;
if((err=find__(qu,from,to,kwsm_and_or_,from2,to2,kw2,buf2)))
return err;
if(!jiehe){
size_t from3,to3;
int yunsuanfu;
string buf3;
int fei_cnt=0;
if((err=find__(qu,from2,to2,kwsm_bijiaoyunsuanfu_,from3,to3,yunsuanfu,buf3)))
return err;
if(to3>from3){
for(size_t i=from3;i<to3-fei_len;i+=fei_len){
if(qu->src_.compare(i,fei_len,fei)==0){
fei_cnt++;
}else
break;
}
if((err=jieshi__(qu,from3,to3,buf3,NULL,NULL,keyword_no_,kwsm_1_|kwsm_has_)))
return err;
zuo=buf3;
}
#ifdef debug_liucheng_
out_if__(zuo);
#endif
switch(yunsuanfu){
case keyword_dengyu_:
case keyword_budengyu_:
case keyword_xiaoyudengyu_:
case keyword_xiaoyu_:
case keyword_dayudengyu_:
case keyword_dayu_:
break;
default:
if(yunsuanfu>keyword_no_){
to3+=syn_[yunsuanfu].length();
yunsuanfu=keyword_no_;
}
break;
}
if(yunsuanfu>keyword_no_){
#ifdef debug_liucheng_
out_kw__(syn_[yunsuanfu],out_clr_if_);
#endif
to3+=syn_[yunsuanfu].length();
string buf4;
if((err=jieshi__(qu,to3,to2,buf4,NULL,NULL,keyword_no_,kwsm_1_|kwsm_has_)))
return err;
zhi___ you;
you=buf4;
#ifdef debug_liucheng_
out_if__(you);
#endif
switch(yunsuanfu){
case keyword_dengyu_:
result = zuo==you;
break;
case keyword_budengyu_:
result = zuo!=you;
break;
case keyword_xiaoyudengyu_:
result = zuo<=you;
break;
case keyword_xiaoyu_:
result = zuo<you;
break;
case keyword_dayudengyu_:
result = zuo>=you;
break;
case keyword_dayu_:
result = zuo>you;
break;
}
}else
result=zuo.bool__(syn_[keyword_null_],fei_cnt,fei_len);
}
#ifdef debug_liucheng_
out_if__(result?"正":"歪",out_clr_x_);
#endif
if((!result&&kw2==keyword_and_)||(result&&kw2==keyword_or_))
break;
from=to2;
if(kw2>keyword_no_){
#ifdef debug_liucheng_
out_kw__(syn_[kw2],out_clr_if_);
#endif
from+=syn_[kw2].length();
}
}
return 0;
}
void Amt::ObjConnImpl::dataCells(const char* _id){
_dataCells.push_back( find__(_id ) );
// printf("Amt::ObjConnImpl::dataCells new Id %s\n", _id);
}
void stdc::ControllerImpl::applyAttrs(){
crtc::ItemNode::applyAttrs();
// stage two activation ( after dom tree building done )
//Находим УАРТ который рулит модулями
if( uart = static_cast<stdc::UartImpl*>( find__("uart")) ){
;
}
else{
crtcLog<<"stdc::Controller !! Ошибка адаптации не найден УАРТ (stdc:Uart)\n";
crtcEXIT("Критическая ошибка");
}
//Найдем объект с порогами на значения
limits = dynamic_cast<stdc::Ilimits*>(find__("stdc_limits"));
if (!limits)
crtcLog<<"stdc::Controller !! Не найден компонент с пороговыми значениями (<stdc:Limits id='stdc_limits' ... >)\n";
//Создаем список объектов ТИ
//Подписываем себя на события от SectionProxy
std::list<crtc::ItemImpl*> iis;
long rc = _cntx_->registry()->getItems( "*", iis );
std::list<crtc::ItemImpl*>::iterator beg = iis.begin();
std::list<crtc::ItemImpl*>::iterator end = iis.end();
while (beg != end ){
std::string _repo = static_cast<crtc::ItemImpl*>(*beg)->getRepo__();
if (_repo == "IDL:stdc/SectionProxy:1.0" ){
crtc::ItemImpl *ss = 0;
ss =find__( (*beg)->getId__() );
if (ss){
ss -> subs__("popup", this);
//Создаем список объектов телеизмерений
crtc::ItemNode* sectProxy = 0;
sectProxy = ss;
const char* _sectionId;
if (sectProxy->hasAttribute("sectionId"))
_sectionId = sectProxy->getAttributeText("sectionId");
else{
crtcLog<<"stdc::Controller::Error отсутствует аттрибут sectionId\n";
crtcEXIT("Критическая ошибка");
}
if (sectProxy){
crtc::ItemNode *points = sectProxy->firstChild;
while (points ){
const char *unit, *ak, *side, *key, *mode, *fasa, *subtitle, *label, *source;
if (points->hasAttribute("unit")){
unit = points->getAttributeText("unit");
if (points->hasAttribute("ak"))
ak = points->getAttributeText("ak");
else{
crtcLog<<"stdc::SectionProxy::Error в потомке "<<_sectionId<<" отсутвует аттрибут ak="". Номер модуля АК\n";
crtcEXIT("Критическая ошибка");
}
if (points->hasAttribute("side"))
side = points->getAttributeText("side");
else{
crtcLog<<"stdc::SectionProxy::Error в потомке "<<_sectionId<<" отсутвует аттрибут side="". Сторона мадуля АК.\n";
crtcEXIT("Критическая ошибка");
}
if (points->hasAttribute("key"))
key = points->getAttributeText("key");
else{
crtcLog<<"stdc::SectionProxy::Error в потомке "<<_sectionId<<" отсутвует аттрибут key="". Номер ключа\n";
crtcEXIT("Критическая ошибка");
}
if (points->hasAttribute("mode"))
mode = points->getAttributeText("mode");
else{
crtcLog<<"stdc::SectionProxy::Error в потомке "<<_sectionId<<" отсутвует аттрибут mode="". Режим работы ключа\n";
crtcEXIT("Критическая ошибка");
}
if (points->hasAttribute("subtitle"))
subtitle = points->getAttributeText("subtitle");
else{
crtcLog<<"stdc::SectionProxy::Error в потомке "<<_sectionId<<" отсутвует аттрибут subtite="". Название точки подключения.\n";
crtcEXIT("Критическая ошибка");
}
//необязательные атрибуты
if (points->hasAttribute("Phdop"))
fasa = points->getAttributeText("Phdop");
else
fasa ="";
if (points->hasAttribute("source"))
source = points->getAttributeText("source");
else
source ="VAC";
//создаем элемент в таблице объектов измерения
char buff[200];
if (std::string(ss->getId__()).find("Section") != std::string::npos )
snprintf(buff, sizeof(buff), "%sСП %s", _sectionId, subtitle);
else if (std::string(ss->getId__()).find("Way") != std::string::npos )
snprintf(buff, sizeof(buff), "%sП %s", _sectionId, subtitle);
else
snprintf(buff, sizeof(buff), "%s %s", _sectionId, subtitle);
//выясняем есть ли по этому объекту измерение изоляции
bool isIsol=0;
char ak_name[7];
snprintf(ak_name, sizeof(ak_name),"ak%s", ak );
if (strcmp("none", uart->getIon4Ak( ak_name )))
isIsol = 1;
_in_items[std::string(unit) ] = new stdItem(ak, side, key, mode, unit, fasa, buff, ss, isIsol, source );
}
points = points->nextSibling;
}
}
}
}
beg++;
}
//check...
if (_in_items.size() == 0 )
crtcEXIT ("Мега ошибка. Нету объектов измерения.\n Проверте: 1. Адаптацию 2. Собраны ли модули stdc::SectionProxy или stdc::IsolUnit");
//for test
if (_in_debug){
std::cout<<"Известные объекты телеизмерений _in_items:\n";
StdItems::iterator begin = _in_items.begin();
StdItems::iterator end1 = _in_items.end();
while(begin!=end1){
std::cout<<begin->first.c_str();
std::cout<<" ak="<<begin->second->ak<<" side="<<begin->second->side<<" key="<<begin->second->key<<" mode="<<begin->second->mode;
std::cout<<" unit='"<<begin->second->unit<<"' fasa="<<begin->second->fasa<<" title='"<<begin->second->label.c_str()<<"' isIsol= '"<<begin->second->isIsol<<"'\n";
begin++;
}
}
//Подготовка для циклических измерений.
if (_in_voltMeasureDelay < 3)
_in_voltMeasureDelay == 3;
registerForPoll__(_in_voltMeasureDelay);
registerForStep__();
circleItem = _in_items.begin();
viewItem = _in_items.begin();
circleIsolIter = _in_items.begin();
createTZK();
readData();
//for syncAnalogData
if ( _in_syncPort ) prepareSync();
//start circle diment
circleIn(1);
}
