##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » SocExplorerPlugins
RSS
Avoid empty destructor trash.
Alexis Jeandet -
r85:b1f51619a4e6 default draft
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,1014 +1,1014
1 1 /*------------------------------------------------------------------------------
2 2 -- This file is a part of the SocExplorer Software
3 3 -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
4 4 --
5 5 -- This program is free software; you can redistribute it and/or modify
6 6 -- it under the terms of the GNU General Public License as published by
7 7 -- the Free Software Foundation; either version 3 of the License, or
8 8 -- (at your option) any later version.
9 9 --
10 10 -- This program is distributed in the hope that it will be useful,
11 11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 13 -- GNU General Public License for more details.
14 14 --
15 15 -- You should have received a copy of the GNU General Public License
16 16 -- along with this program; if not, write to the Free Software
17 17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 18 -------------------------------------------------------------------------------*/
19 19 /*-- Author : Alexis Jeandet
20 20 -- Mail : alexis.jeandet@member.fsf.org
21 21 ----------------------------------------------------------------------------*/
22 22
23 23 #include "stardundeespw_usb.h"
24 24 #include "fakestardundeespwusb_lib.h"
25 25 #include <socexplorerengine.h>
26 26 #include <qhexedit.h>
27 27
28 28 const QString dwLinkStatusQString[6] = {
29 29 "CFG_SPACEWIRE_ERROR_RESET",
30 30 "CFG_SPACEWIRE_ERROR_WAIT",
31 31 "CFG_SPACEWIRE_READY",
32 32 "CFG_SPACEWIRE_STARTED",
33 33 "CFG_SPACEWIRE_CONNECTING",
34 34 "CFG_SPACEWIRE_RUN"
35 35 };
36 36
37 37 stardundeeSPW_USB::stardundeeSPW_USB(socexplorerplugin *parent) :
38 38 abstractSpwBridge(parent)
39 39 {
40 40 Q_UNUSED(parent)
41 41 this->manager = new stardundeeSPW_USB_Manager(parent,this);
42 42 makeGUI(parent);
43 43 connect(this->manager,SIGNAL(emitPacket(char*,int)),this,SIGNAL(pushPacketOverTCP(char*,int)));
44 44 connect(this->manager, SIGNAL(bytesReceivedFromSpw(uint)), this, SIGNAL(BytesReceivedFromSpw(uint)));
45 45 connect(this->manager, SIGNAL(bytesTransmittedToSpw(uint)), this, SIGNAL(BytesTransmittedToSpw(uint)));
46 46 connect(this->manager, SIGNAL(ccsdsPacketTransmittedToSpw()), this, SIGNAL(CCSDSPacketTransmittedToSpw()));
47 47 this->manager->start();
48 48 }
49 49
50 50 stardundeeSPW_USB::~stardundeeSPW_USB()
51 51 {
52
52 SocExplorerEngine::message(this,"Deleting stardundeeSPW_USB",0);
53 53 }
54 54
55 55 void stardundeeSPW_USB::toggleBridgeConnection()
56 56 {
57 57 if(this->plugin->isConnected())
58 58 {
59 59 this->disconnectBridge();
60 60 }
61 61 else
62 62 {
63 63 this->connectBridge();
64 64 }
65 65 }
66 66
67 67 bool stardundeeSPW_USB::connectBridge()
68 68 {
69 69 if(this->manager->connectBridge())
70 70 {
71 71 this->timecodeFrequencyChanged( ((StarDundeeGUI*)this->p_GUI)->getTimecodeFrequency());
72 72 this->startSendingTimecodes( ((StarDundeeGUI*)this->p_GUI)->getStartSendingTimecodes());
73 73 ((StarDundeeGUI*)this->p_GUI)->lock(true);
74 74 emit setConnected(true);
75 75 return true;
76 76 }
77 77 return false;
78 78 }
79 79
80 80 bool stardundeeSPW_USB::disconnectBridge()
81 81 {
82 82 if(this->manager->disconnectBridge())
83 83 {
84 84 ((StarDundeeGUI*)this->p_GUI)->lock(false);
85 85 emit setConnected(false);
86 86 return true;
87 87 }
88 88 return false;
89 89 }
90 90
91 91 int stardundeeSPW_USB::pushRMAPPacket(char *packet, int size)
92 92 {
93 93 return this->manager->sendPacket(packet,size);
94 94 }
95 95
96 96 unsigned int stardundeeSPW_USB::Write(unsigned int *Value, unsigned int count, unsigned int address)
97 97 {
98 98 char writeBuffer[RMAP_WRITE_PACKET_MIN_SZ((RMAP_MAX_XFER_SIZE*4))+1];
99 99 char *RMAPAckBuff;
100 100 writeBuffer[0]=this->manager->linkNumber;//Link number
101 101 int transactionID = 0;
102 102 int written=0;
103 103 SocExplorerEngine::message(this->plugin,"Enter Write function",2);
104 104 QProgressBar* progress=NULL;
105 105 SocExplorerAutoProgressBar autopb;
106 106 if(count>RMAP_MAX_XFER_SIZE)
107 107 {
108 108 progress= SocExplorerEngine::getProgressBar("Writing on SPW @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
109 109 autopb.setProgressBar(progress);
110 110 }
111 111 //Quite stupide loop, I guess that I always get the number of byte I asked for!
112 112 while(count>=RMAP_MAX_XFER_SIZE)
113 113 {
114 114 for(int i=0;i<(RMAP_MAX_XFER_SIZE);i++)
115 115 {
116 116 writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+1] = (char)(((unsigned int)Value[i+written]>>24)&0xFF);
117 117 writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+2] = (char)(((unsigned int)Value[i+written]>>16)&0xFF);
118 118 writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+3] = (char)(((unsigned int)Value[i+written]>>8)&0xFF);
119 119 writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+4] = (char)(((unsigned int)Value[i+written])&0xFF);
120 120 }
121 121 transactionID=manager->getRMAPtransactionID();
122 122 SocExplorerEngine::message(this->plugin,QString("Sending Write request with ID=%1").arg(transactionID),2);
123 123 RMAP_build_tx_request_header(
124 124 this->manager->destinationLogicalAddress,
125 125 this->manager->destinationKey,
126 126 this->manager->sourceLogicalAddress,
127 127 transactionID,
128 128 address+(written*4),
129 129 RMAP_MAX_XFER_SIZE*4,
130 130 writeBuffer+1);
131 131 manager->sendPacket(writeBuffer,RMAP_WRITE_PACKET_MIN_SZ(RMAP_MAX_XFER_SIZE*4)+1);
132 132 manager->getRMAPanswer(transactionID,&RMAPAckBuff);
133 133 free(RMAPAckBuff);
134 134 written+=RMAP_MAX_XFER_SIZE;
135 135 count-=RMAP_MAX_XFER_SIZE;
136 136 progress->setValue(written);
137 137 qApp->processEvents();
138 138 }
139 139 if(count>0)
140 140 {
141 141 for(int i=0;i<((int)count);i++)
142 142 {
143 143 writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+1] = (char)(((unsigned int)Value[i+written]>>24)&0xFF);
144 144 writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+2] = (char)(((unsigned int)Value[i+written]>>16)&0xFF);
145 145 writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+3] = (char)(((unsigned int)Value[i+written]>>8)&0xFF);
146 146 writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+4] = (char)(((unsigned int)Value[i+written])&0xFF);
147 147 }
148 148 transactionID=manager->getRMAPtransactionID();
149 149 SocExplorerEngine::message(this->plugin,QString("Sending Write request with ID=%1").arg(transactionID),2);
150 150 RMAP_build_tx_request_header(
151 151 this->manager->destinationLogicalAddress,
152 152 this->manager->destinationKey,
153 153 this->manager->sourceLogicalAddress,
154 154 transactionID,
155 155 address+(written*4),
156 156 count*4,
157 157 writeBuffer+1);
158 158 manager->sendPacket(writeBuffer,RMAP_WRITE_PACKET_MIN_SZ(count*4) +1);
159 159 manager->getRMAPanswer(transactionID,&RMAPAckBuff);
160 160 free(RMAPAckBuff);
161 161 written+=count;
162 162 if(progress!=NULL)
163 163 {
164 164 progress->setValue(written);
165 165 qApp->processEvents();
166 166 }
167 167 }
168 168 return written;
169 169 }
170 170
171 171 unsigned int stardundeeSPW_USB::Read(unsigned int *Value, unsigned int count, unsigned int address)
172 172 {
173 173 char requestBuffer[RMAP_READ_HEADER_MIN_SZ+1];
174 174 char* RMAP_AnswerBuffer;
175 175 requestBuffer[0]=this->manager->linkNumber;//Link number
176 176 int transactionID = 0;
177 177 int read=0;
178 178 QProgressBar* progress=NULL;
179 179 SocExplorerAutoProgressBar autopb;
180 180 if(count>RMAP_MAX_XFER_SIZE)
181 181 {
182 182 progress= SocExplorerEngine::getProgressBar("Reading on SPW @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
183 183 autopb.setProgressBar(progress);
184 184 }
185 185 SocExplorerEngine::message(this->plugin,QString("Enter read function, count=%1, RMAP_MAX_XFER_SIZE=%2").arg(count).arg(RMAP_MAX_XFER_SIZE),2);
186 186
187 187 //Quite stupide loop, I guess that I always get the number of byte I asked for!
188 188 while((int)count>=(int)RMAP_MAX_XFER_SIZE)
189 189 {
190 190 transactionID = manager->getRMAPtransactionID();
191 191 SocExplorerEngine::message(this->plugin,QString("New transactionID:%1").arg(transactionID),2);
192 192 RMAP_build_rx_request_header(
193 193 this->manager->destinationLogicalAddress,
194 194 this->manager->destinationKey,
195 195 this->manager->sourceLogicalAddress,
196 196 transactionID,
197 197 address+(read*4),
198 198 RMAP_MAX_XFER_SIZE*4,
199 199 requestBuffer+1);
200 200 manager->sendPacket(requestBuffer,RMAP_READ_HEADER_MIN_SZ+1);
201 201 int len=manager->getRMAPanswer(transactionID,&RMAP_AnswerBuffer);
202 202 if(len==-1)
203 203 {
204 204 this->toggleBridgeConnection();
205 205 return 0;
206 206 }
207 207 for(int i=0;i<((len-13)/4);i++)
208 208 {
209 209 Value[read+i] = 0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+12]);
210 210 Value[read+i] = (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+13]));
211 211 Value[read+i] = (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+14]));
212 212 Value[read+i] = (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+15]));
213 213 }
214 214 free(RMAP_AnswerBuffer);
215 215 read+=RMAP_MAX_XFER_SIZE;
216 216 count-=RMAP_MAX_XFER_SIZE;
217 217 if(progress!=NULL)
218 218 {
219 219 progress->setValue(read);
220 220 qApp->processEvents();
221 221 }
222 222 }
223 223 if((int)count>0)
224 224 {
225 225 transactionID = manager->getRMAPtransactionID();
226 226 SocExplorerEngine::message(this->plugin,QString("New transactionID: %1").arg(transactionID),2);
227 227 SocExplorerEngine::message(this->plugin,QString("Building request with:"),2);
228 228 SocExplorerEngine::message(this->plugin,QString("Address = %1").arg(address+(read*4),8,16),2);
229 229 SocExplorerEngine::message(this->plugin,QString("Size = %1").arg(count*4),2);
230 230 SocExplorerEngine::message(this->plugin,QString("Size + 13 = %1").arg((count*4)+13),2);
231 231 RMAP_build_rx_request_header(
232 232 this->manager->destinationLogicalAddress,
233 233 this->manager->destinationKey,
234 234 this->manager->sourceLogicalAddress,
235 235 transactionID,
236 236 address+(read*4),
237 237 count*4,
238 238 requestBuffer+1);
239 239 manager->sendPacket(requestBuffer,RMAP_READ_HEADER_MIN_SZ+1);
240 240 int len=manager->getRMAPanswer(transactionID,&RMAP_AnswerBuffer);
241 241 if(len==-1)
242 242 {
243 243 this->toggleBridgeConnection();
244 244 return 0;
245 245 }
246 246 for(int i=0;i<((len-13)/4);i++)
247 247 {
248 248 Value[read+i] = 0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+12]);
249 249 Value[read+i] = (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+13]));
250 250 Value[read+i] = (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+14]));
251 251 Value[read+i] = (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+15]));
252 252 }
253 253 free(RMAP_AnswerBuffer);
254 254 read+=count;
255 255 if(progress!=NULL)
256 256 {
257 257 progress->setValue(read);
258 258 qApp->processEvents();
259 259 }
260 260 }
261 261 return read;
262 262 }
263 263
264 264 void stardundeeSPW_USB::brickSelectionChanged(int brickIndex)
265 265 {
266 266 this->manager->selectedBrick = brickIndex-1;
267 267 SocExplorerEngine::message(plugin,QString("Changing brick index: %1").arg(manager->selectedBrick),1);
268 268 }
269 269
270 270 void stardundeeSPW_USB::linkNumberSelectionChanged(int linkIndex)
271 271 {
272 272 this->manager->linkNumber = linkIndex + 1;
273 273 SocExplorerEngine::message(plugin,QString("Changing Link Number: %1").arg(manager->linkNumber),1);
274 274 }
275 275
276 276 void stardundeeSPW_USB::linkSpeedSelectionChanged(const QString &linkSpeed)
277 277 {
278 278 this->manager->linkSpeed = linkSpeed.toInt();
279 279
280 280 SocExplorerEngine::message(plugin,QString("Changing Link Speed: %1").arg(manager->linkSpeed),1);
281 281 }
282 282
283 283 void stardundeeSPW_USB::sourceLogicalAddressChanged(const QString &sourceAddress)
284 284 {
285 285 this->manager->sourceLogicalAddress = sourceAddress.toInt();
286 286 SocExplorerEngine::message(plugin,QString("Changing Destination Key: %1").arg(manager->sourceLogicalAddress),1);
287 287 }
288 288
289 289 void stardundeeSPW_USB::destinationAddressChanged(const QString &rmapaddress)
290 290 {
291 291 this->manager->destinationLogicalAddress = rmapaddress.toInt();
292 292 SocExplorerEngine::message(plugin,QString("Changing RMAP address: %1").arg(manager->destinationLogicalAddress),1);
293 293 }
294 294
295 295 void stardundeeSPW_USB::destinationKeyChanged(const QString &key)
296 296 {
297 297 this->manager->destinationKey = key.toInt();
298 298 SocExplorerEngine::message(plugin,QString("Changing RMAP Key: %1").arg(manager->destinationKey),1);
299 299 }
300 300
301 301 void stardundeeSPW_USB::brickModeChanged( bool interfaceMode )
302 302 {
303 303 this->manager->interfaceMode = interfaceMode;
304 304 }
305 305
306 306 void stardundeeSPW_USB::timecodeFrequencyChanged(const QString &frequency)
307 307 {
308 308 this->manager->timecodeFrequency = frequency.toDouble();
309 309 this->manager->setTimecodeFrequency( this->manager->timecodeFrequency);
310 310 SocExplorerEngine::message(plugin,QString("Changing timecode frequency: %1").arg(manager->timecodeFrequency),1);
311 311 }
312 312
313 313 void stardundeeSPW_USB::startSendingTimecodes(bool onOff )
314 314 {
315 315 this->manager->sendTimecodePeriodically( onOff );
316 316 }
317 317
318 318 void stardundeeSPW_USB::rmapTimeoutChanged(const QString &timeout)
319 319 {
320 320 int tim=timeout.toInt();
321 321 if(tim<50)
322 322 {
323 323 tim = 50;
324 324 ((StarDundeeGUI*)this->p_GUI)->setRmapTimeout(QString("%1").arg(tim));
325 325 }
326 326 this->manager->RMAPtimeout = tim;
327 327 SocExplorerEngine::message(plugin,QString("Changing RMAP Timeout: %1").arg(manager->RMAPtimeout),1);
328 328 }
329 329
330 330 void stardundeeSPW_USB::makeGUI(socexplorerplugin *parent)
331 331 {
332 332 Q_UNUSED(parent)
333 333 this->p_GUI = new StarDundeeGUI();
334 334 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(connectClicked()),this,SLOT(toggleBridgeConnection()));
335 335 connect(this->manager,SIGNAL(updateAvailableBrickCount(int)),((StarDundeeGUI*)this->p_GUI),SLOT(updateAvailableBrickCount(int)));
336 336 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(brickSelectionChanged(int)),this,SLOT(brickSelectionChanged(int)));
337 337 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(linkNumberSelectionChanged(int)),this,SLOT(linkNumberSelectionChanged(int)));
338 338 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(linkSpeedSelectionChanged(QString)),this,SLOT(linkSpeedSelectionChanged(QString)));
339 339 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(sourceLogicalAddressChanged(QString)),this,SLOT(sourceLogicalAddressChanged(QString)));
340 340 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(rmapAddressChanged(QString)),this,SLOT(destinationAddressChanged(QString)));
341 341 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(destinationKeyChanged(QString)),this,SLOT(destinationKeyChanged(QString)));
342 342 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(rmapTimeoutChanged(QString)),this,SLOT(rmapTimeoutChanged(QString)));
343 343 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(brickModeChanged(bool)), this, SLOT(brickModeChanged(bool)));
344 344 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(timecodeFrequencyChange(QString)), this, SLOT(timecodeFrequencyChanged(QString)));
345 345 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(startSendingTimecode(bool)), this, SLOT(startSendingTimecodes(bool)));
346 346
347 347 this->brickSelectionChanged( ((StarDundeeGUI*)this->p_GUI)->getBrickSelection());
348 348 this->linkNumberSelectionChanged( ((StarDundeeGUI*)this->p_GUI)->getLinkNumberSelection());
349 349 this->linkSpeedSelectionChanged( ((StarDundeeGUI*)this->p_GUI)->getLinkSpeedSelection());
350 350 this->sourceLogicalAddressChanged(((StarDundeeGUI*)this->p_GUI)->getSourceAddress());
351 351 this->destinationAddressChanged( ((StarDundeeGUI*)this->p_GUI)->getDestinationAddress());
352 352 this->destinationKeyChanged( ((StarDundeeGUI*)this->p_GUI)->getDestinationKey());
353 353 this->rmapTimeoutChanged( ((StarDundeeGUI*)this->p_GUI)->getRmapTimeout());
354 354 this->brickModeChanged( ((StarDundeeGUI*)this->p_GUI)->isBrickSetAsAnInterface());
355 355
356 356 connect(this,SIGNAL(SelectBrick(int)), ((StarDundeeGUI*)this->p_GUI),SLOT(selectBrick(int)));
357 357 connect(this,SIGNAL(SelectLinkNumber(int)), ((StarDundeeGUI*)this->p_GUI),SLOT(selectLinkNumber(int)));
358 358 connect(this,SIGNAL(SelectLinkSpeed(int)), ((StarDundeeGUI*)this->p_GUI),SLOT(selectLinkSpeed(int)));
359 359 connect(this,SIGNAL(SetDestinationKey(QString)), ((StarDundeeGUI*)this->p_GUI),SLOT(setDestinationKey(QString)));
360 360 connect(this,SIGNAL(SetDestinationAddress(QString)),((StarDundeeGUI*)this->p_GUI),SLOT(setDestinationAddress(QString)));
361 361 connect(this,SIGNAL(SetSourceAddress(QString)), ((StarDundeeGUI*)this->p_GUI),SLOT(setSourceAddress(QString)));
362 362 connect(this,SIGNAL(SetRmapTimeout(QString)), ((StarDundeeGUI*)this->p_GUI),SLOT(setRmapTimeout(QString)));
363 363 connect(this,SIGNAL(GetAvailableBrickCount()), ((StarDundeeGUI*)this->p_GUI),SLOT(getAvailableBrickCount()));
364 364 connect(this,SIGNAL(GetNbPacketsTransmittedToSpw()),((StarDundeeGUI*)this->p_GUI),SLOT(getNbPacketsTransmittedToSpw()));
365 365 connect(this,SIGNAL(GetNbCCSDSPacketsTransmittedToSpw()),
366 366 ((StarDundeeGUI*)this->p_GUI),SLOT(getNbCCSDSPacketsTransmittedToSpw()));
367 367 connect(this,SIGNAL(SetBrickAsAnInterface(bool)), ((StarDundeeGUI*)this->p_GUI),SLOT(setBrickAsAnInterface(bool)));
368 368 connect(this,SIGNAL(SetBrickAsARouter(bool)), ((StarDundeeGUI*)this->p_GUI),SLOT(setBrickAsARouter(bool)));
369 369 connect(this,SIGNAL(BytesReceivedFromSpw(uint)), ((StarDundeeGUI*)this->p_GUI),SLOT(updateNbReceivedBytesFromSpw(uint)));
370 370 connect(this,SIGNAL(BytesTransmittedToSpw(uint)), ((StarDundeeGUI*)this->p_GUI),SLOT(updateNbTransmittedBytesToSpw(uint)));
371 371 connect(this,SIGNAL(CCSDSPacketTransmittedToSpw()), ((StarDundeeGUI*)this->p_GUI),SLOT(updateCCSDSPacketTransmittedToSpw()));
372 372 connect(this,SIGNAL(SetTimecodeFrequency(double)), ((StarDundeeGUI*)this->p_GUI),SLOT(setTimecodeFrequency(double)));
373 373 connect(this,SIGNAL(StartSendingTimecodes(bool)), ((StarDundeeGUI*)this->p_GUI),SLOT(setStartSendingTimecodes(bool)));
374 374
375 375 connect(this,SIGNAL(SendOneTimecode(unsigned char)),this->manager, SLOT(sendOneTimecode(unsigned char)));
376 376 connect(this,SIGNAL(GetLinkNumber()), this->manager, SLOT(getLinkNumber()));
377 377 }
378 378
379 379 void stardundeeSPW_USB::sendPacketComingFromTCPServer(char *packet, int size)
380 380 {
381 381 char* data;
382 382 int i;
383 383
384 384 data = (char *) malloc( size + 5 );
385 385
386 386 data[0] = this->manager->linkNumber;
387 387 data[1] = this->manager->destinationLogicalAddress; // target logical address
388 388 data[2] = SPW_PROTO_ID_CCSDS; // protocol identifier
389 389 data[3] = 0x00; // reserved
390 390 data[4] = 0x00; // user application
391 391
392 392 for ( i=0; i<size; i++ )
393 393 {
394 394 data[i+5] = packet[i];
395 395 }
396 396
397 397 this->manager->sendPacket( data, size + 5);
398 398
399 399 free(data);
400 400 free(packet);
401 401 }
402 402
403 403 stardundeeSPW_USB_Manager::stardundeeSPW_USB_Manager(socexplorerplugin *plugin, QObject *parent)
404 404 :abstractSpwManager(plugin, parent)
405 405 {
406 406 // TODO remove this crap!
407 407 this->initDialog();
408 408 // this->moveToThread(this);
409 409 }
410 410
411 411 stardundeeSPW_USB_Manager::~stardundeeSPW_USB_Manager()
412 412 {
413 413 if(this->connected)disconnectBridge();
414 414 this->requestInterruption();
415 415 while(!this->isFinished());
416 416 }
417 417
418 418 void stardundeeSPW_USB_Manager::run()
419 419 {
420 420 USB_SPACEWIRE_PACKET_PROPERTIES properties;
421 421 USB_SPACEWIRE_ID pIdentifier=NULL;
422 422 USB_SPACEWIRE_STATUS stat;
423 423 SocExplorerEngine::message(this->plugin,"Starting Startdundee USB pooling thread",1);
424 424 char buffer[(RMAP_MAX_XFER_SIZE*4)+50];
425 425 while (!QThread::currentThread()->isInterruptionRequested())
426 426 {
427 427 if(this->connected)
428 428 {
429 429 this->handleMutex->lock();
430 430 SocExplorerEngine::message(this->plugin,"Looking for new RMAP packets",4);
431 431 if(USBSpaceWire_WaitOnReadPacketAvailable(hDevice,0.01))
432 432 {
433 433 SocExplorerEngine::message(this->plugin,"Got packet",2);
434 434 stat = USBSpaceWire_ReadPackets(hDevice, buffer, (RMAP_MAX_XFER_SIZE*4)+50,1, 1, &properties, &pIdentifier);
435 435 if (stat == TRANSFER_SUCCESS)
436 436 {
437 437 if(USBSpaceWire_GetReadTrafficType(&properties, 0) ==SPACEWIRE_TRAFFIC_PACKET)
438 438 {
439 439 SocExplorerEngine::message(this->plugin,"It's a SPW packet",2);
440 440 if(USBSpaceWire_GetReadEOPStatus(&properties, 0)== SPACEWIRE_USB_EOP)
441 441 {
442 442 SocExplorerEngine::message(this->plugin,"Got end of packet",2);
443 443 emit bytesReceivedFromSpw( properties.len );
444 444 if(buffer[1]==(char)SPW_PROTO_ID_RMAP) //RMAP packet
445 445 {
446 446 RMAP_Answer* packet;
447 447 SocExplorerEngine::message(this->plugin,"Got RMAP packet",2);
448 448 SocExplorerEngine::message(this->plugin,QString("Rmap packet size %1").arg(properties.len),2);
449 449 char* packetbuffer = (char*)malloc(properties.len);
450 450 memcpy(packetbuffer,buffer,properties.len);
451 451 USBSpaceWire_FreeRead(hDevice, pIdentifier);
452 452 pIdentifier = NULL;
453 453 this->handleMutex->unlock();
454 454 if(properties.len==8)
455 455 {
456 456 packet=new RMAP_Answer(RMAP_get_transactionID(buffer),packetbuffer,properties.len);
457 457 }
458 458 else
459 459 {
460 460 packet=new RMAP_Answer(RMAP_get_transactionID(buffer+1),packetbuffer,properties.len);
461 461 }
462 462 RMAP_AnswersMtx->lock();
463 463 RMAP_Answers.append(packet);
464 464 RMAP_AnswersMtx->unlock();
465 465 RMAP_AnswersSem->release();
466 466 }
467 467 else //any non-rmap packet will be pushed to the network
468 468 {
469 469 char* packetbuffer = (char*)malloc(properties.len);
470 470 memcpy(packetbuffer,buffer,properties.len);
471 471 emit emitPacket(packetbuffer,properties.len);
472 472 USBSpaceWire_FreeRead(hDevice, pIdentifier);
473 473 this->handleMutex->unlock();
474 474 SocExplorerEngine::message(this->plugin,"Got SPW packet",2);
475 475 }
476 476 }
477 477 else
478 478 {
479 479 SocExplorerEngine::message(this->plugin,"No EOP received",2);
480 480 this->handleMutex->unlock();
481 481 }
482 482 }
483 483
484 484 }
485 485 else
486 486 {
487 487 USBSpaceWire_FreeRead(hDevice, pIdentifier);
488 488 this->handleMutex->unlock();
489 489 }
490 490 }
491 491 else
492 492 {
493 493 USBSpaceWire_FreeRead(hDevice, pIdentifier);
494 494 this->handleMutex->unlock();
495 495 }
496 496 }
497 497 else
498 498 {
499 499 //do some sanity checks!
500 500 int list = USBSpaceWire_ListDevices();
501 501 if(this->brickList!=list)
502 502 {
503 503 this->brickList = list;
504 504 emit updateAvailableBrickCount(this->brickList);
505 505 }
506 506 usleep(RMAPtimeout/2);
507 507 }
508 508 usleep(1000);
509 509 }
510 510 SocExplorerEngine::message(this->plugin,"Exiting Startdundee USB pooling thread",1);
511 511 }
512 512
513 513 bool stardundeeSPW_USB_Manager::connectBridge()
514 514 {
515 515 bool ret;
516 516
517 517 if (this->interfaceMode == BRICK_IS_SET_AS_AN_INTERFACE)
518 518 {
519 519 ret = connectBridgeAsInterface();
520 520 }
521 521 else if (this->interfaceMode == BRICK_IS_SET_AS_A_ROUTER)
522 522 {
523 523 ret = connectBridgeAsRouter();
524 524 }
525 525 else
526 526 {
527 527 ret = false;
528 528 }
529 529
530 530 return ret;
531 531 }
532 532
533 533 bool stardundeeSPW_USB_Manager::connectBridgeAsInterface()
534 534 {
535 535 this->handleMutex->lock();
536 536 int status;
537 537 U32 statusControl;
538 538 this->connected = false;
539 539 if (!USBSpaceWire_Open(&hDevice, this->selectedBrick)) // Open the USB device
540 540 {
541 541 SocExplorerEngine::message(this->plugin,"stardundee *** Open *** ERROR: USBSpaceWire_Open(&hDevice, 0))",0);
542 542 this->handleMutex->unlock();
543 543 return false;
544 544 }
545 545 SocExplorerEngine::message(this->plugin,"stardundee *** Open *** USBSpaceWire_Open successful",0);
546 546
547 547 USBSpaceWire_EnableNetworkMode(hDevice, 0); // deactivate the network mode
548 548 CFGSpaceWire_EnableRMAP(1); // Enable the use of RMAP for the StarDundee brick configuration
549 549 CFGSpaceWire_SetRMAPDestinationKey(0x20); // Set the destination key expected by STAR-Dundee devices
550 550
551 551 // Set the path and return path to the device
552 552 CFGSpaceWire_StackClear();
553 553 CFGSpaceWire_AddrStackPush(0);
554 554 CFGSpaceWire_AddrStackPush(254);
555 555 CFGSpaceWire_RetAddrStackPush(254);
556 556 // set the base transmit rate to 100 MHz
557 557 status = CFGSpaceWire_SetBrickBaseTransmitRate( hDevice, CFG_BRK_CLK_100_MHZ, CFG_BRK_DVDR_1, 0xff);
558 558 if (status != CFG_TRANSFER_SUCCESS)
559 559 {
560 560 SocExplorerEngine::message(this->plugin,"ERROR CFGSpaceWire_SetBrickBaseTransmitRate",1);
561 561 this->handleMutex->unlock();
562 562 return false;
563 563 }
564 564 else
565 565 {
566 566 SocExplorerEngine::message(this->plugin,"OK CFGSpaceWire_SetBrickBaseTransmitRate, base rate = 100 MHz",1);
567 567 }
568 568
569 569 // read the link status
570 570 if (CFGSpaceWire_GetLinkStatusControl(hDevice, this->linkNumber, &statusControl) != CFG_TRANSFER_SUCCESS)
571 571 {
572 572 SocExplorerEngine::message(this->plugin,"Could not read link status control for link " + QString::number(this->linkNumber),1);
573 573 this->handleMutex->unlock();
574 574 return false;
575 575 }
576 576 else
577 577 {
578 578 SocExplorerEngine::message(this->plugin,"OK CFGSpaceWire_GetLinkStatusControl of link " + QString::number(this->linkNumber),1);
579 579
580 580 // Set the link status control register properties
581 581 CFGSpaceWire_LSEnableAutoStart(&statusControl, 1);
582 582 CFGSpaceWire_LSEnableStart(&statusControl, 1);
583 583 CFGSpaceWire_LSEnableDisabled(&statusControl, 0);
584 584 CFGSpaceWire_LSEnableTristate(&statusControl, 0);
585 585 CFGSpaceWire_LSSetOperatingSpeed(&statusControl, 9); // sets the link speed to ( 100 MHz / (9+1) ) = 10 MHz
586 586
587 587 // Set the link status control register
588 588 if (CFGSpaceWire_SetLinkStatusControl(hDevice, this->linkNumber, statusControl) != CFG_TRANSFER_SUCCESS)
589 589 {
590 590 SocExplorerEngine::message(this->plugin,"Could not set the link status control for link " + QString::number(this->linkNumber),1);
591 591 this->handleMutex->unlock();
592 592 return false;
593 593 }
594 594 else
595 595 {
596 596 SocExplorerEngine::message(this->plugin,"Set the link status control for link " + QString::number(this->linkNumber),1);
597 597 }
598 598 }
599 599
600 600 if (CFGSpaceWire_SetAsInterface(hDevice, 1, 0) != CFG_TRANSFER_SUCCESS)
601 601 {
602 602 SocExplorerEngine::message(this->plugin,"Could not set the device to be an interface",1);
603 603 this->handleMutex->unlock();
604 604 return false;
605 605 }
606 606 else
607 607 {
608 608 SocExplorerEngine::message(this->plugin,"Device set to be an interface",1);
609 609 }
610 610
611 611 USBSpaceWire_RegisterReceiveOnAllPorts(hDevice); // Register to receive on all ports
612 612 USBSpaceWire_ClearEndpoints(hDevice); // clear the USB endpoints
613 613 USBSpaceWire_SetTimeout(hDevice,1.0);
614 614 this->handleMutex->unlock();
615 615 SocExplorerEngine::message(this->plugin,"The driver's current send buffer size is " + QString::number(USBSpaceWire_GetDriverSendBufferSize(hDevice)) + " bytes",1);
616 616 SocExplorerEngine::message(this->plugin,"The driver's current read buffer size is " + QString::number(USBSpaceWire_GetDriverReadBufferSize(hDevice)) + " bytes",1);
617 617 SocExplorerEngine::message(this->plugin,"USBSpaceWire_IsReadThrottling is " + QString::number(USBSpaceWire_IsReadThrottling(hDevice)),1);
618 618 this->connected = true;
619 619 return true;
620 620 }
621 621
622 622 bool stardundeeSPW_USB_Manager::connectBridgeAsRouter()
623 623 {
624 624 // QMutexLocker mlock(&this->handleMutex);
625 625 this->handleMutex->lock();
626 626 int status;
627 627 U32 statusControl;
628 628 unsigned int linkStatus1;
629 629 unsigned int linkStatus2;
630 630 unsigned char linkNumber;
631 631 unsigned char deviceIsAnInterface;
632 632
633 633 if (!USBSpaceWire_Open(&hDevice, this->selectedBrick)) // Open the USB device
634 634 {
635 635 SocExplorerEngine::message(this->plugin,"stardundee *** Open *** ERROR: USBSpaceWire_Open(&hDevice, 0))");
636 636 this->handleMutex->unlock();
637 637 return false;
638 638 }
639 639 SocExplorerEngine::message(this->plugin,"stardundee *** Open *** USBSpaceWire_Open successful, device number: "
640 640 + QString::number(this->selectedBrick));
641 641
642 642 USBSpaceWire_EnableNetworkMode(hDevice, 0); // deactivate the network mode
643 643 CFGSpaceWire_EnableRMAP(1); // Enable the use of RMAP for the StarDundee brick configuration
644 644 CFGSpaceWire_SetRMAPDestinationKey(0x20); // Set the destination key expected by STAR-Dundee devices
645 645
646 646 // Set the path and return path to the device
647 647 // This affects just the operations performed by the Configuration Library and does not affect the packets
648 648 // sent and received using the driver API.
649 649 CFGSpaceWire_StackClear();
650 650 CFGSpaceWire_AddrStackPush(0);
651 651 CFGSpaceWire_AddrStackPush(254);
652 652 CFGSpaceWire_RetAddrStackPush(254);
653 653
654 654 // set the base transmit rate to 100 MHz
655 655 status = CFGSpaceWire_SetBrickBaseTransmitRate( hDevice, CFG_BRK_CLK_100_MHZ, CFG_BRK_DVDR_1, 0xff);
656 656 if (status != CFG_TRANSFER_SUCCESS)
657 657 {
658 658 SocExplorerEngine::message(this->plugin,"ERROR CFGSpaceWire_SetBrickBaseTransmitRate");
659 659 }
660 660 else SocExplorerEngine::message(this->plugin,"OK CFGSpaceWire_SetBrickBaseTransmitRate, base rate = 100 MHz");
661 661
662 662 //*********************
663 663 // LINK 1 CONFIGURATION
664 664 linkNumber = 1;
665 665 if (CFGSpaceWire_GetLinkStatusControl(hDevice, linkNumber, &statusControl) != CFG_TRANSFER_SUCCESS)
666 666 SocExplorerEngine::message(this->plugin,"Could not read link status control for link " + QString::number(linkNumber));
667 667 else
668 668 {
669 669 SocExplorerEngine::message(this->plugin,"OK CFGSpaceWire_GetLinkStatusControl of link " + QString::number(linkNumber));
670 670
671 671 // Set the link status control register properties
672 672 CFGSpaceWire_LSEnableAutoStart(&statusControl, 1);
673 673 CFGSpaceWire_LSEnableStart(&statusControl, 1);
674 674 CFGSpaceWire_LSEnableDisabled(&statusControl, 0);
675 675 CFGSpaceWire_LSEnableTristate(&statusControl, 0);
676 676 CFGSpaceWire_LSSetOperatingSpeed(&statusControl, 9); // sets the link speed to ( 100 MHz / (9+1) ) = 10 MHz
677 677
678 678 // Set the link status control register
679 679 if (CFGSpaceWire_SetLinkStatusControl(hDevice, linkNumber, statusControl) != CFG_TRANSFER_SUCCESS)
680 680 SocExplorerEngine::message(this->plugin,"Could not set the link status control for link " + QString::number(linkNumber));
681 681 else
682 682 SocExplorerEngine::message(this->plugin,"link status control for link " + QString::number(0x01) + " is set");
683 683 }
684 684
685 685 //*********************
686 686 // LINK 2 CONFIGURATION
687 687 linkNumber = 2;
688 688 if (CFGSpaceWire_GetLinkStatusControl(hDevice, linkNumber, &statusControl) != CFG_TRANSFER_SUCCESS)
689 689 SocExplorerEngine::message(this->plugin,"Could not read link status control for link " + QString::number(linkNumber));
690 690 else
691 691 {
692 692 SocExplorerEngine::message(this->plugin,"OK CFGSpaceWire_GetLinkStatusControl of link " + QString::number(linkNumber));
693 693
694 694 // Set the link status control register properties
695 695 CFGSpaceWire_LSEnableAutoStart(&statusControl, 1);
696 696 CFGSpaceWire_LSEnableStart(&statusControl, 1);
697 697 CFGSpaceWire_LSEnableDisabled(&statusControl, 0);
698 698 CFGSpaceWire_LSEnableTristate(&statusControl, 0);
699 699 CFGSpaceWire_LSSetOperatingSpeed(&statusControl, 9); // sets the link speed to ( 100 MHz / (9+1) ) = 10 MHz
700 700
701 701 // Set the link status control register
702 702 if (CFGSpaceWire_SetLinkStatusControl(hDevice, linkNumber, statusControl) != CFG_TRANSFER_SUCCESS)
703 703 SocExplorerEngine::message(this->plugin,"Could not set the link status control for link " + QString::number(linkNumber));
704 704 else
705 705 SocExplorerEngine::message(this->plugin,"link status control for link " + QString::number(linkNumber) + " is set");
706 706 }
707 707
708 708 //***************************
709 709 // SET THE DEVICE AS A ROUTER
710 710 deviceIsAnInterface = 0; // 0 = router, 1 = interface
711 711 if (CFGSpaceWire_SetAsInterface(hDevice, deviceIsAnInterface, 0) != CFG_TRANSFER_SUCCESS)
712 712 SocExplorerEngine::message(this->plugin,"Could not set the device to be an interface");
713 713 else
714 714 SocExplorerEngine::message(this->plugin,"Device is an interface: " + QString::number(deviceIsAnInterface) + " (1 => true, 0 => false)");
715 715
716 716 setRoutingTableEntry(0xfe, 0x02, 0); // [0010] => route 0xfe on port 1
717 717 setRoutingTableEntry(32 , 0x08, 0); // [1000] => route 32 on port 3
718 718
719 719 USBSpaceWire_RegisterReceiveOnAllPorts(hDevice); // Register to receive on port 1 only
720 720 USBSpaceWire_ClearEndpoints(hDevice); // clear the USB endpoints
721 721
722 722 SocExplorerEngine::message(this->plugin,"The driver's current send buffer size is " + QString::number(USBSpaceWire_GetDriverSendBufferSize(hDevice)) + " bytes");
723 723 SocExplorerEngine::message(this->plugin,"The driver's current read buffer size is " + QString::number(USBSpaceWire_GetDriverReadBufferSize(hDevice)) + " bytes");
724 724 SocExplorerEngine::message(this->plugin,"USBSpaceWire_IsReadThrottling is " + QString::number(USBSpaceWire_IsReadThrottling(hDevice)));
725 725
726 726 //************
727 727 // test Link 1 and Link 2
728 728 linkStatus1 = getLinkStatus(0x01);
729 729 linkStatus2 = getLinkStatus(0x02);
730 730 this->handleMutex->unlock();
731 731
732 732 if ((linkStatus1==1) || (linkStatus2==1))
733 733 {
734 734 initializeTimecodeGeneration();
735 735 this->connected=true;
736 736 return true;
737 737 }
738 738 else
739 739 {
740 740 statusLink1->setText("Link 1 status code: " + QString::number(linkStatus1));
741 741 statusLink2->setText("Link 2 status code: " + QString::number(linkStatus2));
742 742 starDundeeStatusQueryDialog->exec();
743 743 this->connected = false;
744 744 return false;
745 745 }
746 746 }
747 747
748 748 void stardundeeSPW_USB_Manager::initDialog( void )
749 749 {
750 750 // STAR DUNDEE STATUS QUERY DIALOG
751 751 starDundeeStatusQueryDialog = new QDialog;
752 752 starDundeeStatusQueryDialogLayout = new QGridLayout;
753 753 starDundeeStatusQueryDialogLabel = new QLabel(tr("SpaceWire links state"));
754 754 starDundeeStatusQueryContinueButton = new QPushButton(tr("Continue"));
755 755 starDundeeStatusQueryRetryButton = new QPushButton(tr("Retry"));
756 756 starDundeeStatusQueryAbortButton = new QPushButton(tr("Abort"));
757 757 statusLink1 = new QLabel(tr("Link 1 status code: -"));
758 758 statusLink2 = new QLabel(tr("Link 2 status code: -"));
759 759
760 760 starDundeeStatusQueryDialogLayout->addWidget(starDundeeStatusQueryDialogLabel, 0, 0, 1, 2);
761 761 starDundeeStatusQueryDialogLayout->addWidget(starDundeeStatusQueryContinueButton, 1, 0, 0);
762 762 starDundeeStatusQueryDialogLayout->addWidget(starDundeeStatusQueryRetryButton, 1, 1, 0);
763 763 starDundeeStatusQueryDialogLayout->addWidget(starDundeeStatusQueryAbortButton, 1, 2, 0);
764 764 starDundeeStatusQueryDialogLayout->addWidget(statusLink1, 2, 0, 0);
765 765 starDundeeStatusQueryDialogLayout->addWidget(statusLink2, 3, 0, 0);
766 766 starDundeeStatusQueryDialog->setLayout(starDundeeStatusQueryDialogLayout);
767 767 }
768 768
769 769 unsigned char stardundeeSPW_USB_Manager::setRoutingTableEntry(int tableEntry, U32 dwOutputPorts, char bDelHead)
770 770 {
771 771 U32 routingTableEntry;
772 772 // SET THE ROUTING TABLE ENTRY FOR LOGICAL ADDRESSING, TARGET entryNumber
773 773 if (CFGSpaceWire_ClearRoutingTableEntry(hDevice, tableEntry) != CFG_TRANSFER_SUCCESS)
774 774 {
775 775 SocExplorerEngine::message(this->plugin,"Could not clear routing table entry " + QString::number(tableEntry));
776 776 }
777 777 // Build the routing table entry
778 778 CFGSpaceWire_RTBuildRoutingTableEntry(&routingTableEntry,
779 779 dwOutputPorts, // route out of port dwOutputPorts
780 780 bDelHead, // header deletion is enabled [1] or disabled [0]
781 781 0); // priority normal
782 782 // Set the routing table entry for logical address tableEntry
783 783 if (CFGSpaceWire_SetRoutingTableEntry(hDevice, tableEntry, routingTableEntry) != CFG_TRANSFER_SUCCESS)
784 784 {
785 785 SocExplorerEngine::message(this->plugin,"Could not set routing table entry [" + QString::number(tableEntry) + "]");
786 786 }
787 787 else SocExplorerEngine::message(this->plugin,"Routing table entry [" + QString::number(tableEntry) + "] set" );
788 788 return 1;
789 789 }
790 790
791 791 unsigned int stardundeeSPW_USB_Manager::getRoutingTableEntry(int tableEntry)
792 792 {
793 793 U32 routingTableEntry, outputPorts;
794 794 char enabled, delHead, priority;
795 795 int portNum;
796 796
797 797 SocExplorerEngine::message(this->plugin,"GetRoutingTableEntry [" + QString::number(tableEntry) + "]");
798 798 // Read the routing table entry
799 799 if (CFGSpaceWire_GetRoutingTableEntry(hDevice, tableEntry, &routingTableEntry) != CFG_TRANSFER_SUCCESS)
800 800 {
801 801 SocExplorerEngine::message(this->plugin,"Could not read routing table entry [" + QString::number(tableEntry) + "]");
802 802 }
803 803 else
804 804 {
805 805 // Display the routing table entry properties
806 806 CFGSpaceWire_RTIsEnabled(routingTableEntry, &enabled);
807 807 CFGSpaceWire_RTIsDelHead(routingTableEntry, &delHead);
808 808 CFGSpaceWire_RTIsPriority(routingTableEntry, &priority);
809 809 CFGSpaceWire_RTGetOutputPorts(routingTableEntry, &outputPorts);
810 810 SocExplorerEngine::message(this->plugin,"CFGSpaceWire_RTIsEnabled : " + QString::number(enabled));
811 811 SocExplorerEngine::message(this->plugin,"CFGSpaceWire_RTIsDelHead : " + QString::number(delHead));
812 812 SocExplorerEngine::message(this->plugin,"CFGSpaceWire_RTIsPriority : " + QString::number(priority));
813 813 SocExplorerEngine::message(this->plugin,"CFGSpaceWire_RTGetOutputPorts : ");
814 814 for (portNum = 0; portNum < 32; portNum++)
815 815 {
816 816 if (outputPorts & (1 << portNum))
817 817 {
818 818 SocExplorerEngine::message(this->plugin,QString::number(portNum));
819 819 }
820 820 }
821 821 }
822 822
823 823 return 1;
824 824 }
825 825
826 826 void stardundeeSPW_USB_Manager::initializeTimecodeGeneration()
827 827 {
828 828 U32 dwTickEnableStatus;
829 829 U32 rtr_clk_freq;
830 830
831 831 // (1) RESET
832 832 if (!USBSpaceWire_TC_Reset(hDevice))
833 833 SocExplorerEngine::message(this->plugin,"ERR *** in Open *** Could not reset timecodes\n");
834 834
835 835 // (2) Clear the tick enable register
836 836 if (CFGSpaceWire_SetTickEnableStatus(hDevice, 6) != CFG_TRANSFER_SUCCESS)
837 837 SocExplorerEngine::message(this->plugin,"Could not clear the tick enable register");
838 838 else
839 839 SocExplorerEngine::message(this->plugin,"Cleared the tick enable register");
840 840
841 841 // (3) get the tick status
842 842 CFGSpaceWire_GetTickEnableStatus(hDevice, &dwTickEnableStatus);
843 843 SocExplorerEngine::message(this->plugin,"OK *** in Open *** CFGSpaceWire_GetTickEnableStatus, code is " + QString::number(dwTickEnableStatus, 2));
844 844
845 845 // (4) enable external timecode selection
846 846 if(!USBSpaceWire_TC_EnableExternalTimecodeSelection(hDevice,0))
847 847 SocExplorerEngine::message(this->plugin,"ERR *** disable external timecode selection");
848 848
849 849 rtr_clk_freq = USBSpaceWire_TC_GetClockFrequency(hDevice);
850 850
851 851 SocExplorerEngine::message(this->plugin,"clock frequency = " + QString::number(rtr_clk_freq) );
852 852
853 853 //**************************************************
854 854 // auto _ tick _ freq = rtr _ clk _ freq / freqCount
855 855 if (!USBSpaceWire_TC_SetAutoTickInFrequency(hDevice, rtr_clk_freq) )
856 856 SocExplorerEngine::message(this->plugin,"Could not set the tick-in frequency");
857 857 }
858 858
859 859 unsigned int stardundeeSPW_USB_Manager::getLinkStatus(unsigned char link)
860 860 {
861 861 U32 statusControl, errorStatus, portType;
862 862 U32 linkStatus=0, operatingSpeed, outputPortConnection;
863 863 char isLinkRunning, isAutoStart, isStart, isDisabled, isTristate;
864 864
865 865 // Read the link status control register
866 866 if (CFGSpaceWire_GetLinkStatusControl(hDevice, link, &statusControl) != CFG_TRANSFER_SUCCESS)
867 867 {
868 868 SocExplorerEngine::message(this->plugin,"Could not read link status control for link" + QString::number(link));
869 869 }
870 870 else
871 871 {
872 872 // Display the link status control register properties
873 873 CFGSpaceWire_LSPortType(statusControl, &portType);
874 874 if (portType == CFG_CONFIGURATION_PORT)
875 875 {
876 876 CFGSpaceWire_LSConfigErrorStatus(statusControl, &errorStatus);
877 877 }
878 878 else if (portType == CFG_SPACEWIRE_EXTERNAL_PORT)
879 879 {
880 880 CFGSpaceWire_LSExternalErrorStatus(statusControl, &errorStatus);
881 881 }
882 882 else
883 883 {
884 884 CFGSpaceWire_LSErrorStatus(statusControl, &errorStatus);
885 885 }
886 886 CFGSpaceWire_LSLinkState(statusControl, &linkStatus);
887 887 CFGSpaceWire_LSIsLinkRunning(statusControl, &isLinkRunning);
888 888 CFGSpaceWire_LSIsAutoStart(statusControl, &isAutoStart);
889 889 CFGSpaceWire_LSIsStart(statusControl, &isStart);
890 890 CFGSpaceWire_LSIsDisabled(statusControl, &isDisabled);
891 891 CFGSpaceWire_LSIsTristate(statusControl, &isTristate);
892 892 CFGSpaceWire_LSOperatingSpeed(statusControl, &operatingSpeed);
893 893 CFGSpaceWire_LSOutputPortConnection(statusControl, &outputPortConnection);
894 894 }
895 895 SocExplorerEngine::message(this->plugin,"status of link " + QString::number(link)
896 896 +" is " + dwLinkStatusQString[linkStatus]);
897 897 if (linkStatus == 5)
898 898 {
899 899 return 1;
900 900 }
901 901 else return 0;
902 902 }
903 903
904 904 bool stardundeeSPW_USB_Manager::disconnectBridge()
905 905 {
906 906 this->handleMutex->lock();
907 907 USBSpaceWire_UnregisterReceiveOnAllPorts(hDevice); // Stop receiving on all ports
908 908 USBSpaceWire_Close(hDevice); // Close the device
909 909 SocExplorerEngine::message(this->plugin,"stardundee *** Close *** USBSpaceWire_Close, device: " + QString::number(0),0);
910 910 this->handleMutex->unlock();
911 911 this->RMAP_pending_transaction_IDsMtx->lock();
912 912 this->RMAP_pending_transaction_IDs.clear();
913 913 this->RMAP_pending_transaction_IDsMtx->unlock();
914 914 this->RMAP_AnswersMtx->lock();
915 915 this->RMAP_Answers.clear();
916 916 this->RMAP_AnswersMtx->unlock();
917 917 this->RMAP_AnswersSem->acquire(this->RMAP_AnswersSem->available());
918 918 this->connected=false;
919 919 return true;
920 920 }
921 921
922 922 bool stardundeeSPW_USB_Manager::sendPacket(char *packet, int size)
923 923 {
924 924 char protocoleIdentifier;
925 925 USB_SPACEWIRE_STATUS result=TRANSFER_ERROR_NOT_FOUND;
926 926 USB_SPACEWIRE_ID pIdentifier;
927 927 SocExplorerEngine::message(this->plugin,"Sending SPW packet",2);
928 928 this->handleMutex->lock();
929 929 result = USBSpaceWire_SendPacket(hDevice,packet,size,1, &pIdentifier);
930 930 USBSpaceWire_FreeSend(hDevice, pIdentifier);
931 931 this->handleMutex->unlock();
932 932 if (result != TRANSFER_SUCCESS)
933 933 {
934 934 SocExplorerEngine::message(this->plugin,"ERR sending the READ command ",2);
935 935 return false;
936 936 }
937 937 else
938 938 {
939 939 emit bytesTransmittedToSpw( size-1 ); // -1 is for removing the first bytes added to the packet to route to the right link
940 940 // read the protocole identifier
941 941 protocoleIdentifier = packet[2];
942 942 if (protocoleIdentifier == SPW_PROTO_ID_CCSDS)
943 943 emit ccsdsPacketTransmittedToSpw();
944 944
945 945 SocExplorerEngine::message(this->plugin,"Packet sent",2);
946 946 }
947 947 return true;
948 948 }
949 949
950 950
951 951 void stardundeeSPW_USB_Manager::sendTimecodePeriodically( bool onOff )
952 952 {
953 953 this->handleMutex->lock();
954 954 if (onOff == true)
955 955 {
956 956 if (!USBSpaceWire_TC_EnableAutoTickIn(hDevice, 1, 1))
957 957 SocExplorerEngine::message(this->plugin,"Could not enable auto tick-in");
958 958 }
959 959 else
960 960 {
961 961 if (!USBSpaceWire_TC_EnableAutoTickIn(hDevice, 0, 0))
962 962 SocExplorerEngine::message(this->plugin,"Could not disable auto tick-in");
963 963 }
964 964 this->handleMutex->unlock();
965 965 }
966 966
967 967 int stardundeeSPW_USB_Manager::getLinkNumber( void )
968 968 {
969 969 return this->linkNumber;
970 970 }
971 971
972 972 void stardundeeSPW_USB_Manager::setTimecodeFrequency(double requestedFrequency)
973 973 {
974 974 U32 rtr_clk_freq=0;
975 975 U32 freqCount=0;
976 976 double freqCountInDouble=0.0;
977 977 double currentFrequency=0.0;
978 978
979 979 this->handleMutex->lock();
980 980 rtr_clk_freq = USBSpaceWire_TC_GetClockFrequency(hDevice);
981 981 freqCountInDouble = ((double) rtr_clk_freq) / requestedFrequency;
982 982 freqCount = (unsigned int) freqCountInDouble;
983 983
984 984 currentFrequency = ((double) rtr_clk_freq) / ((double) freqCount);
985 985
986 986 //**************************************************
987 987 // auto _ tick _ freq = rtr _ clk _ freq / freqCount
988 988 if (!USBSpaceWire_TC_SetAutoTickInFrequency(hDevice, freqCount) )
989 989 SocExplorerEngine::message(this->plugin,"Could not set the tick-in frequency");
990 990 else
991 991 SocExplorerEngine::message(this->plugin,"tick frequency set to " + QString::number(currentFrequency) +" Hz"
992 992 + " (freqCount set to " + QString::number(freqCount) + ")" );
993 993 this->handleMutex->unlock();
994 994 }
995 995
996 996 void stardundeeSPW_USB_Manager::sendOneTimecode( unsigned char nTimein )
997 997 {
998 998 this->handleMutex->lock();
999 999 // enable external timecode selection
1000 1000 if(!USBSpaceWire_TC_EnableExternalTimecodeSelection(hDevice,1))
1001 1001 SocExplorerEngine::message(this->plugin,"sendOneTimecode *** ERR *** enable external timecode selection");
1002 1002
1003 1003 if (!USBSpaceWire_TC_PerformTickIn( hDevice, nTimein) )
1004 1004 SocExplorerEngine::message( this->plugin,"sendOneTimecode *** ERR *** Could not send the requested timecode: " + QString::number(nTimein) );
1005 1005 else
1006 1006 SocExplorerEngine::message( this->plugin,"sendOneTimecode *** OK *** timecode sent " + QString::number(nTimein) );
1007 1007
1008 1008 // disable external timecode selection
1009 1009 if(!USBSpaceWire_TC_EnableExternalTimecodeSelection(hDevice,0))
1010 1010 SocExplorerEngine::message(this->plugin,"sendOneTimecode *** ERR *** disable external timecode selection");
1011 1011 this->handleMutex->unlock();
1012 1012 }
1013 1013
1014 1014
General Comments 0
You need to be logged in to leave comments. Login now