MNE-CPP  beta 1.0
babymegclient.cpp
1 //=============================================================================================================
37 //*************************************************************************************************************
38 //=============================================================================================================
39 // INCLUDES
40 //=============================================================================================================
41 
42 #include "babymegclient.h"
43 
44 //*************************************************************************************************************
45 //=============================================================================================================
46 // QT INCLUDES
47 //=============================================================================================================
48 
49 #include <QDebug>
50 #include <QtNetwork/QtNetwork>
51 #include <QtEndian>
52 
53 //*************************************************************************************************************
54 
55 BabyMEGClient::BabyMEGClient(int myPort, QObject *parent) :
56  QThread(parent)
57 {
58  connect(this,SIGNAL(DataAcq()),this,SLOT(run()));
59  tcpSocket = new QTcpSocket(this);
60 
61  connect(tcpSocket,SIGNAL(readyRead()),this,SLOT(ReadToBuffer()));
62 
63 
64  connect(this, SIGNAL(error(int,QString)),
65  this, SLOT(DisplayError(int,QString))); //find out name of this machine
66  name = QHostInfo::localHostName();
67  if(!name.isEmpty())
68  {
69  QString domain = QHostInfo::localDomainName();
70  if (!domain.isEmpty())
71  name = name + QChar('.') + domain;
72  }
73  if (name!=QString("localhost"))
74  name = QString("localhost");
75  qDebug()<< "- " + name;
76  port = myPort;//6340;
77  SocketIsConnected = false;
78  SkipLoop = false;
79  DataAcqStartFlag = false;
80  numBlock = 0;
81  DataACK = false;
82 
83 }
84 
85 //*************************************************************************************************************
86 
87 BabyMEGClient::~BabyMEGClient()
88 {
89  delete tcpSocket; // added 5.31.2013
90 }
91 
92 //*************************************************************************************************************
93 
95 {
96  myBabyMEGInfo = pInfo;
97 }
98 
99 //*************************************************************************************************************
100 
101 void BabyMEGClient::DisplayError(int socketError, const QString &message)
102 {
103  switch (socketError){
104  case QAbstractSocket::RemoteHostClosedError:
105  break;
106  case QAbstractSocket::HostNotFoundError:
107  qDebug()<< "The host was not found. Please check the host name and the port number";
108  break;
109  case QAbstractSocket::ConnectionRefusedError:
110  qDebug()<< "The connection was refused by the peer. Make sure the server is running?";
111  break;
112  default:
113  qDebug()<< "Error: " << message;
114  }
115 }
116 
117 //*************************************************************************************************************
118 
120 {
121  int value= 0;
122  for (int i=0;i<2;i++)
123  {
124  QByteArray t;
125  t[0] = b[i];
126  b[i] = b[3-i];
127  b[3-i] = t[0];
128  }
129  memcpy((char *)&value,b,4);
130  return value;
131 }
132 
133 
134 //*************************************************************************************************************
135 
137 {
138  QByteArray b = QByteArray::fromRawData((char *)&a,4);
139 
140  for (int i=0;i<2;i++)
141  {
142  QByteArray t;
143  t[0] = b[i];
144  b[i] = b[3-i];
145  b[3-i] = t[0];
146  }
147  return b;
148 }
149 
150 
151 //*************************************************************************************************************
152 
154 {
155  double value= 1.0;
156  // reverse the byte order
157  for (int i=0;i<4;i++)
158  {
159  QByteArray t;
160  t[0] = b[i];
161  b[i] = b[7-i];
162  b[7-i] = t[0];
163  }
164  memcpy((char *)&value,b,8);
165 
166  return value;
167 }
168 
169 
170 //*************************************************************************************************************
171 
173 {
174  QByteArray data = QByteArray::fromRawData((char *)&a,8);
175  qDebug() << data.toHex();
176 }
177 
178 
179 //*************************************************************************************************************
180 
182 {
183  // return true: sucessfully connect to babyMEG server
184  // false: fail.
185  SocketIsConnected = false;
186  // Connect to the server of babyMEG [labview]
187  qDebug()<< "Client is started!";
188 
189  if (!this->isRunning())
190  {
191  this->start();
192  }
193 
194  for(int i=0;i<5;i++){
195  tcpSocket->connectToHost(name,port,QIODevice::ReadWrite);
196  if (tcpSocket->waitForConnected(5000))
197  {
198  SocketIsConnected = true;
199  qDebug("Connect to BabyMEG Server ... Ok");
200  //download parameters
201  qDebug()<< "Send the initial parameter request";
202  if (tcpSocket->state()==QAbstractSocket::ConnectedState)
203  {
204  buffer.clear();
205 // SendCommand("INFO");
206  SendCommand("DATA");
207  }
208  return;
209  }
210  else{
211  qDebug("Connect to BabyMEG Server ... Fail");
212  qDebug("Try another time connection");
213  }
214  qDebug("Please check the babyMEG server: if started");
215  }
216  return;
217 }
218 
219 
220 //*************************************************************************************************************
221 
223 {
224  if(SocketIsConnected && tcpSocket->state()==QAbstractSocket::ConnectedState)
225  SendCommand("QUIT");
226 }
227 
228 
229 //*************************************************************************************************************
230 
232 {
233  qDebug() << "SendCommandToBabyMEGShortConnection";
234  tcpSocket->connectToHost(name,port,QIODevice::ReadWrite);
235  if (tcpSocket->waitForConnected(10000))
236  {
237 
238  qDebug()<<"Connection is built.";
239 
240  if(tcpSocket->state()==QAbstractSocket::ConnectedState)
241  {
242  qDebug()<<"Send String [" << s << "]";
243  tcpSocket->write(s);
244 // int strlen = s.size();
245 // QByteArray Scmd = MGH_LM_Int2Byte(strlen);
246 
247 // tcpSocket->write(Scmd);
248 // tcpSocket->write("SLM");
249  tcpSocket->waitForBytesWritten();
250  }
251  }
252 
253 }
254 
255 
256 //*************************************************************************************************************
257 
259 {
260  qDebug()<<"Send Command";
261  if(SocketIsConnected && tcpSocket->state()==QAbstractSocket::ConnectedState)
262  {
263  m_qMutex.lock();
264  tcpSocket->write("COMD");
265  tcpSocket->waitForBytesWritten();
266 
267  int strlen = 3;
268  QByteArray Scmd = MGH_LM_Int2Byte(strlen);
269 
270  tcpSocket->write(Scmd);
271  tcpSocket->write("SLM");
272  tcpSocket->waitForBytesWritten();
273  m_qMutex.unlock();
274  }
275 
276 }
277 
278 
279 //*************************************************************************************************************
280 
282 {
283 
284  QByteArray dat;
285 
286  int numBytes = tcpSocket->bytesAvailable();
287 // qDebug() << "1.byte available: " << numBytes;
288  if (numBytes > 0){
289  dat = tcpSocket->read(numBytes); // read all pending data
290 // qDebug()<<"[dat Size]"<<dat.size();
291  if (!dat.isEmpty()){
292  buffer.append(dat); // and append it to your own buffer
293 // qDebug()<<"[ReadToBuffer: Buffer Size]"<<buffer.size();
294  }
295  else
296  {
297  qDebug()<<"[Empty dat: error]"<<tcpSocket->errorString();
298  }
299  }
300 // qDebug()<<"read buffer is done!";
301 
302  handleBuffer();
303  return;
304 }
305 
306 //*************************************************************************************************************
307 
309 {
310  if(buffer.size()>= 8){
311  QByteArray CMD = buffer.left(4);
312  QByteArray DLEN = buffer.mid(4,4);
313  int tmp = MGH_LM_Byte2Int(DLEN);
314 // qDebug() << "First 4 bytes + length" << CMD << "["<<CMD.toHex()<<"]";
315 // qDebug() << "Command[" << CMD <<"]";
316 // qDebug() << "Body Length[" << tmp << "]";
317 
318  if (tmp <= (buffer.size() - 8))
319  {
320  buffer.remove(0,8);
321 
322  int OPT = 0;
323 
324  if (CMD == "INFO")
325  OPT = 1;
326  else if (CMD == "DATR")
327  OPT = 2;
328  else if (CMD == "COMD")
329  OPT = 3;
330  else if (CMD == "QUIT")
331  OPT = 4;
332  else if (CMD == "COMS")
333  OPT = 5;
334  else if (CMD == "QUIS")
335  OPT = 6;
336 
337  switch (OPT){
338  case 1:
339  // from buffer get data package
340  {
341  QByteArray PARA = buffer.left(tmp);
342  qDebug()<<"[INFO]"<<PARA;
343  //Parse parameters from PARA string
344  myBabyMEGInfo->MGH_LM_Parse_Para(PARA);
345  buffer.remove(0,tmp);
346  qDebug()<<"INFO has been received!!!!";
347 // qDebug()<<"ACQ Start";
348 // SendCommand("DATA");
349  }
350  break;
351  case 2:
352  // read data package from buffer
353  // Ask for the next data block
354 
355  SendCommand("DATA");
356  DispatchDataPackage(tmp);
357 
358  break;
359  case 3:
360  {
361  QByteArray RESP = buffer.left(tmp);
362  qDebug()<< "5.Readbytes:"<<RESP.size();
363  qDebug() << RESP;
364  }
365  buffer.remove(0,tmp);
366 
367  break;
368  case 4: //quit
369  qDebug()<<"Quit";
370 
371  SendCommand("QREL");
372  tcpSocket->disconnectFromHost();
373  if(tcpSocket->state() != QAbstractSocket::UnconnectedState)
374  tcpSocket->waitForDisconnected();
375  SocketIsConnected = false;
376  qDebug()<< "Disconnect Server";
377  qDebug()<< "Client is End!";
378  qDebug()<< "You can close this application or restart to connect Server.";
379 
380  break;
381  case 5://command short connection
382  {
383  QByteArray RESP = buffer.left(tmp);
384  qDebug()<< "5.Readbytes:"<<RESP.size();
385  qDebug() << RESP;
386  myBabyMEGInfo->MGH_LM_Send_CMDPackage(RESP);
387  }
388  buffer.remove(0,tmp);
389  SendCommand("QUIT");
390  break;
391  case 6: //quit
392  qDebug()<<"Quit";
393 
394  SendCommand("QREL");
395  tcpSocket->disconnectFromHost();
396  if(tcpSocket->state() != QAbstractSocket::UnconnectedState)
397  tcpSocket->waitForDisconnected();
398  SocketIsConnected = false;
399  qDebug()<< "Disconnect Server";
400  break;
401 
402  default:
403  qDebug()<< "Unknow Type";
404  break;
405  }
406  }
407  }// buffer is not empty and larger than 8 bytes
408 
409 }
410 
411 //*************************************************************************************************************
412 
414 {
415 
416 // qDebug()<<"Acq data from buffer [buffer size() =" << buffer.size()<<"]";
417  QByteArray DATA = buffer.left(tmp);
418  qDebug()<< "5.Readbytes:"<<DATA.size();
419  myBabyMEGInfo->MGH_LM_Send_DataPackage(DATA);
420 // myBabyMEGInfo->EnQueue(DATA);
421  buffer.remove(0,tmp);
422 // qDebug()<<"Rest buffer [buffer size() =" << buffer.size()<<"]";
423  numBlock ++;
424  qDebug()<< "Next Block ..." << numBlock;
425 // DATA.clear();
426 
427  ReadNextBlock(tmp);
428 }
429 
430 //*************************************************************************************************************
431 
433 {
434  QByteArray CMD1;
435  QByteArray DLEN1;
436  QByteArray DATA1;
437  int tmp1;
438  while (buffer.size()>=(tmp+8))
439  { // process the extra data block to reduce the load of data buffer
440  CMD1 = buffer.left(4);
441  qDebug()<<"CMD"<< CMD1;
442  if (CMD1 == "DATR")
443  {
444  DLEN1 = buffer.mid(4,4);
445  tmp1 = MGH_LM_Byte2Int(DLEN1);
446  qDebug() << "[2]First 4 bytes + length" << CMD1 << "["<<CMD1.toHex()<<"]";
447  qDebug() << "[2]Command[" << CMD1 <<"]";
448  qDebug() << "[2]Body Length[" << tmp1 << "]";
449 
450  buffer.remove(0,8);
451  DATA1 = buffer.left(tmp1);
452  myBabyMEGInfo->MGH_LM_Send_DataPackage(DATA1);
453 // myBabyMEGInfo->EnQueue(DATA1);
454  buffer.remove(0,tmp1);
455  qDebug()<<"End of DataPackeage" << buffer.left(3);
456  qDebug()<<"[2]Rest buffer [buffer size() =" << buffer.size()<<"]";
457  numBlock ++;
458  qDebug()<< "[2]Next Block ..." << numBlock;
459  }
460  else
461  {
462  qDebug()<<"[CMD1]"<<CMD1.toHex();
463  break;
464  }
465  qDebug()<<"[ReadNextBlock:buffer size]"<<buffer.size();
466  }
467  DATA1.clear();
468  CMD1.clear();
469  DLEN1.clear();
470 }
471 
472 //*************************************************************************************************************
473 
475 {
476  QByteArray array;
477  array.append(s);
478 
479  int WrtNum;
480 
481  if (tcpSocket->state()==QAbstractSocket::ConnectedState)
482  {
483  m_qMutex.lock();
484 
485 // qDebug()<<"[Send Command]"<<array;
486  WrtNum = tcpSocket->write(array,4);
487  if(WrtNum==-1)
488  {
489  qDebug()<<"Error for sending a command";
490  }
491  if(WrtNum != array.size())
492  {
493  qDebug()<<"Uncorrectly sending";
494  }
495  tcpSocket->flush();
496  tcpSocket->waitForBytesWritten();
497  m_qMutex.unlock();
498  qDebug()<<"[Done: Send Command]"<<array<<"[Send bytes]"<<WrtNum;
499 
500  }
501  else
502  {
503  qDebug()<<"Not in Connected state";
504  //re-connect to server
506  buffer.clear();
507  SendCommand("DATA");
508  }
509 // sleep(1);
510 }
511 
512 
513 //*************************************************************************************************************
514 
515 void BabyMEGClient::run()
516 {
517 
518 }
BabyMEGClient(int myPort, QObject *parent=0)
void MGH_LM_Parse_Para(QByteArray cmdstr)
void SendCommandToBabyMEG()
The BabyMEGClient class provides a TCP/IP communication between Qt and Labview.
Definition: babymeginfo.h:70
void ReadNextBlock(int tmp)
void HexDisplay(double a)
void DisConnectBabyMEG()
void SendCommandToBabyMEGShortConnection(QByteArray s)
void SetInfo(BabyMEGInfo *pInfo)
void ConnectToBabyMEG()
double MGH_LM_Byte2Double(QByteArray InByte)
int MGH_LM_Byte2Int(QByteArray InByte)
void SendCommand(QString s)
QByteArray MGH_LM_Int2Byte(int a)
void DispatchDataPackage(int tmp)
void MGH_LM_Send_DataPackage(QByteArray DATA)
Definition: babymeginfo.cpp:56
void MGH_LM_Send_CMDPackage(QByteArray DATA)
Definition: babymeginfo.cpp:49