MNE-CPP  beta 1.0
babymeg.cpp
1 //=============================================================================================================
38 //*************************************************************************************************************
39 //=============================================================================================================
40 // INCLUDES
41 //=============================================================================================================
42 
43 #include "babymeg.h"
44 
45 
46 //*************************************************************************************************************
47 //=============================================================================================================
48 // FIFF INCLUDES
49 //=============================================================================================================
50 
51 #include <fiff/fiff.h>
52 #include <fiff/fiff_types.h>
53 #include <utils/ioutils.h>
54 
55 
56 //*************************************************************************************************************
57 //=============================================================================================================
58 // MNE INCLUDES
59 //=============================================================================================================
60 
61 #include <mne/mne.h>
63 
64 
65 //*************************************************************************************************************
66 //=============================================================================================================
67 // QT INCLUDES
68 //=============================================================================================================
69 
70 #include <QtCore/QtPlugin>
71 #include <QFile>
72 #include <QDebug>
73 
74 
75 //*************************************************************************************************************
76 //=============================================================================================================
77 // USED NAMESPACES
78 //=============================================================================================================
79 
80 using namespace BabyMEGPlugin;
81 using namespace FIFFLIB;
82 using namespace MNELIB;
83 using namespace UTILSLIB;
84 
85 
86 //*************************************************************************************************************
87 //=============================================================================================================
88 // DEFINE MEMBER METHODS
89 //=============================================================================================================
90 
92 :pInfo(NULL)
93 , m_bIsRunning(false)
94 , m_uiBufferSampleSize(1000)
95 , m_pRawMatrixBuffer(NULL)
96 {
97  //BabyMEG Inits
98  pInfo = new BabyMEGInfo();
99  connect(pInfo, &BabyMEGInfo::fiffInfoAvailable, this, &BabyMEG::setFiffInfo);
100  connect(pInfo, &BabyMEGInfo::SendDataPackage, this, &BabyMEG::setFiffData);
101  connect(pInfo, &BabyMEGInfo::SendCMDPackage, this, &BabyMEG::setCMDData);
102 
103  myClient = new BabyMEGClient(6340,this);
104  myClient->SetInfo(pInfo);
105  myClient->start();
106  myClientComm = new BabyMEGClient(6341,this);
107  myClientComm->SetInfo(pInfo);
108  myClientComm->start();
109 
110  myClientComm->SendCommandToBabyMEGShortConnection("INFO");
111 
112 // myClient->ConnectToBabyMEG();
114 // m_bIsRunning = true;
115 // QThread::start();
116 
117  this->init();
118 }
119 
120 
121 //*************************************************************************************************************
122 
124 {
125  qDebug() << "Destroy BabyMEG::~BabyMEG()";
126 
127  if(myClient)
128  delete myClient;
129  if(myClientComm)
130  delete myClientComm;
131  if(pInfo)
132  delete pInfo;
133 
134  m_bIsRunning = false;
135  QThread::wait();
136 }
137 
138 //*************************************************************************************************************
139 void BabyMEG::comFLL(Command p_command)
140 {
141  qDebug()<<"FLL commands";
142 
143  QString t_sFLLControlCommand = p_command.pValues()[0].toString();
144 
145 
146  qDebug() << "BabyMeg Received" << t_sFLLControlCommand;
147  int strlen = t_sFLLControlCommand.size();
148  QByteArray Scmd = myClientComm->MGH_LM_Int2Byte(strlen);
149  QByteArray SC = QByteArray("COMS")+Scmd;
150  SC.append(t_sFLLControlCommand);
151  myClientComm->SendCommandToBabyMEGShortConnection(SC);
152 }
153 
154 
155 //*************************************************************************************************************
156 
157 void BabyMEG::setCMDData(QByteArray DATA)
158 {
159  qDebug()<<"------"<<DATA;
160  m_commandManager["FLL"].reply(DATA);
161  qDebug()<<"Data has been received.";
162 /*
163  int exec,a,b;
164  QByteArray chan;
165  int nChan;
166  //QList<QByteArray> mdat;
167  //qDebug()<<"setCMDData"<<DATA;
168  QByteArray rcmd = DATA.left(4);
169  QString sbuf;
170 
171  exec =0;
172  if (rcmd == "INIT") exec = 2;
173  if (rcmd == "SYNC") exec = 3;
174 
175  switch (exec)
176  {
177  case 1:
178  //find the repetition number for sending the channel information
179  a = DATA.indexOf("[",0);
180  b = DATA.indexOf("#",0);
181 
182  chan = DATA.mid(a+1,b-a-1);
183  nChan = chan.toInt();
184 // //qDebug()<<"a, b, Chan"<<a<<b<<nChan;
185 // mdat = DATA.split('#');
186 // //qDebug()<<"size of list mdat"<<mdat.size();
187 // //qDebug()<<"mdat"<<mdat[0]<<mdat[1]<<mdat[2];
188 // for (int i=1; i<nChan+1; i++){
189 // //Send information per channel
190 // sbuf.clear();
191 // sbuf = "INIT|"+chan+"|"+tr("%1").arg(i)+"|"+mdat[i];
192 // //qDebug()<<sbuf;
193 // m_commandManager["FLL"].reply(sbuf);
194 // }
195  sbuf.clear();
196  sbuf = "INIT|"+chan;
197  m_commandManager["FLL"].reply(sbuf);
198 
199  break;
200  case 2:
201  m_commandManager["FLL"].reply(DATA);
202  break;
203  default:
204  m_commandManager["FLL"].reply(DATA);
205  qDebug()<<"-----"<<DATA;
206  break;
207  }
208  */
209 }
210 
211 
212 //*************************************************************************************************************
213 
214 void BabyMEG::comBufsize(Command p_command)
215 {
216 
217  qDebug() << "Here Inside void BabyMEG::comBufsize(Command p_command)";
218 
219  //ToDO JSON
220 
221  quint32 t_uiBuffSize = p_command.pValues()[0].toUInt();
222 
223  if(t_uiBuffSize > 0)
224  {
225 // printf("bufsize %d\n", t_uiBuffSize);
226 
227 // bool t_bWasRunning = m_bIsRunning;
228 
229 // if(m_bIsRunning)
230 // this->stop();
231 
232 // m_uiBufferSampleSize = t_uiBuffSize;
233 
234 // if(t_bWasRunning)
235 // this->start();
236 
237  QString str = QString("\tSet %1 buffer sample size to %2 samples\r\n\n").arg(getName()).arg(t_uiBuffSize);
238 
239  m_commandManager["bufsize"].reply(str);
240  }
241  else
242  m_commandManager["bufsize"].reply("Buffer size not set\r\n");
243 }
244 
245 
246 //*************************************************************************************************************
247 
248 void BabyMEG::comGetBufsize(Command p_command)
249 {
250  bool t_bCommandIsJson = p_command.isJson();
251  if(t_bCommandIsJson)
252  {
253  //
254  //create JSON help object
255  //
256  QJsonObject t_qJsonObjectRoot;
257  t_qJsonObjectRoot.insert("bufsize", QJsonValue((double)m_uiBufferSampleSize));
258  QJsonDocument p_qJsonDocument(t_qJsonObjectRoot);
259 
260  m_commandManager["getbufsize"].reply(p_qJsonDocument.toJson());
261  }
262  else
263  {
264  QString str = QString("\t%1\r\n\n").arg(m_uiBufferSampleSize);
265  m_commandManager["getbufsize"].reply(str);
266  }
267 }
268 
269 
270 //*************************************************************************************************************
271 
272 void BabyMEG::connectCommandManager()
273 {
274  //Connect slots
275  QObject::connect(&m_commandManager["bufsize"], &Command::executed, this, &BabyMEG::comBufsize);
276  QObject::connect(&m_commandManager["getbufsize"], &Command::executed, this, &BabyMEG::comGetBufsize);
277  QObject::connect(&m_commandManager["FLL"], &Command::executed, this, &BabyMEG::comFLL);
278 }
279 
280 
281 //*************************************************************************************************************
282 
283 ConnectorID BabyMEG::getConnectorID() const
284 {
285  return _BABYMEG;
286 }
287 
288 
289 //*************************************************************************************************************
290 
291 const char* BabyMEG::getName() const
292 {
293  return "BabyMEG";
294 }
295 
296 
297 //*************************************************************************************************************
298 
299 void BabyMEG::setFiffInfo(FiffInfo p_FiffInfo)
300 {
301  m_FiffInfoBabyMEG = p_FiffInfo;
302 
303  m_uiBufferSampleSize = pInfo->dataLength;
304 }
305 
306 //*************************************************************************************************************
307 
308 void BabyMEG::setFiffData(QByteArray DATA)
309 {
310 // qDebug() << "[BabyMEG] Data Size:"<<DATA.size();
311 
312  //get the first byte -- the data format
313  int dformat = DATA.left(1).toInt();
314 
315  DATA.remove(0,1);
316  qint32 rows = m_FiffInfoBabyMEG.nchan;
317  qint32 cols = (DATA.size()/dformat)/rows;
318 
319  qDebug() << "[BabyMEG] Matrix " << rows << "x" << cols << " [Data bytes:" << dformat << "]";
320 
321  MatrixXf rawData(Map<MatrixXf>( (float*)DATA.data(),rows, cols ));
322 
323  for(qint32 i = 0; i < rows*cols; ++i)
324  IOUtils::swap_floatp(rawData.data()+i);
325 
326 // std::cout << "first ten elements \n" << rawData.block(0,0,1,10) << std::endl;
327 
328  if(!m_pRawMatrixBuffer)
329  m_pRawMatrixBuffer = CircularMatrixBuffer<float>::SPtr(new CircularMatrixBuffer<float>(40, rows, cols));
330 
331  m_pRawMatrixBuffer->push(&rawData);
332 
333 }
334 
335 
336 //*************************************************************************************************************
337 
338 void BabyMEG::init()
339 {
340 
342 // if(m_pRawMatrixBuffer)
343 // delete m_pRawMatrixBuffer;
344 // m_pRawMatrixBuffer = NULL;
345 
346 // if(!m_RawInfo.isEmpty())
347 // m_pRawMatrixBuffer = new RawMatrixBuffer(RAW_BUFFFER_SIZE, m_RawInfo.info.nchan, this->m_uiBufferSampleSize);
348 }
349 
350 
351 //*************************************************************************************************************
352 
353 bool BabyMEG::start()
354 {
355  this->init();
356 
357  // Start threads
358  m_bIsRunning = true;
359  QThread::start();
360 
361  myClient->ConnectToBabyMEG();
362 
363  return true;
364 }
365 
366 
367 //*************************************************************************************************************
368 
369 bool BabyMEG::stop()
370 {
371  m_bIsRunning = false;
372  QThread::wait();
373 
374  myClient->DisConnectBabyMEG();
375 
376  return true;
377 }
378 
379 
380 //*************************************************************************************************************
381 
382 void BabyMEG::info(qint32 ID)
383 {
384  if(m_FiffInfoBabyMEG.isEmpty())
385  m_FiffInfoBabyMEG = pInfo->getFiffInfo();
386 
387  if(!m_FiffInfoBabyMEG.isEmpty())
388  emit remitMeasInfo(ID, m_FiffInfoBabyMEG);
389 }
390 
391 
392 //*************************************************************************************************************
393 
395 {
396  m_bIsRunning = true;
397 // quint32 count = 0;
398 
399  while(m_bIsRunning)
400  {
401  if(m_pRawMatrixBuffer)
402  {
403  QSharedPointer<Eigen::MatrixXf> t_pRawBuffer(new Eigen::MatrixXf(m_pRawMatrixBuffer->pop()));
404 
405 // ++count;
406 // printf("%d raw buffer (%d x %d) generated\r\n", count, t_pRawBuffer->rows(), t_pRawBuffer->cols());
407 // std::cout << "first 100 elements \n" << t_rawBuffer.block(0,0,1,100) << std::endl;
408 
409  emit remitRawBuffer(t_pRawBuffer);
410  }
411  }
412 }
FIFF measurement file information.
Definition: fiff_info.h:96
Old fiff_type declarations - replace them.
The BabyMEGClient class provides a TCP/IP communication between Qt and Labview.
Definition: babymeginfo.h:70
MNEEpochDataList class declaration.
void DisConnectBabyMEG()
void SendCommandToBabyMEGShortConnection(QByteArray s)
void SetInfo(BabyMEGInfo *pInfo)
QSharedPointer< CircularMatrixBuffer > SPtr
void ConnectToBabyMEG()
CommandManager m_commandManager
Definition: IConnector.h:228
void push(const Matrix< _Tp, Dynamic, Dynamic > *pMatrix)
virtual void run()
Definition: babymeg.cpp:394
Matrix< _Tp, Dynamic, Dynamic > pop()
The BabyMEGClient class provides a TCP/IP communication between Qt and Labview.
Definition: babymegclient.h:70
QList< QVariant > & pValues()
Definition: command.h:370
Definition: fiff.h:98
static void swap_floatp(float *source)
Definition: ioutils.cpp:196
QByteArray MGH_LM_Int2Byte(int a)
void executed(Command p_command)
FIFF class declaration, which provides static wrapper functions to stay consistent with mne matlab to...
IOUtils class declaration.