OpcUaCanOpen
CANopen OPC-UA server
UaCanNodeObject.cpp
Go to the documentation of this file.
1 #include "CanBusInterface.h"
2 #include "UaCanNodeObject.h"
3 #include "NmBuildingAutomation.h"
4 
5 #include "Ids.h"
6 
7 #include "UaCanBusObject.h"
8 #include "UaControlDeviceGeneric.h"
9 #include "UaControlDeviceItem.h"
10 #include "IOManagerSDO.h"
11 #include "InterfaceUserDataBase.h"
12 #include "UaProgramItem.h"
13 #include "CanPDOItem.h"
14 
15 using namespace UserDevice;
16 namespace CanOpen
17 {
25 /*
26  UaCanNodeObject::UaCanNodeObject(NODE *nd, const UaNodeId& newNodeId, NmBuildingAutomation *pNodeManager,UserDataBase* pcanbus)
27  : UaControlDeviceGeneric(UaString(nd->name().c_str()), newNodeId,pNodeManager,BA_CANNODETYPE,nd,pcanbus)
28  {
29 
30  UaStatus ret ;
31 
32  ret = createSDOITEMs(nd,pNodeManager); // create SDO items
33  UA_ASSERT(ret.isGood());
34 
35  ret = createSDOs(nd,pNodeManager); // create the SDO object - the set of SDO items variable
36  UA_ASSERT(ret.isGood());
37 
38  ret = createAllTypesPDOs(nd,pNodeManager);
39  UA_ASSERT(ret.isGood());
40 
41  ret = createItems<NODE>(nd); // create the PDO object - the set of PDO item variable
42  UA_ASSERT(ret.isGood());
43 
44  ret = createPROGRAMs(nd, pNodeManager); // create the Program objects - the set of sequence of methods
45  UA_ASSERT(ret.isGood());
46 
47 // m_pIOManagerSDO = new IOManagerSDO(this); // Input/Output manager for SDO operation
48  }
49  */
58  UaCanNodeObject::UaCanNodeObject(NODE *nd,UaObject *pNodeType , const UaNodeId& newNodeId, NmBuildingAutomation *pNodeManager, pUserDeviceStruct* pcanbus)
59  : UaControlDeviceGeneric(UaString(nd->name().c_str()), newNodeId,pNodeManager, BA_CANNODETYPE,nd,pcanbus)
60  {
61 
62  UaStatus ret ;
63 
64  UaDataValue attrValue;
65 
66  NODETYPE *xsdObject=0;
67  if (pNodeType)
68  xsdObject = ((UaDeviceNodeType *)pNodeType)->getXsdData();
69 
70  if (xsdObject) {
71  ret = createSDOITEMs(xsdObject,pNodeManager); // create SDO items
72  UA_ASSERT(ret.isGood());
73 
74  ret = createSDOs(xsdObject,pNodeManager); // create the SDO object - the set of SDO items variable
75  UA_ASSERT(ret.isGood());
76 
77  ret = createAllTypesPDOs(xsdObject,pNodeManager); // create the PDO object - the set of PDO item variable
78  UA_ASSERT(ret.isGood());
79 
80  ret = createItems<NODETYPE>(xsdObject, pNodeManager);
81  UA_ASSERT(ret.isGood());
82  }
83 
84  ret = createSDOITEMs(nd,pNodeManager); // create SDO items
85  UA_ASSERT(ret.isGood());
86 
87  ret = createSDOs(nd,pNodeManager); // create the SDO object - the set of SDO items variable
88  UA_ASSERT(ret.isGood());
89 
90  ret = createAllTypesPDOs(nd,pNodeManager);
91  UA_ASSERT(ret.isGood());
92 
93  ret = createItems<NODE>(nd, pNodeManager); // create the PDO object - the set of PDO item variable
94  UA_ASSERT(ret.isGood());
95 
96  ret = createPROGRAMs(nd,pNodeManager); // create the Program objects - the set of sequence of methods
97  UA_ASSERT(ret.isGood());
98  }
99 
100  UaStatus UaCanNodeObject::createAllTypesPDOs(NODETYPE *xsdObject, NmBuildingAutomation *pNodeManager)
101  {
102  UaStatus ret = OpcUa_Good;
103  for (NODETYPE::NPDO_iterator pit = xsdObject->NPDO().begin(); pit != xsdObject->NPDO().end(); pit++)
104  {
105  ret = createPDOs((*pit),pNodeManager,true); // create the PDO object - the set of PDO item variable
106  if (ret.isBad()) {
107  return ret;
108  }
109  }
110 
111  for (NODETYPE::RPDO1_iterator pit = xsdObject->RPDO1().begin(); pit != xsdObject->RPDO1().end(); pit++)
112  {
113  ret = createPDOs((*pit),pNodeManager,true); // create the PDO object - the set of PDO item variable
114  if (ret.isBad()) {
115  return ret;
116  }
117  }
118  for (NODETYPE::RPDO2_iterator pit=xsdObject->RPDO2().begin(); pit != xsdObject->RPDO2().end(); pit++)
119  {
120  ret = createPDOs((*pit),pNodeManager,true); // create the PDO object - the set of PDO item variable
121  if (ret.isBad()) {
122  return ret;
123  }
124  }
125  for (NODETYPE::RPDO3_iterator pit=xsdObject->RPDO3().begin(); pit != xsdObject->RPDO3().end(); pit++)
126  {
127  ret = createPDOs((*pit),pNodeManager,true); // create the PDO object - the set of PDO item variable
128  if (ret.isBad()) {
129  return ret;
130  }
131  }
132  for (NODETYPE::RPDO4_iterator pit=xsdObject->RPDO4().begin(); pit != xsdObject->RPDO4().end(); pit++)
133  {
134  ret = createPDOs((*pit),pNodeManager,true); // create the PDO object - the set of PDO item variable
135  if (ret.isBad()) {
136  return ret;
137  }
138  }
139  for (NODETYPE::TPDO1_iterator pit=xsdObject->TPDO1().begin(); pit != xsdObject->TPDO1().end(); pit++)
140  {
141  ret = createPDOs((*pit),pNodeManager,true); // create the PDO object - the set of PDO item variable
142  if (ret.isBad()) {
143  return ret;
144  }
145  }
146  for (NODETYPE::TPDO2_iterator pit=xsdObject->TPDO2().begin(); pit != xsdObject->TPDO2().end(); pit++)
147  {
148  ret = createPDOs((*pit),pNodeManager,true); // create the PDO object - the set of PDO item variable
149  if (ret.isBad()) {
150  return ret;
151  }
152  }
153  for (NODETYPE::TPDO3_iterator pit=xsdObject->TPDO3().begin(); pit != xsdObject->TPDO3().end(); pit++)
154  {
155  ret = createPDOs((*pit),pNodeManager,true); // create the PDO object - the set of PDO item variable
156  if (ret.isBad()) {
157  return ret;
158  }
159  }
160 
161  for (NODETYPE::TPDO4_iterator pit=xsdObject->TPDO4().begin(); pit != xsdObject->TPDO4().end(); pit++)
162  {
163  ret = createPDOs((*pit),pNodeManager,true); // create the PDO object - the set of PDO item variable
164  if (ret.isBad()) {
165  return ret;
166  }
167  }
168  return ret;
169  }
170 
171  UaStatus UaCanNodeObject::createAllTypesPDOs(NODE *xsdObject, NmBuildingAutomation *pNodeManager)
172  {
173  UaStatus ret;
174 
175  for (NODE::NPDO_iterator pit = xsdObject->NPDO().begin(); pit != xsdObject->NPDO().end(); pit++)
176  {
177  ret = createPDOs((*pit),pNodeManager,true); // create the PDO object - the set of PDO item variable
178  if (ret.isBad()) {
179  return ret;
180  }
181  }
182 
183  for (NODE::RPDO1_iterator pit = xsdObject->RPDO1().begin(); pit != xsdObject->RPDO1().end(); pit++)
184  {
185  ret = createPDOs((*pit),pNodeManager,true); // create the PDO object - the set of PDO item variable
186  if (ret.isBad()) {
187  return ret;
188  }
189  }
190  for (NODE::RPDO2_iterator pit=xsdObject->RPDO2().begin(); pit != xsdObject->RPDO2().end(); pit++)
191  {
192  ret = createPDOs((*pit),pNodeManager,true); // create the PDO object - the set of PDO item variable
193  if (ret.isBad()) {
194  return ret;
195  }
196  }
197  for (NODE::RPDO3_iterator pit=xsdObject->RPDO3().begin(); pit != xsdObject->RPDO3().end(); pit++)
198  {
199  ret = createPDOs((*pit),pNodeManager,true); // create the PDO object - the set of PDO item variable
200  if (ret.isBad()) {
201  return ret;
202  }
203  }
204  for (NODE::RPDO4_iterator pit=xsdObject->RPDO4().begin(); pit != xsdObject->RPDO4().end(); pit++)
205  {
206  ret = createPDOs((*pit),pNodeManager,true); // create the PDO object - the set of PDO item variable
207  if (ret.isBad()) {
208  return ret;
209  }
210  }
211  for (NODE::TPDO1_iterator pit=xsdObject->TPDO1().begin(); pit != xsdObject->TPDO1().end(); pit++)
212  {
213  ret = createPDOs((*pit),pNodeManager,true); // create the PDO object - the set of PDO item variable
214  if (ret.isBad()) {
215  return ret;
216  }
217  }
218  for (NODE::TPDO2_iterator pit=xsdObject->TPDO2().begin(); pit != xsdObject->TPDO2().end(); pit++)
219  {
220  ret = createPDOs((*pit),pNodeManager,true); // create the PDO object - the set of PDO item variable
221  if (ret.isBad()) {
222  return ret;
223  }
224  }
225  for (NODE::TPDO3_iterator pit=xsdObject->TPDO3().begin(); pit != xsdObject->TPDO3().end(); pit++)
226  {
227  ret = createPDOs((*pit),pNodeManager,true); // create the PDO object - the set of PDO item variable
228  if (ret.isBad()) {
229  return ret;
230  }
231  }
232 
233  for (NODE::TPDO4_iterator pit=xsdObject->TPDO4().begin(); pit != xsdObject->TPDO4().end(); pit++)
234  {
235  ret = createPDOs((*pit),pNodeManager,true); // create the PDO object - the set of PDO item variable
236  if (ret.isBad()) {
237  return ret;
238  }
239  }
240 
241  for (NODE::PDO_iterator pit=xsdObject->PDO().begin(); pit != xsdObject->PDO().end(); pit++)
242  {
243  ret = createPDOs((*pit),pNodeManager,false); // create the PDO object - the set of PDO item variable
244  if (ret.isBad()) {
245  return ret;
246  }
247  }
248  return ret;
249  }
250 
251  UaStatus UaCanNodeObject::createPDOs(PDO &pit, NmBuildingAutomation *pNodeManager,bool type)
252  {
253  UaStatus ret;
254  UaString name;
255  UaNodeId uaId;
256  UaControlDeviceGeneric *pUaPdo;
257  OpcUa_BuiltInType typeName;
258  UaControlDeviceItem *pUaPdoItem;
259  UaVariant defaultValue;
260  UaDataValue uadef;
261  CanPDOItem* cPDOItem;
262 
263  name = pit.name().c_str();
264  OpcUa_Byte nch = pit.numch();
265 
266  uaId = pNodeManager->getNewNodeId(this,name);
267 
268 
269  pUserDeviceStruct* interf = static_cast<pUserDeviceStruct*>(getUserData());
270 
271  UaObjectType* prType = pNodeManager->getInstanceDeclarationObjectType(BA_PDOOBJECT);
272 
273  pUaPdo = new UaControlDeviceGeneric (name,uaId,pNodeManager, prType,
274  (::xml_schema::type *)&pit,
275  interf);
276 
277  pUserDeviceStruct * udb = static_cast<pUserDeviceStruct*>(pUaPdo->getUserData());
278 
279  CanPDOObject *cPDO = static_cast<CanPDOObject *>(udb->getDevice());
280  cPDO->addNodeId(type);
281 
282  ret = pNodeManager->addNodeAndReference( this,pUaPdo, OpcUaId_HasComponent);
283  UA_ASSERT(ret.isGood());
284 
285  ::PDO::PDOITEM_sequence pitem = pit.PDOITEM();
286 
287  if (nch > 0) {
288  for (OpcUa_Byte i = 0; i < nch; i++)
289  {
290  for (::PDO::PDOITEM_iterator pt = pitem.begin(); pt != pitem.end(); pt++)
291  {
292  name = pt->name().c_str();
293  name += UaString("_%1").arg(i);
294  CanOpenDataAddress::getOpcUaType(pt->type().c_str(),typeName);
295 
296  uaId = pNodeManager->getNewNodeId(pUaPdo,name);
297 // defaultValue.setInt32(0);
298  defaultValue.changeType(typeName, false);
299  UaVariableType* prType = pNodeManager->getInstanceDeclarationVariableType(BA_PDOITEM);
300 
301  pUaPdoItem = new UaControlDeviceItem(name,uaId,pNodeManager,defaultValue,prType,
302  (::xml_schema::type *)&(*pt),
303  udb,pUaPdo->getSharedMutex());
304  ret = pNodeManager->addNodeAndReference( pUaPdo,pUaPdoItem, OpcUaId_HasComponent);
305 
306  pUaPdoItem->setDataType(UaNodeId(typeName));
307  uadef.setDataValue(defaultValue, OpcUa_False, OpcUa_BadWaitingForInitialData, UaDateTime::now(), UaDateTime::now());
308  pUaPdoItem->setValue(0, uadef, OpcUa_False);
309 
310  pUserDeviceStruct * udbi = static_cast<pUserDeviceStruct*>(pUaPdoItem->getUserData());
311 
312  cPDOItem = static_cast<CanPDOItem *>(udbi->getDevice());
313 
314  cPDO->setItem(i,cPDOItem);
315  pUaPdoItem->setAccess(cPDO->getDirectionType());
316  }
317  }
318  }
319  else {
320  for (::PDO::PDOITEM_iterator pit1 = pitem.begin(); pit1 != pitem.end(); pit1++)
321  {
322  name = pit1->name().c_str();
323  CanOpenDataAddress::getOpcUaType(pit1->type().c_str(),typeName);
324  uaId = pNodeManager->getNewNodeId(pUaPdo,name);
325 
326  defaultValue.changeType(typeName, false);
327  UaVariableType* prType = pNodeManager->getInstanceDeclarationVariableType(BA_PDOITEM);
328 
329  pUaPdoItem = new UaControlDeviceItem(name,uaId,pNodeManager,defaultValue,prType,
330  (::xml_schema::type *)&(*pit1),
331  udb,pUaPdo->getSharedMutex());
332  ret = pNodeManager->addNodeAndReference( pUaPdo,pUaPdoItem, OpcUaId_HasComponent);
333  pUaPdoItem->setDataType(UaNodeId(typeName));
334  pUserDeviceStruct * udbi = static_cast<pUserDeviceStruct *>(pUaPdoItem->getUserData());
335  uadef.setDataValue(defaultValue, OpcUa_False, OpcUa_BadWaitingForInitialData, UaDateTime::now(), UaDateTime::now());
336  pUaPdoItem->setValue(0, uadef, OpcUa_False);
337 
338  cPDOItem = static_cast<CanPDOItem *>(udbi->getDevice());
339 
340  cPDO->setItem(0,cPDOItem);
341  pUaPdoItem->setAccess(cPDO->getDirectionType());
342 
343  }
344  }
345 
346  return ret;
347  }
348 
349  UaStatus UaCanNodeObject::createSDOs(NODETYPE *sn,NmBuildingAutomation *pNodeManager)
350  {
351  UaStatus ret;
352  UaString name;
353  UaNodeId uaId,uaIdsdo;
354  UaControlDeviceGeneric *pUasdo;
355  OpcUa_BuiltInType typeName;
356  UaControlDeviceItem *pUaSdoItem;
357  DirectionType dir;
358  UaVariant defaultValue;
359  SDO::SDOITEM_sequence sitem1;
360 
361  pUserDeviceStruct* interf = (pUserDeviceStruct *)getUserData();
362  NODETYPE::SDO_sequence sit1 = sn->SDO();
363  if (! sit1.empty() ) {
364 // for (NODETYPE::SDO_iterator sit = sit1.begin(); sit != sit1.end(); sit++)
365  OpcUa_Int32 len = sit1.size();
366  for (OpcUa_Int32 l = 0; l < len ; l++)
367  {
368  name = sit1[l].name().c_str();
369 
370  uaIdsdo = pNodeManager->getNewNodeId(this,name);
371  UaObjectType* prType = pNodeManager->getInstanceDeclarationObjectType(BA_SDOOBJECT);
372 
373  pUasdo = new UaControlDeviceGeneric (name,uaIdsdo,pNodeManager,prType,
374 // pUasdo = new UaControlDeviceGeneric(name, pNodeManager, prType,
375  (::xml_schema::type *)&(sit1[l]),
376  interf);
377  ret = pNodeManager->addNodeAndReference( this,pUasdo, OpcUaId_HasComponent);
378  UA_ASSERT(ret.isGood());
379 
380  sitem1 = sit1[l].SDOITEM();
381 
382  if (!sitem1.empty()) {
383  for (SDO::SDOITEM_iterator sitem = sitem1.begin(); sitem != sitem1.end(); sitem++)
384  {
385  CanOpenDataAddress::getOpcUaType(sitem->type().c_str(),typeName);
386  CanOpenDataAddress::getDirection(sitem->access().c_str(),dir);
387 
388  name = sitem->name().c_str(); // name of sdo item
389 
390  UaString nTmp = UaString("%1.%2").arg(uaIdsdo.toString()).arg(name);
391  uaId = UaNodeId(nTmp,pNodeManager->getNameSpaceIndex()); //create node id
392 
393  defaultValue.setInt32(0);
394  defaultValue.changeType(typeName, false);
395  UaVariableType* prType = pNodeManager->getInstanceDeclarationVariableType(BA_SDOITEMTYPE1);
396 
397  pUaSdoItem = new UaControlDeviceItem(name,uaId,pNodeManager,defaultValue,prType,
398  &(*sitem),
399 // (::xml_schema::type *)&(*sitem),
400  static_cast<pUserDeviceStruct*>(pUasdo->getUserData()),pUasdo->getSharedMutex());
401  pUaSdoItem->setAccess(dir);
402  pUaSdoItem->setValueHandling(UaVariable_Value_Cache);
403 
404  pUaSdoItem->setDataType(UaNodeId(typeName));
405 
406  ret = pNodeManager->addNodeAndReference(pUasdo,pUaSdoItem, OpcUaId_HasComponent);
407  }
408  }
409  SDO::SDOITEMARRAY_optional sdoi3 = sit1[l].SDOITEMARRAY();
410  if (sdoi3.present()) {
411  name = sdoi3.get().name().c_str();
412  for (int n = 0; n < sdoi3.get().number(); n++)
413  {
414  name += UaString("_%1").arg(n);
415  CanOpenDataAddress::getOpcUaType(sdoi3.get().type().c_str(),typeName);
416  CanOpenDataAddress::getDirection(sdoi3.get().access().c_str(),dir);
417  uaId = pNodeManager->getNewNodeId(pUasdo,name);
418  defaultValue.setInt32(0);
419  defaultValue.changeType(typeName, false);
420  UaVariableType* prType = pNodeManager->getInstanceDeclarationVariableType(BA_SDOITEMTYPE3);
421 
422  pUaSdoItem = new UaControlDeviceItem(name,uaId,pNodeManager,defaultValue,prType,
423  (::xml_schema::type *)&(sit1[l]),
424  (pUserDeviceStruct*)pUasdo->getUserData(),pUasdo->getSharedMutex());
425  pUaSdoItem->setAccess(dir);
426  pUaSdoItem->setValueHandling(UaVariable_Value_Cache);
427 
428  pUaSdoItem->setDataType(UaNodeId(typeName));
429 
430  ret = pNodeManager->addNodeAndReference(pUasdo,pUaSdoItem, OpcUaId_HasComponent);
431  }
432  }
433  }
434  }
435  return ret;
436  }
437 
438  UaStatus UaCanNodeObject::createSDOs(NODE *sn,NmBuildingAutomation *pNodeManager)
439  {
440  UaStatus ret;
441  UaString name;
442  UaNodeId uaId;
443  UaControlDeviceGeneric *pUasdo;
444  OpcUa_BuiltInType typeName;
445  UaControlDeviceItem *pUaSdoItem;
446  DirectionType dir;
447  UaVariant defaultValue;
448  pUserDeviceStruct* interf = (pUserDeviceStruct*)getUserData();
449  for (NODE::SDO_iterator sit=sn->SDO().begin(); sit != sn->SDO().end(); sit++)
450  {
451  name = sit->name().c_str();
452  uaId = pNodeManager->getNewNodeId(this,name);
453  UaObjectType* prType = pNodeManager->getInstanceDeclarationObjectType(BA_SDOOBJECT);
454 
455  pUasdo = new UaControlDeviceGeneric (name,uaId,pNodeManager,prType,
456 // pUasdo = new UaControlDeviceGeneric(name, pNodeManager, prType,
457  (::xml_schema::type *)&(*sit),
458  interf);
459  ret = pNodeManager->addNodeAndReference( this,pUasdo, OpcUaId_Organizes);
460  UA_ASSERT(ret.isGood());
461  SDO::SDOITEM_sequence sitem1 = sit->SDOITEM();
462  for (SDO::SDOITEM_iterator sitem = sitem1.begin(); sitem != sitem1.end(); sitem++)
463  {
464  name = sitem->name().c_str();
465  CanOpenDataAddress::getOpcUaType(sitem->type().c_str(),typeName);
466  CanOpenDataAddress::getDirection(sitem->access().c_str(),dir);
467  uaId = pNodeManager->getNewNodeId(pUasdo,name);
468 
469  defaultValue.setInt32(0);
470  defaultValue.changeType(typeName, false);
471  UaVariableType* prType = pNodeManager->getInstanceDeclarationVariableType(BA_SDOITEMTYPE1);
472 
473  pUaSdoItem = new UaControlDeviceItem(name,uaId,pNodeManager,defaultValue,prType,
474  (::xml_schema::type *)&(*sitem),
475  (pUserDeviceStruct*)pUasdo->getUserData(),pUasdo->getSharedMutex());
476  pUaSdoItem->setAccess(dir);
477  pUaSdoItem->setDataType(UaNodeId(typeName));
478 
479  ret = pNodeManager->addNodeAndReference(pUasdo,pUaSdoItem, OpcUaId_HasComponent);
480  }
481  SDO::SDOITEMARRAY_optional sdoi3 = sit->SDOITEMARRAY();
482  if (sdoi3.present()) {
483  name = sdoi3.get().name().c_str();
484  for (int n = 0; n < sdoi3.get().number(); n++)
485  {
486  name += UaString("_%1").arg(n);
487  CanOpenDataAddress::getOpcUaType(sdoi3.get().type().c_str(),typeName);
488  CanOpenDataAddress::getDirection(sdoi3.get().access().c_str(),dir);
489  uaId = pNodeManager->getNewNodeId(pUasdo,name);
490  defaultValue.setInt32(0);
491  defaultValue.changeType(typeName, false);
492  UaVariableType* prType = pNodeManager->getInstanceDeclarationVariableType(BA_SDOITEMTYPE3);
493 
494  pUaSdoItem = new UaControlDeviceItem(name,uaId,pNodeManager,defaultValue,prType,
495  (::xml_schema::type *)&(*sit),
496  (pUserDeviceStruct*)pUasdo->getUserData(),pUasdo->getSharedMutex());
497  pUaSdoItem->setAccess(dir);
498 
499  pUaSdoItem->setDataType(UaNodeId(typeName));
500 
501  ret = pNodeManager->addNodeAndReference(pUasdo,pUaSdoItem, OpcUaId_HasComponent);
502  }
503  }
504  }
505 
506  return ret;
507  }
508 
509  UaStatus UaCanNodeObject::createPROGRAMs(NODE *sn, NmBuildingAutomation *pNodeManager)
510  {
511  UaStatus ret;
512  UaString name;
513  UaNodeId uaId;
514  UaProgramItem *pProg;
515 // OpcUa_BuiltInType typeName;
516 // UaDeviceMethod *pUaMethod;
517 // DirectionType dir;
518 // UaVariant defaultValue;
519 
520  for (NODE::PROGRAM_iterator pit = sn->PROGRAM().begin(); pit != sn->PROGRAM().end(); pit++)
521  {
522  name = pit->name().c_str();
523  uaId = pNodeManager->getNewNodeId(this, name);
524  PROGRAM *pt = &(*pit);
525  UaObjectType* prType = pNodeManager->getInstanceDeclarationObjectType(BA_PROGRAM);
526  pProg = new UaProgramItem(pt, prType, uaId, pNodeManager, this, static_cast<pUserDeviceStruct*>(getUserData()));
527 // pProg = new UaProgramItem(pt, prType, name, pNodeManager, this, getUserData());
528  ret = pNodeManager->addNodeAndReference(this, pProg, OpcUaId_Organizes);
529  UA_ASSERT(ret.isGood());
530  }
531 
532  return ret;
533  }
534 
535 // template<typename NODEDEF>
536  UaStatus UaCanNodeObject::createSDOITEMs(NODE *sdoi,NmBuildingAutomation *pNodeManager)
537  {
538  UaStatus ret;
539  UaString name;
540  UaNodeId uaId;
541  UaControlDeviceItem *pUaSdoItem;
542  OpcUa_BuiltInType typeName;
543  DirectionType dir;
544  UaVariant defaultValue;
545 
546  pUserDeviceStruct* interf = (pUserDeviceStruct*)getUserData();
547  for (NODE::SDOITEM_iterator sit=sdoi->SDOITEM().begin(); sit != sdoi->SDOITEM().end(); sit++)
548  {
549  name = sit->name().c_str();
550  CanOpenDataAddress::getOpcUaType(sit->type().c_str(),typeName);
551  CanOpenDataAddress::getDirection(sit->access().c_str(),dir);
552  uaId = pNodeManager->getNewNodeId(this,name);
553  defaultValue.setInt32(0);
554  defaultValue.changeType(typeName, false);
555 
556  pUserDeviceStruct* pCanInter = pNodeManager->m_pControlInterface->createInterfaceEntry(interf,BA_SDOOBJECT,&(*sit),this);
557 
558  UaVariableType* prType = pNodeManager->getInstanceDeclarationVariableType(BA_SDOITEMTYPE2);
559 
560  pUaSdoItem = new UaControlDeviceItem(name,uaId,pNodeManager,defaultValue,prType,&(*sit),pCanInter,getSharedMutex());
561  pUaSdoItem->setAccess(dir);
562  pUaSdoItem->setValueHandling(UaVariable_Value_Cache);
563  pUaSdoItem->setDataType(UaNodeId(typeName));
564  ret = pNodeManager->addNodeAndReference(this, pUaSdoItem, OpcUaId_HasComponent);
565  }
566 
567  return ret;
568  }
569 
570  UaStatus UaCanNodeObject::createSDOITEMs(NODETYPE *sdoi,NmBuildingAutomation *pNodeManager)
571  {
572  UaStatus ret;
573  UaString name;
574  UaNodeId uaId;
575  UaControlDeviceItem *pUaSdoItem;
576  OpcUa_BuiltInType typeName;
577  DirectionType dir;
578  UaVariant defaultValue;
579 
580  pUserDeviceStruct* interf = static_cast<pUserDeviceStruct*>(getUserData());
581 
582  for (NODETYPE::SDOITEM_iterator sit=sdoi->SDOITEM().begin(); sit != sdoi->SDOITEM().end(); sit++)
583  {
584  name = sit->name().c_str();
585  CanOpenDataAddress::getOpcUaType(sit->type().c_str(),typeName);
586  CanOpenDataAddress::getDirection(sit->access().c_str(),dir);
587  uaId = pNodeManager->getNewNodeId(this,name);
588  defaultValue.setInt32(0);
589  defaultValue.changeType(typeName, false);
590 
591  pUserDeviceStruct* pCanInter = pNodeManager->m_pControlInterface->createInterfaceEntry(interf,BA_SDOOBJECT,&(*sit),this);
592  UaVariableType* prType = pNodeManager->getInstanceDeclarationVariableType(BA_SDOITEMTYPE2);
593 
594  pUaSdoItem = new UaControlDeviceItem(name,uaId,pNodeManager,defaultValue,prType,&(*sit),pCanInter,getSharedMutex());
595  pUaSdoItem->setAccess(dir);
596  pUaSdoItem->setValueHandling(UaVariable_Value_Cache);
597 
598  pUaSdoItem->setDataType(UaNodeId(typeName));
599 
600  ret = pNodeManager->addNodeAndReference(this, pUaSdoItem, OpcUaId_HasComponent);
601  }
602 
603  return ret;
604  }
605 
606  UaCanNodeObject::~UaCanNodeObject(void)
607  {
608 // delete m_pIOManagerSDO;
609 // m_pIOManagerSDO = NULL;
610  }
611 
612  template<typename NODEDEF>
613  UaStatus UaCanNodeObject::createItems(NODEDEF *nd, NmBuildingAutomation *pNodeManager)
614  {
615  UaStatus ret;
616  ret = CanBusInterface::CompileItems(this,nd->ITEM(),nd->REGEXPR(), pNodeManager);
617  if (ret.isBad()) {
618  LOG(Log::ERR) << "Calc Item" << " failed to create Calc Item, for " << this->browseName().toString().toUtf8() << " " << ret.pDiagnosticInfo()->m_localizedText.toString().toUtf8();
619  cerr << "Error Cacl Item " << this->browseName().toString().toUtf8() << " " << ret.pDiagnosticInfo()->m_localizedText.toString().toUtf8() << endl;
620  exit(-1);
621  }
622 
623  return ret;
624  }
625 /*
626  void UaCanNodeObject::setInitValue(UaVariant &uav,OpcUa_BuiltInType nType)
627  {
628  UaByteArray uba;
629  switch (nType) {
630  case OpcUaType_Boolean: uav.setBool(false); break;
631  case OpcUaType_Byte: uav.setByte(0); break;
632  case OpcUaType_Int16: uav.setInt16(0); break;
633  case OpcUaType_UInt16: uav.setUInt16(0); break;
634  case OpcUaType_Int32: uav.setInt32(0); break;
635  case OpcUaType_UInt32: uav.setUInt32(0); break;
636  case OpcUaType_Float: uav.setFloat(0.0); break;
637  case OpcUaType_Double: uav.setDouble(0.0); break;
638  case OpcUaType_ByteString: uav.setByteArray(uba); break;
639  default: uav.setInt32(0); break;
640  }
641  }
642 */
643 }