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.

355 lines
11 KiB

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