OpcUaCanOpen
CANopen OPC-UA server
IOManagerPDO.cpp
Go to the documentation of this file.
1 #include "BuildingAutomationTypeIds.h"
2 #include "IOManagerPDO.h"
3 #include "UaControlDeviceGeneric.h"
4 #include "UaControlDeviceItem.h"
5 #include "CanPDOItem.h"
6 #include "IOTransactionContextCanOpen.h"
7 #include "srvtrace.h"
8 #include "uabase.h"
9 #include "UaCanTrace.h"
10 
11 using namespace AddressSpace;
12 
13 namespace CanOpen
14 {
15 
17  IOManagerPDO::IOManagerPDO()
18  {
19 
20  }
21 
23  IOManagerPDO::~IOManagerPDO()
24  {
25 
26  }
27 
49  UaStatus IOManagerPDO::beginTransaction (
50  IOManagerCallback* pCallback,
51  const ServiceContext& serviceContext, // ToDo handle timeout hint and diagnostic info
52  OpcUa_UInt32 hTransaction,
53  OpcUa_UInt32 totalItemCountHint,
54  OpcUa_Double maxAge,
55  OpcUa_TimestampsToReturn timestampsToReturn,
56  TransactionType transactionType,
57  OpcUa_Handle& hIOManagerContext)
58  {
59  OpcUa_ReferenceParameter(maxAge);
60  TRACE0_INOUT(SERVER_CORE, UA_T"--> IOManagerPDO::beginTransaction");
61  UaStatus ret = OpcUa_Good ;
62 
63  // create transaction context for pdo write operation
64 
65  if ( transactionType == IOManager::WRITE ) // only write operation is allowed
66  {
67  IOTransactionContextPDO* pTransaction = new IOTransactionContextPDO;
68  pTransaction->setSession(serviceContext.pSession());
69  pTransaction->m_pCallback = pCallback;
70  pTransaction->m_hTransaction = hTransaction;
71  pTransaction->m_timestampsToReturn = timestampsToReturn;
72  pTransaction->m_totalItemCountHint = totalItemCountHint;
73  pTransaction->m_transactionType = transactionType;
74  pTransaction->m_nAsyncCount = 0;
75  pTransaction->m_pIOManager = this;
76  pTransaction->m_arrCallbackHandles.create(totalItemCountHint);
77  pTransaction->m_arrUaVariableHandles.create(totalItemCountHint);
78  OpcUa_UInt32 count = pTransaction->m_arrUaVariableHandles.length();
79 
80  pTransaction->m_arrCanPDOObject.create(totalItemCountHint);
81  for (OpcUa_UInt32 i = 0; i < count; i++)
82  {
83  pTransaction->m_arrUaVariableHandles[i] = NULL;
84  pTransaction->m_arrCanPDOObject[i] = NULL;
85  }
86 
87 
88  hIOManagerContext = (OpcUa_Handle)pTransaction;
89 
90  TRACE0_INOUT(SERVER_CORE, UA_T"--> IOManagerPDO::beginWriteTransaction");
91  }
92  else
93  {
94  hIOManagerContext = 0;
95  LOG(Log::DBG, UaCanTrace::PdoMessage) << " PDO Transaction Type Wrong -> " << transactionType;
96 
97  ret = OpcUa_BadInvalidArgument;
98  }
99 
100  TRACE1_INOUT(SERVER_CORE, UA_T"<-- IOManagerPDO::beginTransaction [ret=0x%lx]", ret.statusCode());
101  return ret;
102  }
103 
108  UaStatus IOManagerPDO::finishTransaction(OpcUa_Handle hIOManagerContext)
109  {
110  TRACE0_INOUT(SERVER_CORE, UA_T"--> IOManagerPDO::finishTransaction");
111  UaStatus ret = OpcUa_Good;
112  UaObjectArray<UaStatus> retTrun;
113  IOTransactionContextPDO* pTransaction = (IOTransactionContextPDO*)hIOManagerContext;
114 
115  if(pTransaction)
116  {
117  retTrun.create(pTransaction->m_nAsyncCount);
118  OpcUa_UInt32 nRetTrun = 0;
119  for(OpcUa_UInt32 i = 0; i < pTransaction->m_iPDONumber.size(); i++)
120  {
121  UaStatus retloc;
122  TRACE0_INOUT(SERVER_CORE, UA_T"--> IOManagerPDO::Write");
123 
124  //send PDO message
125 
126  retTrun[nRetTrun] = pTransaction->m_arrCanPDOObject[i]->sendDeviceMessage(Ba_PDOType_OUT);
127  if (i < pTransaction->m_iPDONumber.size()-1)
128  {
129  for (OpcUa_UInt32 j = nRetTrun + 1; j < pTransaction->m_iPDONumber[i + 1]; j++)
130  {
131  retTrun[j] = retTrun[nRetTrun];
132  nRetTrun = pTransaction->m_iPDONumber[i + 1];
133  }
134  }
135  }
136 
137  for(OpcUa_UInt32 i = 0; i < pTransaction->m_nAsyncCount; i++)
138  {
139  pTransaction->m_pCallback->finishWrite(pTransaction->m_hTransaction,pTransaction->m_arrCallbackHandles[i],retTrun[i],OpcUa_True);
140  }
141  delete pTransaction;
142  }
143  else {
144  ret.setStatus(OpcUa_BadUnexpectedError,"No Transaction");
145  TRACE1_INOUT(SERVER_CORE, UA_T"<-- IOManagerPDO::badFinishTransaction [ret=0x%lx]", ret.statusCode());
146  }
147 
148 
149  TRACE1_INOUT(SERVER_CORE, UA_T"<-- IOManagerPDO::finishTransaction [ret=0x%lx]", ret.statusCode());
150  return ret;
151  }
152 
162  UaStatus IOManagerPDO::beginRead (
163  OpcUa_Handle hIOManagerContext,
164  OpcUa_UInt32 callbackHandle,
165  VariableHandle* pVariableHandle,
166  OpcUa_ReadValueId* /*pReadValueId*/) // ToDo handle index range
167  {
168  OpcUa_ReferenceParameter(hIOManagerContext);
169  OpcUa_ReferenceParameter(callbackHandle);
170  OpcUa_ReferenceParameter( pVariableHandle);
171 // return OpcUa_BadInvalidArgument;
172  return OpcUa_Good;
173  }
174 
183  UaStatus IOManagerPDO::beginWrite (
184  OpcUa_Handle hIOManagerContext,
185  OpcUa_UInt32 callbackHandle,
186  VariableHandle* pVariableHandle,
187  OpcUa_WriteValue* pWriteValue)
188  {
189  UaStatus ret = OpcUa_Good;
190  UaControlDeviceItem *pPDONode;
191  IOTransactionContextPDO* pTransaction = (IOTransactionContextPDO*)hIOManagerContext;
192 
193  if(pTransaction)
194  {
195  if ( pTransaction->m_transactionType == IOManager::WRITE )
196  {
197  VariableHandleUaNode* vhUaNode = (VariableHandleUaNode*)pVariableHandle;
198 
199  pPDONode = (UaControlDeviceItem *)vhUaNode->pUaNode();
200  CanPDOItem *t_pdoi = (CanPDOItem *)pPDONode->getUserData();
201  CanPDOObject *t_pdo = t_pdoi->getCanPDOObject();
202 
203  // add variable handler ( possible not need for this operation )
204  pTransaction->m_arrCallbackHandles[pTransaction->m_nAsyncCount] = callbackHandle;
205  pTransaction->m_arrUaVariableHandles[pTransaction->m_nAsyncCount] = vhUaNode;
206  pTransaction->m_arrUaVariableHandles[pTransaction->m_nAsyncCount]->addReference();
207 
208  if (pTransaction->isNewCanPDOObject(t_pdo))
209  {
210  pTransaction->m_iPDONumber.push_back(pTransaction->m_nAsyncCount);
211 // pTransaction->m_arrCanPDOObject[pTransaction->m_nAsyncCount] = t_pdo; //add new PDO object to send data
212  pTransaction->m_arrCanPDOObject[pTransaction->m_iPDONumber.size()-1] = t_pdo; //add new PDO object to send data
213  }
214  pTransaction->m_nAsyncCount++;
215 
216  t_pdoi->pack((const OpcUa_Variant *)&pWriteValue->Value.Value); //pack PDO item into PDO object
217  }
218  else
219  {
220 // cout << "No Transaction Write " << endl;
221 
222  UA_ASSERT(false);
223  ret = OpcUa_BadNotWritable;
224  }
225  }
226  else
227  {
228  UA_ASSERT(false);
229  ret = OpcUa_BadInvalidArgument;
230  }
231 
232  return ret;
233  }
234 
245  UaStatus IOManagerPDO::beginStartMonitoring(
246  OpcUa_Handle hIOManagerContext,
247  OpcUa_UInt32 callbackHandle,
248  IOVariableCallback* pIOVariableCallback,
249  VariableHandle* pVariableHandle,
250  MonitoringContext& monitoringContext)
251  {
252  OpcUa_ReferenceParameter(hIOManagerContext);
253  OpcUa_ReferenceParameter(callbackHandle);
254  OpcUa_ReferenceParameter(pIOVariableCallback);
255  OpcUa_ReferenceParameter(pVariableHandle);
256  OpcUa_ReferenceParameter(monitoringContext);
257  return OpcUa_BadNotSupported;
258  }
259 
260 
269  UaStatus IOManagerPDO::beginModifyMonitoring(
270  OpcUa_Handle hIOManagerContext,
271  OpcUa_UInt32 callbackHandle,
272  OpcUa_UInt32 hIOVariable,
273  MonitoringContext& monitoringContext)
274  {
275  OpcUa_ReferenceParameter(hIOManagerContext);
276  OpcUa_ReferenceParameter(callbackHandle);
277  OpcUa_ReferenceParameter(hIOVariable);
278  OpcUa_ReferenceParameter(monitoringContext);
279  return OpcUa_BadNotSupported;
280  }
281 
282 
291  UaStatus IOManagerPDO::beginStopMonitoring(
292  OpcUa_Handle hIOManagerContext,
293  OpcUa_UInt32 callbackHandle,
294  OpcUa_UInt32 hIOVariable)
295  {
296  OpcUa_ReferenceParameter(hIOManagerContext);
297  OpcUa_ReferenceParameter(callbackHandle);
298  OpcUa_ReferenceParameter(hIOVariable);
299  return OpcUa_BadNotSupported;
300  }
301 
302 }