canctrl.cpp 6.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259
  1. #include "canctrl.h"
  2. #include <memory>
  3. canctrl * gc;
  4. static iv::canstate::canstate proCanSt;
  5. void Listencansend0(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
  6. {
  7. iv::can::canmsg msg;
  8. if(false == msg.ParseFromArray(strdata,nSize))
  9. {
  10. std::cout<<"Listencansend Parse fail."<<std::endl;
  11. return;
  12. }
  13. gc->sendmsg(0,msg);
  14. }
  15. void Listencansend1(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
  16. {
  17. iv::can::canmsg msg;
  18. if(false == msg.ParseFromArray(strdata,nSize))
  19. {
  20. std::cout<<"Listencansend Parse fail."<<std::endl;
  21. return;
  22. }
  23. gc->sendmsg(1,msg);
  24. }
  25. canctrl::canctrl(const char * strmemsend0,const char * strmemrecv0,const char * strmemsend1,const char * strmemrecv1,const char * strcan0name,const char * strcan1name)
  26. {
  27. gc = this;
  28. mparecv0 = iv::modulecomm::RegisterSend(strmemrecv0,100000,3);
  29. mparecv1 = iv::modulecomm::RegisterSend(strmemrecv1,100000,3);
  30. mpcanState = iv::modulecomm::RegisterSend("canstate",18,3);
  31. mpasend0 = iv::modulecomm::RegisterRecv(strmemsend0,Listencansend0);
  32. mpasend1 = iv::modulecomm::RegisterRecv(strmemsend1,Listencansend1);
  33. mpcan = new nvcan(strcan0name,strcan1name);
  34. mspcan.reset(mpcan);
  35. connect(mpcan,SIGNAL(SIG_CANOPENSTATE(bool,int,const char*)),this,SLOT(onCANState(bool,int,const char*)));
  36. mpcan->startdev();
  37. mptheadstate = new std::thread(&canctrl::threadstate,this);
  38. }
  39. canctrl::~canctrl()
  40. {
  41. mpcan->stopdev();
  42. delete mpcan;
  43. mbstaterun = false;
  44. mptheadstate->join();
  45. iv::modulecomm::Unregister(mpasend0);
  46. iv::modulecomm::Unregister(mpcanState);
  47. iv::modulecomm::Unregister(mparecv0);
  48. }
  49. void canctrl::threadstate()
  50. {
  51. int ncount = 0;
  52. while(mbstaterun)
  53. {
  54. std::this_thread::sleep_for(std::chrono::milliseconds(100));
  55. ncount++;
  56. if(ncount>=10)
  57. {
  58. ncount = 0;
  59. proCanSt.set_b_canstate(true);
  60. int nsize = proCanSt.ByteSize();
  61. std::shared_ptr<char > strdata_ptr= std::shared_ptr<char>(new char[nsize]);
  62. if(proCanSt.SerializeToArray(strdata_ptr.get(),nsize))
  63. {
  64. iv::modulecomm::ModuleSendMsg(mpcanState,strdata_ptr.get(),nsize);
  65. }
  66. }
  67. }
  68. std::cout<<"threadstate exit."<<std::endl;
  69. }
  70. void canctrl::run()
  71. {
  72. QTime xTime;
  73. xTime.start();
  74. int nOldTime = xTime.elapsed();
  75. int i;
  76. while(!isInterruptionRequested())
  77. {
  78. if(mbCANOpen)
  79. {
  80. basecan_msg xmsg[2500];
  81. int nRec1,nRec2,nSend1,nSend2;
  82. if((nRec1 =mpcan->GetMessage(0,xmsg,2500))>0)
  83. {
  84. sharecanmsg(mparecv0,xmsg,nRec1,0);
  85. }
  86. nSend1 = 0;
  87. nSend2 = 0;
  88. msleep(5);
  89. }
  90. else
  91. {
  92. msleep(1);
  93. mpcan->mivlog->error("%s open can card fail",__func__);
  94. if(xTime.elapsed()>1000)
  95. {
  96. qDebug("Not Open CANCARD exceed 1 second. so exit program.");
  97. exit(-1);
  98. }
  99. }
  100. // mpcan->mfault->SetFaultState(0, 0, "ok");
  101. }
  102. qDebug("thread canctrl complete.");
  103. }
  104. void canctrl::onCANState(bool bCAN, int nR, const char *strres)
  105. {
  106. mbCANOpen = bCAN;
  107. mpcan->mivlog->info("can","canstate is %s ",strres);
  108. }
  109. void canctrl::sendmsg(int index, iv::can::canmsg xmsg)
  110. {
  111. std::vector<basecan_msg> * psendmsgvector;
  112. QMutex * pMutex;
  113. if(index == 0)
  114. {
  115. pMutex = &mMutexcan1;
  116. psendmsgvector = &msendmsgvector1;
  117. }
  118. else
  119. {
  120. if(index == 1)
  121. {
  122. pMutex = &mMutexcan2;
  123. psendmsgvector = &msendmsgvector2;
  124. }
  125. else
  126. {
  127. std::cout<<" canctrl::sendmsg "<<" index error. index: "<<index<<std::endl;
  128. return;
  129. }
  130. }
  131. if((int)psendmsgvector->size() > SENDMSGBUFSIZE)
  132. {
  133. mpcan->mivlog->warn("sendmsg buf full");
  134. return;
  135. }
  136. pMutex->lock();
  137. if(psendmsgvector->size() > 1000)psendmsgvector->clear();
  138. int i;
  139. for(i=0;i<xmsg.rawmsg_size();i++)
  140. {
  141. basecan_msg sendmsg;
  142. iv::can::canraw x;
  143. x.CopyFrom(xmsg.rawmsg(i));
  144. sendmsg.id = x.id();
  145. sendmsg.isExtern = x.bext();
  146. sendmsg.isRemote = x.bremote();
  147. sendmsg.mSetTime = QDateTime::currentMSecsSinceEpoch();
  148. int nlen = x.len();
  149. if((nlen < 0) || (nlen > 8))
  150. {
  151. nlen = 0;
  152. mpcan->mivlog->warn("sendmsg nlen err");
  153. continue;
  154. // mpcan->mfault->SetFaultState(1, 0, "sendmsg nlen err");
  155. }
  156. sendmsg.nLen = nlen;
  157. if(sendmsg.nLen > 0)
  158. {
  159. memcpy(sendmsg.data,x.data().data(),sendmsg.nLen);
  160. }
  161. psendmsgvector->push_back(sendmsg);
  162. }
  163. pMutex->unlock();
  164. if(mbCANOpen)
  165. {
  166. pMutex->lock();
  167. for(i=0;i<psendmsgvector->size();i++)
  168. {
  169. mpcan->SetMessage(index,&(psendmsgvector->at(i)));
  170. }
  171. psendmsgvector->clear();
  172. pMutex->unlock();
  173. mpcan->CmdSend();
  174. }
  175. }
  176. void canctrl::sharecanmsg(void *xpa, basecan_msg * pxmsg,int ncount,int nch)
  177. {
  178. iv::can::canmsg xmsg;
  179. int i;
  180. for(i=0;i<ncount;i++)
  181. {
  182. iv::can::canraw * praw = xmsg.add_rawmsg();
  183. praw->set_id(pxmsg[i].id);
  184. praw->set_data(pxmsg[i].data,8);
  185. praw->set_bext(pxmsg[i].isExtern);
  186. praw->set_bremote(pxmsg[i].isRemote);
  187. praw->set_rectime(QDateTime::currentMSecsSinceEpoch());
  188. praw->set_len(pxmsg[i].nLen);
  189. }
  190. xmsg.set_channel(nch);
  191. xmsg.set_index(mindex[nch]);
  192. mindex[nch]++;
  193. int nsize = xmsg.ByteSize();
  194. char * strdata = new char[xmsg.ByteSize()];
  195. if(xmsg.SerializePartialToArray(strdata,nsize))
  196. {
  197. iv::modulecomm::ModuleSendMsg(xpa,strdata,nsize);
  198. }
  199. else
  200. {
  201. mpcan->mivlog->warn("canctrl::sharecanmsg serialize error");
  202. // mpcan->mfault->SetFaultState(1, 0, "sharecanmsg serialize error");
  203. }
  204. delete strdata;
  205. }