You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

347 lines
11 KiB

2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
  1. #include "zcanreceiver.hpp"
  2. #ifdef HAL_CAN_MODULE_ENABLED
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. using namespace iflytop;
  7. using namespace zcr;
  8. #define TAG "ZCanCmder"
  9. #define OVER_TIME_MS 5
  10. uint16_t CanPacketRxBuffer::get_packetindex() {
  11. Cmdheader_t *cmdheader = (Cmdheader_t *)rxdata;
  12. return cmdheader->packetindex;
  13. }
  14. uint16_t CanPacketRxBuffer::get_cmdid() {
  15. Cmdheader_t *cmdheader = (Cmdheader_t *)rxdata;
  16. return cmdheader->cmdid;
  17. }
  18. uint8_t CanPacketRxBuffer::get_subcmdid() {
  19. Cmdheader_t *cmdheader = (Cmdheader_t *)rxdata;
  20. return cmdheader->subcmdid;
  21. }
  22. uint8_t CanPacketRxBuffer::get_packetType() {
  23. Cmdheader_t *cmdheader = (Cmdheader_t *)rxdata;
  24. return cmdheader->packetType;
  25. }
  26. uint8_t *CanPacketRxBuffer::get_data() {
  27. Cmdheader_t *cmdheader = (Cmdheader_t *)rxdata;
  28. return cmdheader->data;
  29. }
  30. uint16_t CanPacketRxBuffer::get_datalen() {
  31. Cmdheader_t *cmdheader = (Cmdheader_t *)rxdata;
  32. return rxdataSize - sizeof(Cmdheader_t);
  33. }
  34. bool CanPacketRxBuffer::iscmd(CmdID_t id, uint8_t subcmdid) {
  35. Cmdheader_t *cmdheader = (Cmdheader_t *)rxdata;
  36. return cmdheader->cmdid == (uint16_t)id && cmdheader->subcmdid == subcmdid;
  37. }
  38. Cmdheader_t *CanPacketRxBuffer::get_cmdheader() {
  39. Cmdheader_t *cmdheader = (Cmdheader_t *)rxdata;
  40. return cmdheader;
  41. }
  42. ZCanCmder::CFG *ZCanCmder::createCFG(uint8_t deviceId) {
  43. CFG *cfg = new CFG();
  44. ZASSERT(cfg != NULL);
  45. cfg->deviceId = deviceId;
  46. #ifdef STM32F103xB
  47. cfg->canHandle = &hcan;
  48. #else
  49. cfg->canHandle = &hcan1;
  50. #endif
  51. cfg->canFilterIndex0 = 0;
  52. cfg->maxFilterNum = 7;
  53. cfg->rxfifoNum = CAN_RX_FIFO0;
  54. return cfg;
  55. }
  56. void ZCanCmder::init(CFG *cfg) {
  57. HAL_StatusTypeDef hal_status;
  58. m_config = cfg;
  59. /**
  60. * @brief ʼCAN
  61. */
  62. /**
  63. * @brief ʼϢbuf
  64. */
  65. m_canPacketRxBuffer[0].dataIsReady = false;
  66. m_canPacketRxBuffer[0].id = 1; // ֻ����������������Ϣ
  67. m_canPacketRxBuffer[0].m_canPacketNum = 0;
  68. /**
  69. * @brief ʼ
  70. */
  71. hal_status = initializeFilter();
  72. if (hal_status != HAL_OK) {
  73. ZLOGE(TAG, "start can initializeFilter fail\r\n");
  74. return;
  75. }
  76. /**
  77. * @brief CAN
  78. */
  79. hal_status = HAL_CAN_Start(m_config->canHandle); // ����CAN
  80. if (hal_status != HAL_OK) {
  81. ZLOGE(TAG, "start can fail\r\n");
  82. return;
  83. }
  84. /**
  85. * @brief ص
  86. */
  87. ZCanIRQDispatcher::instance().regListener(this);
  88. HAL_StatusTypeDef status = activateRxIT();
  89. if (status != HAL_OK) {
  90. ZLOGE(TAG, "activateRxIT fail\r\n");
  91. return;
  92. }
  93. // ZHALCORE::getInstance()->regPeriodJob([this](ZHALCORE::Context &context) { loop(); }, 0);
  94. }
  95. HAL_StatusTypeDef ZCanCmder::initializeFilter() {
  96. /**
  97. * @brief ID֡ʽ
  98. * [ 27:0 ]
  99. * [ STDID ] [ EXTID ]
  100. * [11 :9] [8:6] [5:0] [17:16] [15:8] [7:0]
  101. * ȼ ֡ ĿID ԴID
  102. */
  103. HAL_StatusTypeDef HAL_Status;
  104. CAN_FilterTypeDef sFilterConfig;
  105. uint32_t filterId;
  106. uint32_t mask;
  107. memset(&sFilterConfig, 0, sizeof(sFilterConfig));
  108. sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK; // ��ΪMASKģʽ
  109. sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; // CAN_FILTERSCALE_16BIT
  110. sFilterConfig.FilterFIFOAssignment = m_config->rxfifoNum; // ������������rxfifoNum
  111. sFilterConfig.FilterActivation = ENABLE; // ����������
  112. sFilterConfig.SlaveStartFilterBank = m_config->maxFilterNum; // slave filter start index
  113. /*******************************************************************************
  114. * Ϣ *
  115. *******************************************************************************/
  116. filterId = (0); //
  117. mask = (0); //
  118. sFilterConfig.FilterBank = m_config->canFilterIndex0; //
  119. sFilterConfig.FilterMaskIdLow = mask & 0xffff; //
  120. sFilterConfig.FilterMaskIdHigh = (mask & 0xffff0000) >> 16; //
  121. sFilterConfig.FilterIdLow = filterId & 0xffff; //
  122. sFilterConfig.FilterIdHigh = (filterId & 0xffff0000) >> 16; //
  123. HAL_Status = HAL_CAN_ConfigFilter(m_config->canHandle, &sFilterConfig);
  124. if (HAL_Status != HAL_OK) {
  125. ZLOGE(TAG, "HAL_CAN_ConfigFilter filter0 fail");
  126. return HAL_Status;
  127. }
  128. ZLOGI(TAG, "HAL_CAN_ConfigFilter filterID1 %08x", filterId >> 3);
  129. return HAL_Status;
  130. }
  131. void ZCanCmder::registerListener(ZCanCmderListener *listener) { m_listenerList.push_back(listener); }
  132. void ZCanCmder::regListener(zcan_cmder_listener_t listener) { m_listenerList2.push_back(listener); }
  133. void ZCanCmder::sendPacket(uint8_t *packet, size_t len) {
  134. /**
  135. * @brief
  136. */
  137. int npacket = len / 8 + (len % 8 == 0 ? 0 : 1);
  138. if (npacket > 255) {
  139. ZLOGE(TAG, "sendPacket fail, len:%d", len);
  140. return;
  141. }
  142. int finalpacketlen = len % 8 == 0 ? 8 : len % 8;
  143. for (uint8_t i = 0; i < npacket; i++) {
  144. bool suc = false;
  145. if (i == npacket - 1) {
  146. suc = sendPacketSub(npacket, i, packet + i * 8, finalpacketlen, OVER_TIME_MS);
  147. } else {
  148. suc = sendPacketSub(npacket, i, packet + i * 8, 8, OVER_TIME_MS);
  149. }
  150. if (!suc) {
  151. ZLOGE(TAG, "sendPacket fail, packet(%d:%d)", npacket, i);
  152. return;
  153. }
  154. }
  155. }
  156. void ZCanCmder::sendAck(Cmdheader_t *cmdheader, uint8_t *data, size_t len) {
  157. Cmdheader_t *txheader = (Cmdheader_t *)txbuff;
  158. memcpy(txheader, cmdheader, sizeof(Cmdheader_t));
  159. txheader->packetType = kpt_ack;
  160. memcpy(txheader->data, data, len);
  161. sendPacket(txbuff, sizeof(Cmdheader_t) + len);
  162. }
  163. void ZCanCmder::sendErrorAck(Cmdheader_t *cmdheader, int16_t errcode) {
  164. Cmdheader_t *txheader = (Cmdheader_t *)txbuff;
  165. memcpy(txheader, cmdheader, sizeof(Cmdheader_t));
  166. txheader->packetType = kpt_error_ack;
  167. sendPacket(txbuff, sizeof(Cmdheader_t) + 2);
  168. }
  169. bool ZCanCmder::sendPacketSub(int npacket, int packetIndex, uint8_t *packet, size_t len, int overtimems) {
  170. // ZLOGI(TAG, "sendPacketSub(%d:%d)", npacket, packetIndex);
  171. CAN_TxHeaderTypeDef pHeader;
  172. uint8_t aData[8] /*8byte table*/;
  173. uint32_t txMailBox = 0;
  174. uint32_t enterticket = zos_get_tick();
  175. memset(&pHeader, 0, sizeof(pHeader));
  176. memset(aData, 0, sizeof(aData));
  177. pHeader.StdId = 0x00;
  178. pHeader.ExtId = (m_config->deviceId << 16) | (npacket << 8) | packetIndex;
  179. pHeader.IDE = CAN_ID_EXT;
  180. pHeader.RTR = CAN_RTR_DATA;
  181. pHeader.DLC = len;
  182. pHeader.TransmitGlobalTime = DISABLE;
  183. memcpy(aData, packet, len);
  184. m_lastTransmitStatus = HAL_CAN_AddTxMessage(m_config->canHandle, &pHeader, aData, &txMailBox);
  185. if (m_lastTransmitStatus != HAL_OK) {
  186. ZLOGE(TAG, "HAL_CAN_AddTxMessage fail");
  187. return false;
  188. }
  189. while (HAL_CAN_IsTxMessagePending(m_config->canHandle, txMailBox)) {
  190. if (zos_haspassedms(enterticket) > (uint32_t)overtimems) {
  191. m_lastTransmitStatus = HAL_TIMEOUT;
  192. HAL_CAN_AbortTxRequest(m_config->canHandle, txMailBox);
  193. return false;
  194. }
  195. // m_os->sleepMS(1);
  196. }
  197. if (txPacketInterval_ms > 0) {
  198. osDelay(txPacketInterval_ms);
  199. }
  200. return true;
  201. }
  202. bool ZCanCmder::getRxMessage(CAN_RxHeaderTypeDef *pHeader, uint8_t aData[] /*8byte table*/) {
  203. /**
  204. * @brief ȡǰFIFOл˶֡
  205. */
  206. uint32_t level = HAL_CAN_GetRxFifoFillLevel(m_config->canHandle, m_config->rxfifoNum);
  207. if (level == 0) {
  208. return false;
  209. }
  210. HAL_StatusTypeDef HAL_RetVal;
  211. HAL_RetVal = HAL_CAN_GetRxMessage(m_config->canHandle, m_config->rxfifoNum, pHeader, aData);
  212. if (HAL_OK == HAL_RetVal) {
  213. // �������յ���can��������
  214. return true;
  215. }
  216. return false;
  217. }
  218. void ZCanCmder::STM32_HAL_onCAN_RxFifo0MsgPending(CAN_HandleTypeDef *canHandle) {
  219. /**
  220. * @brief ж
  221. */
  222. // ZLOG_INFO("%s\n", __FUNCTION__);
  223. // printf("------------------%s\n", __FUNCTION__);
  224. if (canHandle != m_config->canHandle) {
  225. return;
  226. }
  227. /**
  228. * @brief canյϢ
  229. */
  230. CAN_RxHeaderTypeDef pHeader;
  231. uint8_t aData[8] /*8byte table*/;
  232. while (getRxMessage(&pHeader, aData)) {
  233. /**
  234. * @brief Ϣʽ
  235. *
  236. * [2] [3bit] [8bit] [8bit] [8bit]
  237. * , from frameNum frameId
  238. */
  239. uint8_t from = (pHeader.ExtId >> 16 & 0xFF);
  240. uint8_t nframe = (pHeader.ExtId & 0xFF00) >> 8;
  241. uint8_t frameId = (pHeader.ExtId & 0x00FF);
  242. CanPacketRxBuffer *rxbuf = &m_canPacketRxBuffer[0];
  243. if (from != rxbuf->id) {
  244. // Ŀǰֻ����������������Ϣ
  245. continue;
  246. }
  247. if (rxbuf->dataIsReady) {
  248. // �ϴν��յ�����Ϣ��û�����ļ�����
  249. continue;
  250. }
  251. /**
  252. * @TODO:жǷ񶪰
  253. */
  254. if (frameId == 0) {
  255. rxbuf->m_canPacketNum = 0;
  256. }
  257. if (rxbuf->m_canPacketNum < 255) {
  258. rxbuf->m_canPacket[rxbuf->m_canPacketNum].pHeader = pHeader;
  259. memcpy(rxbuf->m_canPacket[rxbuf->m_canPacketNum].aData, aData, 8);
  260. rxbuf->m_canPacketNum++;
  261. }
  262. if (nframe == frameId + 1) {
  263. rxbuf->dataIsReady = true;
  264. }
  265. }
  266. // deactivateRxIT();
  267. }
  268. void ZCanCmder::STM32_HAL_onCAN_Error(CAN_HandleTypeDef *canHandle) {
  269. if (canHandle != m_config->canHandle) {
  270. return;
  271. }
  272. ZLOGE(TAG, "onCAN_Error\r\n");
  273. }
  274. void ZCanCmder::loop() {
  275. CanPacketRxBuffer *rxbuf = &m_canPacketRxBuffer[0];
  276. if (rxbuf->dataIsReady) {
  277. int dataoff = 0;
  278. for (size_t i = 0; i < rxbuf->m_canPacketNum; i++) {
  279. memcpy(rxbuf->rxdata + dataoff, rxbuf->m_canPacket[i].aData, rxbuf->m_canPacket[i].pHeader.DLC);
  280. dataoff += rxbuf->m_canPacket[i].pHeader.DLC;
  281. }
  282. rxbuf->rxdataSize = dataoff;
  283. for (auto &var : m_listenerList) {
  284. var->onRceivePacket(rxbuf);
  285. }
  286. for (auto &var : m_listenerList2) {
  287. var(rxbuf);
  288. }
  289. rxbuf->dataIsReady = false;
  290. }
  291. }
  292. HAL_StatusTypeDef ZCanCmder::activateRxIT() {
  293. HAL_StatusTypeDef hal_status = HAL_ERROR;
  294. if (m_config->rxfifoNum == CAN_RX_FIFO0) {
  295. hal_status = HAL_CAN_ActivateNotification(m_config->canHandle, CAN_IT_RX_FIFO0_MSG_PENDING);
  296. } else if (m_config->rxfifoNum == CAN_RX_FIFO1) {
  297. hal_status = HAL_CAN_ActivateNotification(m_config->canHandle, CAN_IT_RX_FIFO1_MSG_PENDING);
  298. } else {
  299. ZLOGE(TAG, "start can HAL_CAN_ActivateNotification CAN_IT_RX_FIFO0_MSG_PENDING fail\r\n");
  300. return hal_status;
  301. }
  302. return hal_status;
  303. }
  304. HAL_StatusTypeDef ZCanCmder::deactivateRxIT() {
  305. HAL_StatusTypeDef hal_status = HAL_ERROR;
  306. if (m_config->rxfifoNum == CAN_RX_FIFO0) {
  307. hal_status = HAL_CAN_DeactivateNotification(m_config->canHandle, CAN_IT_RX_FIFO0_MSG_PENDING);
  308. } else if (m_config->rxfifoNum == CAN_RX_FIFO1) {
  309. hal_status = HAL_CAN_DeactivateNotification(m_config->canHandle, CAN_IT_RX_FIFO1_MSG_PENDING);
  310. } else {
  311. ZLOGE(TAG, "start can HAL_CAN_ActivateNotification CAN_IT_RX_FIFO0_MSG_PENDING fail\r\n");
  312. return hal_status;
  313. }
  314. return hal_status;
  315. }
  316. #endif