/*
功能：从设备驱动中更新并得到实时值
参数：
tag 更新的标签结构体，包含更新实时值所需要的配置信息[in]
new_value 实时值指针，用于存储更新所得到的实时值[in, out]
now 更新时间[in]
返回：
1 成功
0 tag中动态属性的设备信息丢失
或 tag中动态属性设备信息的驱动信息丢失
或 tag中驱动信息中的更新tag的导出函数丢失
*/
IO_API __bool PMC_API io_update_tag(
PCRTK_TAG tag,
Ppmc_value_t new_value,
PCRTK_TIME now
)
{
PDRIVER_INFO drv;
//1 设置新实时值的Flags
new_value->Flags = 0;
set_value_type(new_value->Flags, get_value_type(tag->s.Flags));
//2 将实时值的union清0，u64是union中的最大元素，即可表示union的大小
/*
pre-set all unused bytes to zero, this will make it easier to
write code depending on the tag types
*/
new_value->Value.u64 = 0;
// assert(tag->d.DeviceObj == io_open_device(&tag->s.Device));
//3 从标签的动态属性中得到设备驱动信息的结构体
if(!tag->d.DeviceObj){
return __false;
}
drv = ((PDEVICE_INFO)tag->d.DeviceObj)->d;
if(!drv){
return __false;
}
//4 调用设备驱动DLL的导出函数更新实时值
if(!drv->update_tag){
return __false;
}
if(drv->update_tag){
drv->update_tag(tag, new_value, now);
}
//5 某些设备驱动可能会重写实时值的类型标识，需要再用标签静态属性中的类型标识设置一下
// some ill-behavioured driver will overwrite the type field
set_value_type(new_value->Flags, get_value_type(tag->s.Flags));
//6 若静态属性配置为开关量，则将true转化为1，false转化为0
if(get_value_type(tag->s.Flags) == dt_bool){
/* make digital variable cannonical */
new_value->Value.b = new_value->Value.b? 1 : 0;
}
return __true;
}
void CMcviewDlg::doAutoPopup()
{
// 2004/5/30, auto-popups
do{
__uint i;
static bool bPopupInited;
CAutoPopup::popupEntry_t * ent;
if(!bPopupInited){
autoPopups.init();
bPopupInited = true;
}
ent = autoPopups.entries;
if(!lock_rtdb(__false, 1000)){
break;
}
for(i=0; i<autoPopups.nEntries; i++, ent++){
//
PCRTK_TAG tag;
bool bPopup;
tag = query_tag_f(&ent->tn);
if(!tag){
continue;
}
if(get_value_type(tag->s.Flags) != dt_bool){
continue;
}
bPopup = tag->d.Value.Value.b? true : false;
if(!(ent->flags & popupWhenVariableIsOn)){
bPopup = !bPopup;
}
if(bPopup){
if(ent->flags & popupOverlay){
theView.LoadFile(ent->associatedPicture);
}else{
PopupView(ent->associatedPicture);
}
}else{
if((ent->flags & popupAutoHide) && !(ent->flags & popupOverlay)){
CFView * view;
view = FindView(ent->associatedPicture);
if(view){
view->CloseWindow();
}
}
}
}
unlock_rtdb();
}while(0);
}
PROXY_API __uint PMC_API proxy_write_tags_ex(
__uint count,
PCTAG_NAME names,
PCpmc_value_t values
)
{
__uint i;
__uint j;
__uint ok;
CWriteTagTransaction2 * tr;
ok = 0;
for(i=0; i<count; i++, names++, values++) {
switch(get_value_type(values->Flags)) {
case dt_bool:
case dt_int8:
case dt_int16:
case dt_int32:
case dt_int64:
case dt_uint64:
case dt_uint8:
case dt_uint16:
case dt_uint32:
case dt_real4:
case dt_real8:
tr = new CWriteTagTransaction2();
if(!tr) {
continue;
}
for(j=0; j<3; j++) {
tr->life = 10;
if(tr->Query(names, values, 1000)) {
ok++;
break;
}
rtk_sleep(200);
}
break;
default:
// non-numeric types cannot be written
;
}
}
return ok;
}
RTDB_API RTK_CURSOR PMC_API create_tag(
RTK_CURSOR group,
PCTAG_KEY tag,
PCSTATIC_TAG_DATA sd
)
{
RTK_CURSOR handle;
RTK_GROUP * grp;
RTK_TAG t;
handle = open_tag_g(group, tag);
if(handle){
return handle;
}
if(g_dwTags >= g_dwMaxTags){
rtk_set_last_error(RTDB_HARD_CONSTRAINTS);
return 0;
}
grp = (RTK_GROUP*)cursor_get_item(group);
if(!grp){
return 0;
}
ZeroMemory(&t, sizeof(t));
t.key = *tag;
make_unified_key(t.key);
t.s = *sd;
t.node = grp->node;
t.group = grp->key;
handle = (RTK_CURSOR)_HTAG::create((TAG_TABLE*)grp->itemtable, t.key, t);
RTK_TAG * pTag = (RTK_TAG*)cursor_get_item(handle);
if(pTag){
ZeroMemory(&pTag->d, sizeof(pTag->d));
set_value_type(pTag->d.Value.Flags, get_value_type(pTag->s.Flags));
RtkInitializeListHead(&pTag->d.DeviceLink);
RtkInitializeListHead(&pTag->d.RefreshLink);
FIRE_EVENT(OnAddTag, (pTag));
g_dwTags++;
}
return handle;
}
static __r8 _getSpan(PCRTK_TAG t)
{
switch(get_value_type(t->s.Flags)){
case dt_real4:
case dt_real8:
return t->s.u_max.flt - t->s.u_min.flt;
case dt_date:
return 0;
case dt_int8:
case dt_int16:
case dt_int32:
case dt_uint8:
case dt_uint16:
case dt_uint32:
return t->s.u_max.i - t->s.u_min.i;
}
return 0;
}
/*
功能：将TAG_VALUE实时值写入设备。
参数：
name 待写入实时值对应的 组名.标签名
value 待写入的实时值
返回：即设备驱动导出函数write_device()的返回值
*/
IO_API __bool PMC_API io_write_device(
PCSHORT_TAG_NAME name,
PCTAG_VALUE value
)
{
__bool retval = __false;
//1 锁定
if(!lock_rtdb(__false, 100)){
return __false;
}
//2 找到本地节点中的指定标签点的RTK_TAG，其中存有该标签点对应的设备信息
PRTK_TAG p = query_tag(HNODE_LOCAL_MACHINE, name);
//3 将单点单实时值写入设备
if(p && !(p->d.Value.Flags & TF_ReadOnly)){
#if 0
{
char valbuf[32];
if(get_value_type(p->s.Flags) == dt_real4){
sprintf(valbuf, "%f", value->fltValue);
}else{
sprintf(valbuf, "%s", value->iValue? "On" : "Off");
}
utils_debug(
"WriteDevice(%s.%s)=%s\n",
(char *)CGroupName(name->group),
(char *)CTagName(name->tag),
valbuf
);
}
#endif
//调用设备驱动导出函数，将单点单实时值写入设备
retval = _writeDevice(p, value);
}
//4 解锁
unlock_rtdb();
return retval;
}
/*
功能：将pmc_value_t实时值写入设备
参数：
name 待写入实时值对应的 组名.标签名
value 待写入的实时值
返回：即设备驱动导出函数write_device()的返回值
*/
IO_API __bool PMC_API io_write_device_ex(
PCSHORT_TAG_NAME name,
PCpmc_value_t value
)
{
pmc_value_t value2;
__bool retval = __false;
if(!lock_rtdb(__false, 100)){
return __false;
}
PRTK_TAG p = query_tag(HNODE_LOCAL_MACHINE, name);
if(p && !(p->d.Value.Flags & TF_ReadOnly)){
ZeroMemory(&value2, sizeof(value2));
set_value_type(value2.Flags, get_value_type(p->s.Flags));
if(pmc_type_cast(value, &value2)){
retval = _writeDevice(p, &value2.Value);
}
}
unlock_rtdb();
return retval;
}
static int add_field(HTable table, char *name, char *value, char *buf, long int *pos)
{
int value_type;
char *s;
HTable tbl;
value_type = get_value_type(value);
switch (value_type)
{
case TYPE_INT:
table_set_int(table, name, atoi(value));
break;
case TYPE_STRING:
s = unescape_string(value);
if (! s)
return -1;
table_set_str(table, name, s);
free(s);
break;
case TYPE_FLOAT:
table_set_double(table, name, atof(value));
break;
case TYPE_TABLE:
tbl = table_create();
if (table_set_table(table, name, tbl))
{
table_free(tbl);
return -1;
}
if (parse_table(tbl, buf, pos, 0))
return -1;
break;
default:
return -1;
}
return 0;
}
/*
addTag()
insert a tag into the logging stream list.
caller must have rtdb locked.
*/
bool CInMemoryBuffer::addTag(PCTAG_NAME name)
{
CHislogStream * str;
hislog_stream_list::iterator it;
pair<hislog_stream_list::iterator,bool> pib;
PCRTK_TAG p;
it = m_streams.find(*name);
if(it != m_streams.end()){
// already logged, reset the pending-deletion flag
it->second->m_deletePending = false;
return true;
}
p = query_tag_f(name);
if(!p){
return false;
}
str = new CHislogStream(this);
if(!str){
return false;
}
str->m_type = get_value_type(p->s.Flags);
str->m_name = *name;
str->m_color = rng_rand(0, hislogRecordColors);
pib = m_streams.insert(hislog_stream_list::value_type(*name, str));
if(!pib.second){
delete str;
return false;
}
return true;
}
void CHislogStream::linearCompress(
hislog_key_t time,
const hislog_item_t * snapShot,
__uint compMax,
__r8 compDev,
__bool & bSave,
__bool & bReplace
)
{
__r8 dev, dev2;
//hislog_item_t v;
/*
linear compressing
*/
bReplace = __true;
/*
interpolate(
&m_recentValues[0].value,
snapShot,
&v,
m_recentValues[0].time,
time,
m_recentValues[1].time
);
*/
if((snapShot->Flags & TF_Valid) != (m_recentValues[1].value.Flags & TF_Valid)) {
bSave = __true;
bReplace = __false;
return;
}
switch(get_value_type(snapShot->Flags)) {
case dt_bool:
//if(!(m_recentValues[1].value.Value.b ^ snapShot->Value.b)
// &&
//!(m_recentValues[0].value.Value.b ^ snapShot->Value.b)
//){
if(m_recentValues[0].value.Value.b == snapShot->Value.b
&& m_recentValues[0].value.Value.b == m_recentValues[1].value.Value.b
) {
bSave = __false;
bReplace = __true;
} else {
bSave = __true;
bReplace = __false;
}
return;
break;
case dt_real4:
//dev = fabs(v.Value.fltValue - m_recentValues[1].value.Value.fltValue);
//dev2 = fabs(v.Value.fltValue - m_recentValues[0].value.Value.fltValue);
dev = snapShot->Value.fltValue - m_recentValues[1].value.Value.fltValue;
dev2 = m_recentValues[1].value.Value.fltValue - m_recentValues[0].value.Value.fltValue;
break;
case dt_real8:
case dt_date:
//dev = fabs(v.Value.dblValue - m_recentValues[1].value.Value.dblValue);
//dev2 = fabs(v.Value.dblValue - m_recentValues[0].value.Value.dblValue);
dev = snapShot->Value.dblValue - m_recentValues[1].value.Value.dblValue;
dev2 = m_recentValues[1].value.Value.dblValue - m_recentValues[0].value.Value.dblValue;
break;
case dt_int8:
case dt_int16:
case dt_int32:
//dev = abs(v.Value.i32 - m_recentValues[1].value.Value.i32);
//dev2 = abs(v.Value.i32 - m_recentValues[0].value.Value.i32);
dev = snapShot->Value.i32 - m_recentValues[1].value.Value.i32;
dev2 = m_recentValues[1].value.Value.i32 - m_recentValues[0].value.Value.i32;
break;
case dt_uint8:
case dt_uint16:
case dt_uint32:
//dev = abs(v.Value.u32 - m_recentValues[1].value.Value.u32);
//dev2 = abs(v.Value.u32 - m_recentValues[0].value.Value.u32);
dev = snapShot->Value.u32 - m_recentValues[1].value.Value.u32;
dev2 = m_recentValues[1].value.Value.u32 - m_recentValues[0].value.Value.u32;
break;
default:
/* we dont provide compressing for other types for now */
return;
}
if((dev*dev2) < 0 || fabs(dev) > compDev || fabs(dev2) > compDev) {
bSave = __true;
bReplace = __false;
} else {
bSave = __false;
bReplace = __true;
}
//if(dev2 > compDev){
// bSave = __true;
// bReplace = __false;
//}else if(dev < compDev){
// bSave = __false;
// bReplace = __true;
//}
}
/*
Load data from storage to UI
*/
void __fastcall TframTag::UpdateView()
{
//TODO: Add your source code here
TComponent * comp;
int i;
PTAG_NAME name = &m_TagName;
// update static information
PRTK_TAG pTag = &m_Tag;
char textname[TAGNAME_TEXT_LENGTH + 1];
char buf[64];
// temporarily disable unapplicable components
tsException->TabVisible = false;
btnWriteDevice->Enabled = (pTag->d.Value.Flags & TF_ReadOnly)? false : true;
// now we update the UI to reflect the tag configuration
/*
0 开关量
1 模拟量
2 高精度模拟量
3 8位整数
4 16位整数
5 32位整数
6 64位整数
7 无符号8位整数
8 无符号16位整数
9 无符号32位整数
10 无符号64位整数
11 日期
*/
cmbType->OnChange = NULL;
switch(get_value_type(pTag->s.Flags)){
case dt_bool:
cmbType->ItemIndex = 0;
break;
case dt_real4:
cmbType->ItemIndex = 1;
break;
case dt_real8:
cmbType->ItemIndex = 2;
break;
case dt_int8:
cmbType->ItemIndex = 3;
break;
case dt_int16:
cmbType->ItemIndex = 4;
break;
case dt_int32:
cmbType->ItemIndex = 5;
break;
case dt_int64:
cmbType->ItemIndex = 6;
break;
case dt_uint8:
cmbType->ItemIndex = 7;
break;
case dt_uint16:
cmbType->ItemIndex = 8;
break;
case dt_uint32:
cmbType->ItemIndex = 9;
break;
case dt_uint64:
cmbType->ItemIndex = 10;
break;
case dt_date:
cmbType->ItemIndex = 11;
break;
default:
cmbType->ItemIndex = 12;
break;
}
cmbType->OnChange = cmbTypeChange;
{
cmbDevice->Ctl3D = false;
CDeviceItems * ditems;
AnsiString Url;
Url = (char*)CNodeName(name->node);
Url += ".DEVICES";
ditems = dynamic_cast<CDeviceItems*>(g_DCS.Search(Url));
if(ditems){
if(!ditems->m_iRefreshCount){
ditems->Refresh();
}
}
cmbDevice->Items->Clear();
cmbDevice->Text = "";
if(ditems){
CDeviceItem * ditem;
ditem = dynamic_cast<CDeviceItem*>(ditems->GetFirstChild());
while(ditem){
cmbDevice->Items->Add((char*)CDeviceName(ditem->info.k));
ditem = dynamic_cast<CDeviceItem*>(ditems->GetNextChild(ditem));
}
}
}
{
PRTK_GROUP pgrp;
RTK_CURSOR hgrp;
hgrp = open_group_f(&name->node, &name->sname.group);
pgrp = (PRTK_GROUP)cursor_get_item(hgrp);
if(pgrp){
if(pgrp->period > 50){
tmrUpdater->Interval = pgrp->period;
}
}
close_handle(hgrp);
}
edtTagName->Text = (char *)CTagName(name->sname.tag);
edtCName->Text = pTag->s.Description;
edtAddr->Text = pTag->s.Address;
cmbDevice->Text = (char*)CDeviceName(pTag->s.Device);
#define cc(name) \
do{ if(pTag->s.Flags & TF_##name){\
chk##name->Checked = true;\
}else{\
chk##name->Checked = false;\
}\
}while(0)
cc(HiHi);
cc(Lo);
cc(Hi);
cc(LoLo);
cc(On2Off);
cc(Off2On);
cc(Rate);
cc(SaveToHistory);
cc(Step);
/*
// cutoff is obsolete
#define dd(name) chk##name->Checked = pTag->s.CutOffMask & TF_##name ? true : false;
dd(HiHi);
dd(Lo);
dd(Hi);
dd(LoLo);
dd(On2Off);
dd(Off2On);
*/
if(pTag->s.Flags & TF_System){
cmbDevice->Enabled = false;
edtAddr->ReadOnly = true;
cmbType->Enabled = false;
cmbDevice->Color = clScrollBar;
edtAddr->Color = clScrollBar;
cmbType->Color = clScrollBar;
}else{
cmbDevice->Enabled = true;
edtAddr->ReadOnly = false;
cmbType->Enabled = true;
cmbType->Color = clWindow;
cmbDevice->Color = clWindow;
edtAddr->Color = clWindow;
}
switch(get_value_type(pTag->s.Flags)){
case dt_real4:
case dt_real8:
case dt_int64:
case dt_uint64:
#define aa(f) sprintf(buf, "%g", pTag->s.flt##f);edt##f->Text = buf;
aa(HiHi);
aa(Hi);
aa(Lo);
aa(LoLo);
aa(AlarmDeadband);
aa(MaxValue);
aa(MinValue);
aa(Rate);
edtEU->Text = pTag->s.AnalogMsg.EU;
tsAnalog->TabVisible = true;
tsLogical->TabVisible = false;
break;
case dt_int8:
case dt_int16:
case dt_int32:
case dt_uint8:
case dt_uint16:
case dt_uint32:
aa(AlarmDeadband);
aa(Rate);
#undef aa
#define aa(v, name) \
sprintf(buf, "%d", pTag->s.v);\
edt##name->Text = buf;
aa(u_hihi.i, HiHi);
aa(u_hi.i, Hi);
aa(u_lo.i, Lo);
aa(u_lolo.i, LoLo);
aa(u_max.i, MaxValue);
aa(u_min.i, MinValue);
edtEU->Text = pTag->s.AnalogMsg.EU;
tsAnalog->TabVisible = true;
tsLogical->TabVisible = false;
break;
case dt_date:
tsArchive->TabVisible = true;
tsAnalog->TabVisible = false;
tsLogical->TabVisible = false;
break;
case dt_bool:
edtOnMessage->Text = pTag->s.SwitchMsg.OnMsg;
edtOffMessage->Text = pTag->s.SwitchMsg.OffMsg;
tsLogical->TabVisible = true;
tsAnalog->TabVisible = false;
default:
assert(0);
break;
}
tsAnalog->Visible = tsAnalog->TabVisible;
tsLogical->Visible = tsLogical->TabVisible;
tsException->Visible = tsException->TabVisible;
tsArchive->Visible = tsArchive->TabVisible;
edtAlarmRank->Text = pTag->s.AlarmRank;
edtAlarmRank2->Text = pTag->s.AlarmRank;
chkCompressing->Checked = true;
edtCompMax->Enabled = chkCompressing->Checked;
edtCompDev->Enabled = chkCompressing->Checked;
edtCompDevPercent->Enabled = chkCompressing->Checked;
edtCompMax->Text = IntToStr(pTag->s.CompMax);
edtCompDev->Text = FloatToStr(pTag->s.CompDev);
__r8 span = _getSpan(pTag);
if(span > 1e-5){
edtCompDevPercent->Text = FloatToStr(pTag->s.CompDev / span * 100);
}
TAG_NAME ctn;
ZeroMemory(&ctn, sizeof(ctn));
ctn.sname = pTag->s.CutOffTagName;
tagname_to_text(&ctn, textname, sizeof(textname));
// debugging output
{
char nn[128];
*nn=0;
#define __check_field__(field,name) \
if(pTag->d.Value.Flags & TF_##field) {\
if(*nn) {\
strcat(nn,"+");\
strcat(nn,#name);\
}else{\
strcpy(nn,#name);\
}\
}
__check_field__(HiHi,h2)
__check_field__(Hi,h)
__check_field__(LoLo,l2)
__check_field__(Lo,l)
__check_field__(Rate,r)
__check_field__(On2Off,off)
__check_field__(Off2On,on)
__check_field__(Alarm,alarm)
__check_field__(Expired,expired)
__check_field__(SharpChange,sharp)
__check_field__(ReadOnly,read)
__check_field__(Translated,trans)
__check_field__(ConfigOk,ok)
__check_field__(Valid,valid)
utils_debug("%s flags=0x%08x,%s\n", textname, pTag->d.Value.Flags, nn);
#undef __check_field__
}
// pg->Clear();
}
/*
gather data from UI to internal representation
*/
bool TframTag::ValidateView()
{
PTAG_NAME name;
PRTK_TAG tag;
name = &m_TagName;
tag = &m_Tag;
try{
#undef cc
#define cc(name) tag->s.Flags |= (chk##name->Checked ? TF_##name : 0);
if( edtTagName->Text.Length() >sizeof(TAG_KEY) ||
!edtTagName->Text.Length()
){
m_Hint = "变量名不正确";
throw(-1);
}
if( !is_valid_name(edtTagName->Text.c_str()) ){
m_Hint = "变量名只能包含字母、数字和下划线";
throw(-3);
}
if(edtTagName->Text.Length() > sizeof(TAG_KEY)){
m_Hint = AnsiString("错误: 标签名不能超过 ") + IntToStr(sizeof(TAG_KEY)) + " 个字节";
throw(-3);
}
name->sname.tag = CTagName(edtTagName->Text.c_str());
tag->s.Device = CDeviceName(cmbDevice->Text.c_str());
tag->key = name->sname.tag;
if(edtCName->Text.Length() > sizeof(tag->s.Description)){
m_Hint = "中文名太长(最长 " + AnsiString(sizeof(tag->s.Description)/2) + " 字)";
throw(-4);
}
strncpy(tag->s.Description, edtCName->Text.c_str(), sizeof(tag->s.Description));
tag->s.Description[sizeof(tag->s.Description) - 1] = 0;
if(edtAddr->Text.Length() > sizeof(tag->s.Address)){
m_Hint = "地址太长(最长 " + AnsiString(sizeof(tag->s.Address)/2) + " 字)";
throw(-5);
}
strncpy(tag->s.Address, edtAddr->Text.c_str(), sizeof(tag->s.Address));
tag->s.Address[sizeof(tag->s.Address) - 1] = 0;
tag->s.Flags = 0;
switch(cmbType->ItemIndex){
case 0:
set_value_type(tag->s.Flags, dt_bool);
break;
case 1:
set_value_type(tag->s.Flags, dt_real4);
break;
case 2:
set_value_type(tag->s.Flags, dt_real8);
break;
case 3:
set_value_type(tag->s.Flags, dt_int8);
break;
case 4:
set_value_type(tag->s.Flags, dt_int16);
break;
case 5:
set_value_type(tag->s.Flags, dt_int32);
break;
case 6:
set_value_type(tag->s.Flags, dt_int64);
break;
case 7:
set_value_type(tag->s.Flags, dt_uint8);
break;
case 8:
set_value_type(tag->s.Flags, dt_uint16);
break;
case 9:
set_value_type(tag->s.Flags, dt_uint32);
break;
case 10:
set_value_type(tag->s.Flags, dt_uint64);
break;
case 11:
set_value_type(tag->s.Flags, dt_date);
break;
case 12:
m_Hint = "不支持这个数据类型.";
throw(-41);
break;
}
cc(SaveToHistory);
cc(Step);
// collecting common analog attributes
switch(get_value_type(tag->s.Flags)){
case dt_int8:
case dt_int16:
case dt_int32:
case dt_int64:
case dt_uint8:
case dt_uint16:
case dt_uint32:
case dt_uint64:
case dt_real4:
case dt_real8:
case dt_date:
cc(HiHi);
cc(Lo);
cc(Hi);
cc(LoLo);
cc(Rate);
strncpy(
tag->s.AnalogMsg.EU,
edtEU->Text.c_str(),
sizeof(tag->s.AnalogMsg.EU)
);
tag->s.AnalogMsg.EU[sizeof(tag->s.AnalogMsg.EU) - 1] = 0;
break;
case dt_bool:
cc(On2Off);
cc(Off2On);
strncpy(
tag->s.SwitchMsg.OnMsg,
edtOnMessage->Text.c_str(),
sizeof(tag->s.SwitchMsg.OnMsg)
);
tag->s.SwitchMsg.OnMsg[sizeof(tag->s.SwitchMsg.OnMsg) - 1] = 0;
strncpy(
tag->s.SwitchMsg.OffMsg,
edtOffMessage->Text.c_str(),
sizeof(tag->s.SwitchMsg.OffMsg)
);
tag->s.SwitchMsg.OffMsg[sizeof(tag->s.SwitchMsg.OffMsg) - 1] = 0;
break;
}
#define get(msg, name, ignore_on_condition, _default_value)\
m_Hint = msg;\
if( !edt##name->Text.Length() ){\
if(ignore_on_condition){\
tag->s.flt##name = _default_value;\
}else{\
throw(-1);\
}\
}else{\
tag->s.flt##name = edt##name->Text.ToDouble();\
}
#pragma warn -ccc
#pragma warn -rch
switch(get_value_type(tag->s.Flags)){
case dt_real4:
case dt_real8:
get("高高值不正确", HiHi, !chkHiHi->Checked, 0);
get("低低值不正确", LoLo, !chkLoLo->Checked, 0);
get("低值不正确", Lo, !chkLo->Checked, 0);
get("高值不正确", Hi, !chkHi->Checked, 0);
get("报警死区值不正确", AlarmDeadband, !(tag->s.Flags & 0xffffff00), 0);
get("最大值不正确", MaxValue, false, 0);
get("最小值不正确", MinValue, false, 0);
get("速率报警阈值不正确", Rate, !chkRate->Checked, 0.1);
break;
case dt_int8:
case dt_int16:
case dt_int32:
case dt_int64:
case dt_uint8:
case dt_uint16:
case dt_uint32:
case dt_uint64:
get("速率报警阈值不正确", Rate, !chkRate->Checked, 0.1);
#undef get
#define get(msg, attrName, uiName, ignore_on_condition, _default_value)\
m_Hint = msg;\
if( !edt##uiName->Text.Length() ){\
if(ignore_on_condition){\
tag->s.##attrName = _default_value;\
}else{\
throw(-1);\
}\
}else{\
tag->s.attrName = edt##uiName->Text.ToDouble();\
}
get("高高值不正确", u_hihi.i, HiHi, !chkHiHi->Checked, 0);
get("低低值不正确", u_lolo.i, LoLo, !chkLoLo->Checked, 0);
get("低值不正确", u_lo.i, Lo, !chkLo->Checked, 0);
get("高值不正确", u_hi.i, Hi, !chkHi->Checked, 0);
get("报警死区值不正确", u_deadband.i, AlarmDeadband, !(tag->s.Flags & 0xffffff00), 0);
get("最大值不正确", u_max.i, MaxValue, false, 0);
get("最小值不正确", u_min.i, MinValue, false, 0);
break;
}
#pragma warn .ccc
#pragma warn .rch
if(get_value_type(tag->s.Flags) == dt_bool){
tag->s.AlarmRank = edtAlarmRank2->Text.ToInt();
}else{
tag->s.AlarmRank = edtAlarmRank->Text.ToInt();
}
tag->s.Compressing = Compress_Const;
tag->s.CompDev = StrToFloat(edtCompDev->Text);
tag->s.CompMax = StrToInt(edtCompMax->Text);
}catch(...){
return false;
}
m_Hint = "更新成功";
return true;
}
static void _sql(Request& r, MethodParams& params) {
Value& statement=params.as_junction(0, "statement must be code");
HashStringValue* bind=0;
ulong limit=SQL_NO_LIMIT;
ulong offset=0;
bool distinct=false;
Table2hash_value_type value_type=C_HASH;
if(params.count()>1)
if(HashStringValue* options=params.as_hash(1, "sql options")) {
int valid_options=0;
if(Value* vbind=options->get(sql_bind_name)) {
valid_options++;
bind=vbind->get_hash();
}
if(Value* vlimit=options->get(sql_limit_name)) {
valid_options++;
limit=(ulong)r.process_to_value(*vlimit).as_double();
}
if(Value* voffset=options->get(sql_offset_name)) {
valid_options++;
offset=(ulong)r.process_to_value(*voffset).as_double();
}
if(Value* vdistinct=options->get(sql_distinct_name)) {
valid_options++;
distinct=r.process_to_value(*vdistinct).as_bool();
}
if(Value* vvalue_type=options->get(sql_value_type_name)) {
valid_options++;
value_type=get_value_type(r.process_to_value(*vvalue_type));
}
if(valid_options!=options->count())
throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
}
SQL_Driver::Placeholder* placeholders=0;
uint placeholders_count=0;
if(bind)
placeholders_count=marshal_binds(*bind, placeholders);
Temp_lang temp_lang(r, String::L_SQL);
const String& statement_string=r.process_to_string(statement);
const char* statement_cstr=statement_string.untaint_cstr(r.flang, r.connection());
HashStringValue& hash=GET_SELF(r, VHash).hash();
hash.clear();
Hash_sql_event_handlers handlers(
statement_string, statement_cstr,
distinct,
hash,
value_type);
r.connection()->query(
statement_cstr,
placeholders_count, placeholders,
offset, limit,
handlers,
statement_string);
if(bind)
unmarshal_bind_updates(*bind, placeholders_count, placeholders);
}
