Fawwaz Nadzmy / mbed-STM

mbed library sources. Supersedes mbed-src.

Fork of mbed-dev by mbed official

targets/TARGET_NUVOTON/TARGET_NUC472/device/StdDriver/nuc472_can.c@152:9a67f0b066fc, 2016-12-15 (annotated)

Committer:
<>
Date:
Thu Dec 15 11:48:27 2016 +0000
Revision:
152:9a67f0b066fc
Parent:
150:02e0a0aed4ec 
This updates the lib to the mbed lib v131

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 /**************************************************************************//**
<> 144:ef7eb2e8f9f7 2 * @file CAN.c
<> 144:ef7eb2e8f9f7 3 * @version V1.00
<> 144:ef7eb2e8f9f7 4 * $Revision: 14 $
<> 144:ef7eb2e8f9f7 5 * $Date: 14/10/06 5:38p $
<> 144:ef7eb2e8f9f7 6 * @brief NUC472/NUC442 CAN driver source file
<> 144:ef7eb2e8f9f7 7 *
<> 144:ef7eb2e8f9f7 8 * @note
<> 144:ef7eb2e8f9f7 9 * Copyright (C) 2013 Nuvoton Technology Corp. All rights reserved.
<> 144:ef7eb2e8f9f7 10 *****************************************************************************/
<> 144:ef7eb2e8f9f7 11
<> 144:ef7eb2e8f9f7 12 #include "NUC472_442.h"
<> 144:ef7eb2e8f9f7 13 /** @addtogroup NUC472_442_Device_Driver NUC472/NUC442 Device Driver
<> 144:ef7eb2e8f9f7 14 @{
<> 144:ef7eb2e8f9f7 15 */
<> 144:ef7eb2e8f9f7 16
<> 144:ef7eb2e8f9f7 17 /** @addtogroup NUC472_442_CAN_Driver CAN Driver
<> 144:ef7eb2e8f9f7 18 @{
<> 144:ef7eb2e8f9f7 19 */
<> 144:ef7eb2e8f9f7 20
<> 144:ef7eb2e8f9f7 21
<> 144:ef7eb2e8f9f7 22 /** @addtogroup NUC472_442_CAN_EXPORTED_FUNCTIONS CAN Exported Functions
<> 144:ef7eb2e8f9f7 23 @{
<> 144:ef7eb2e8f9f7 24 */
<> 144:ef7eb2e8f9f7 25
<> 144:ef7eb2e8f9f7 26 #include <stdio.h>
<> 144:ef7eb2e8f9f7 27
<> 144:ef7eb2e8f9f7 28
<> 144:ef7eb2e8f9f7 29 /// @cond HIDDEN_SYMBOLS
<> 144:ef7eb2e8f9f7 30
<> 144:ef7eb2e8f9f7 31
<> 144:ef7eb2e8f9f7 32 static uint32_t GetFreeIF(CAN_T *tCAN);
<> 144:ef7eb2e8f9f7 33
<> 144:ef7eb2e8f9f7 34
<> 144:ef7eb2e8f9f7 35 //#define DEBUG_PRINTF printf
<> 144:ef7eb2e8f9f7 36 #define DEBUG_PRINTF(...)
<> 144:ef7eb2e8f9f7 37
<> 144:ef7eb2e8f9f7 38 /**
<> 144:ef7eb2e8f9f7 39 * @brief Check if SmartCard slot is presented.
<> 144:ef7eb2e8f9f7 40 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 41 * @retval 0 IF0 is free
<> 144:ef7eb2e8f9f7 42 * @retval 1 IF1 is free
<> 144:ef7eb2e8f9f7 43 * @retval 2 No IF is free
<> 144:ef7eb2e8f9f7 44 * @details Search the first free message interface, starting from 0.
<> 144:ef7eb2e8f9f7 45 */
<> 144:ef7eb2e8f9f7 46 static uint32_t GetFreeIF(CAN_T *tCAN)
<> 144:ef7eb2e8f9f7 47 {
<> 144:ef7eb2e8f9f7 48 if((tCAN->IF[0].CREQ & CAN_IF_CREQ_BUSY_Msk) == 0)
<> 144:ef7eb2e8f9f7 49 return 0;
<> 144:ef7eb2e8f9f7 50 else if((tCAN->IF[1].CREQ & CAN_IF_CREQ_BUSY_Msk) == 0)
<> 144:ef7eb2e8f9f7 51 return 1;
<> 144:ef7eb2e8f9f7 52 else
<> 144:ef7eb2e8f9f7 53 return 2;
<> 144:ef7eb2e8f9f7 54 }
<> 144:ef7eb2e8f9f7 55
<> 144:ef7eb2e8f9f7 56 /**
<> 144:ef7eb2e8f9f7 57 * @brief Enter initialization mode
<> 144:ef7eb2e8f9f7 58 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 59 * @return None
<> 144:ef7eb2e8f9f7 60 * @details This function is used to set CAN to enter initialization mode and enable access bit timing
<> 144:ef7eb2e8f9f7 61 * register. After bit timing configuration ready, user must call CAN_LeaveInitMode()
<> 144:ef7eb2e8f9f7 62 * to leave initialization mode and lock bit timing register to let new configuration
<> 144:ef7eb2e8f9f7 63 * take effect.
<> 144:ef7eb2e8f9f7 64 */
<> 144:ef7eb2e8f9f7 65 void CAN_EnterInitMode(CAN_T *tCAN)
<> 144:ef7eb2e8f9f7 66 {
<> 144:ef7eb2e8f9f7 67 tCAN->CON |= CAN_CON_INIT_Msk;
<> 144:ef7eb2e8f9f7 68 tCAN->CON |= CAN_CON_CCE_Msk;
<> 144:ef7eb2e8f9f7 69 }
<> 144:ef7eb2e8f9f7 70
<> 144:ef7eb2e8f9f7 71
<> 144:ef7eb2e8f9f7 72 /**
<> 144:ef7eb2e8f9f7 73 * @brief Leave initialization mode
<> 144:ef7eb2e8f9f7 74 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 75 * @return None
<> 144:ef7eb2e8f9f7 76 * @details This function is used to set CAN to leave initialization mode to let
<> 144:ef7eb2e8f9f7 77 * bit timing configuration take effect after configuration ready.
<> 144:ef7eb2e8f9f7 78 */
<> 144:ef7eb2e8f9f7 79 void CAN_LeaveInitMode(CAN_T *tCAN)
<> 144:ef7eb2e8f9f7 80 {
<> 144:ef7eb2e8f9f7 81 tCAN->CON &= (~(CAN_CON_INIT_Msk | CAN_CON_CCE_Msk));
<> 144:ef7eb2e8f9f7 82
<> 144:ef7eb2e8f9f7 83 while(tCAN->CON & CAN_CON_INIT_Msk); /* Check INIT bit is released */
<> 144:ef7eb2e8f9f7 84 }
<> 144:ef7eb2e8f9f7 85
<> 144:ef7eb2e8f9f7 86 /**
<> 144:ef7eb2e8f9f7 87 * @brief Wait message into message buffer in basic mode.
<> 144:ef7eb2e8f9f7 88 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 89 * @return None
<> 144:ef7eb2e8f9f7 90 * @details This function is used to wait message into message buffer in basic mode. Please notice the
<> 144:ef7eb2e8f9f7 91 * function is polling NEWDAT bit of MCON register by while loop and it is used in basic mode.
<> 144:ef7eb2e8f9f7 92 */
<> 144:ef7eb2e8f9f7 93 void CAN_WaitMsg(CAN_T *tCAN)
<> 144:ef7eb2e8f9f7 94 {
<> 144:ef7eb2e8f9f7 95 tCAN->STATUS = 0x0; /* clr status */
<> 144:ef7eb2e8f9f7 96
<> 144:ef7eb2e8f9f7 97 while (1) {
<> 144:ef7eb2e8f9f7 98 if(tCAN->IF[1].MCON & CAN_IF_MCON_NEWDAT_Msk) { /* check new data */
<> 144:ef7eb2e8f9f7 99 DEBUG_PRINTF("New Data IN\n");
<> 144:ef7eb2e8f9f7 100 break;
<> 144:ef7eb2e8f9f7 101 }
<> 144:ef7eb2e8f9f7 102 if(tCAN->STATUS & CAN_STATUS_RXOK_Msk)
<> 144:ef7eb2e8f9f7 103 DEBUG_PRINTF("Rx OK\n");
<> 144:ef7eb2e8f9f7 104
<> 144:ef7eb2e8f9f7 105 if(tCAN->STATUS & CAN_STATUS_LEC_Msk) {
<> 144:ef7eb2e8f9f7 106 DEBUG_PRINTF("Error\n");
<> 144:ef7eb2e8f9f7 107 }
<> 144:ef7eb2e8f9f7 108 }
<> 144:ef7eb2e8f9f7 109 }
<> 144:ef7eb2e8f9f7 110
<> 144:ef7eb2e8f9f7 111 /**
<> 144:ef7eb2e8f9f7 112 * @brief Get current bit rate
<> 144:ef7eb2e8f9f7 113 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 114 * @return Current Bit-Rate (kilo bit per second)
<> 144:ef7eb2e8f9f7 115 * @details Return current CAN bit rate according to the user bit-timing parameter settings
<> 144:ef7eb2e8f9f7 116 */
<> 144:ef7eb2e8f9f7 117 uint32_t CAN_GetCANBitRate(CAN_T *tCAN)
<> 144:ef7eb2e8f9f7 118 {
<> 144:ef7eb2e8f9f7 119 uint8_t u8Tseg1,u8Tseg2;
<> 144:ef7eb2e8f9f7 120 uint32_t u32Bpr;
<> 144:ef7eb2e8f9f7 121
<> 144:ef7eb2e8f9f7 122 u8Tseg1 = (tCAN->BTIME & CAN_BTIME_TSEG1_Msk) >> CAN_BTIME_TSEG1_Pos;
<> 144:ef7eb2e8f9f7 123 u8Tseg2 = (tCAN->BTIME & CAN_BTIME_TSEG2_Msk) >> CAN_BTIME_TSEG2_Pos;
<> 144:ef7eb2e8f9f7 124 u32Bpr = (tCAN->BTIME & CAN_BTIME_BRP_Msk) | (tCAN->BRPE << 6);
<> 144:ef7eb2e8f9f7 125
<> 144:ef7eb2e8f9f7 126 return (SystemCoreClock/(u32Bpr+1)/(u8Tseg1 + u8Tseg2 + 3));
<> 144:ef7eb2e8f9f7 127 }
<> 144:ef7eb2e8f9f7 128
<> 144:ef7eb2e8f9f7 129 /**
<> 144:ef7eb2e8f9f7 130 * @brief Switch the CAN into test mode.
<> 144:ef7eb2e8f9f7 131 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 132 * @param[in] u8TestMask Specifies the configuration in test modes
<> 144:ef7eb2e8f9f7 133 * CAN_TEST_BASIC_Msk : Enable basic mode of test mode
<> 144:ef7eb2e8f9f7 134 * CAN_TESTR_SILENT_Msk : Enable silent mode of test mode
<> 144:ef7eb2e8f9f7 135 * CAN_TESTR_LBACK_Msk : Enable Loop Back Mode of test mode
<> 144:ef7eb2e8f9f7 136 * CAN_TESTR_TX0_Msk/CAN_TESTR_TX1_Msk: Control CAN_TX pin bit field
<> 144:ef7eb2e8f9f7 137 * @return None
<> 144:ef7eb2e8f9f7 138 * @details Switch the CAN into test mode. There are four test mode (BASIC/SILENT/LOOPBACK/
<> 144:ef7eb2e8f9f7 139 * LOOPBACK combined SILENT/CONTROL_TX_PIN)could be selected. After setting test mode,user
<> 144:ef7eb2e8f9f7 140 * must call CAN_LeaveInitMode() to let the setting take effect.
<> 144:ef7eb2e8f9f7 141 */
<> 144:ef7eb2e8f9f7 142 void CAN_EnterTestMode(CAN_T *tCAN, uint8_t u8TestMask)
<> 144:ef7eb2e8f9f7 143 {
<> 144:ef7eb2e8f9f7 144 tCAN->CON |= CAN_CON_TEST_Msk;
<> 144:ef7eb2e8f9f7 145 tCAN->TEST = u8TestMask;
<> 144:ef7eb2e8f9f7 146 }
<> 144:ef7eb2e8f9f7 147
<> 144:ef7eb2e8f9f7 148
<> 144:ef7eb2e8f9f7 149 /**
<> 144:ef7eb2e8f9f7 150 * @brief Leave the test mode
<> 144:ef7eb2e8f9f7 151 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 152 * @return None
<> 144:ef7eb2e8f9f7 153 * @details This function is used to Leave the test mode (switch into normal mode).
<> 144:ef7eb2e8f9f7 154 */
<> 144:ef7eb2e8f9f7 155 void CAN_LeaveTestMode(CAN_T *tCAN)
<> 144:ef7eb2e8f9f7 156 {
<> 144:ef7eb2e8f9f7 157 tCAN->CON |= CAN_CON_TEST_Msk;
<> 144:ef7eb2e8f9f7 158 tCAN->TEST &= ~(CAN_TEST_LBACK_Msk | CAN_TEST_SILENT_Msk | CAN_TEST_BASIC_Msk);
<> 144:ef7eb2e8f9f7 159 tCAN->CON &= (~CAN_CON_TEST_Msk);
<> 144:ef7eb2e8f9f7 160 }
<> 144:ef7eb2e8f9f7 161
<> 144:ef7eb2e8f9f7 162 /**
<> 144:ef7eb2e8f9f7 163 * @brief Get the waiting status of a received message.
<> 144:ef7eb2e8f9f7 164 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 165 * @param[in] u8MsgObj Specifies the Message object number, from 0 to 31.
<> 144:ef7eb2e8f9f7 166 * @retval non-zero The corresponding message object has a new data bit is set.
<> 144:ef7eb2e8f9f7 167 * @retval 0 No message object has new data.
<> 144:ef7eb2e8f9f7 168 * @details This function is used to get the waiting status of a received message.
<> 144:ef7eb2e8f9f7 169 */
<> 144:ef7eb2e8f9f7 170 uint32_t CAN_IsNewDataReceived(CAN_T *tCAN, uint8_t u8MsgObj)
<> 144:ef7eb2e8f9f7 171 {
<> 144:ef7eb2e8f9f7 172 return (u8MsgObj < 16 ? tCAN->NDAT1 & (1 << u8MsgObj) : tCAN->NDAT2 & (1 << (u8MsgObj-16)));
<> 144:ef7eb2e8f9f7 173 }
<> 144:ef7eb2e8f9f7 174
<> 144:ef7eb2e8f9f7 175
<> 144:ef7eb2e8f9f7 176 /**
<> 144:ef7eb2e8f9f7 177 * @brief Send CAN message in BASIC mode of test mode
<> 144:ef7eb2e8f9f7 178 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 179 * @param[in] pCanMsg Pointer to the message structure containing data to transmit.
<> 144:ef7eb2e8f9f7 180 * @return TRUE: Transmission OK
<> 144:ef7eb2e8f9f7 181 * FALSE: Check busy flag of interface 0 is timeout
<> 144:ef7eb2e8f9f7 182 * @details The function is used to send CAN message in BASIC mode of test mode. Before call the API,
<> 144:ef7eb2e8f9f7 183 * the user should be call CAN_EnterTestMode(CAN_TESTR_BASIC) and let CAN controller enter
<> 144:ef7eb2e8f9f7 184 * basic mode of test mode. Please notice IF1 Registers used as Tx Buffer in basic mode.
<> 144:ef7eb2e8f9f7 185 */
<> 144:ef7eb2e8f9f7 186 int32_t CAN_BasicSendMsg(CAN_T *tCAN, STR_CANMSG_T* pCanMsg)
<> 144:ef7eb2e8f9f7 187 {
<> 144:ef7eb2e8f9f7 188 uint32_t i=0;
<> 144:ef7eb2e8f9f7 189 while(tCAN->IF[0].CREQ & CAN_IF_CREQ_BUSY_Msk);
<> 144:ef7eb2e8f9f7 190
<> 144:ef7eb2e8f9f7 191 tCAN->STATUS &= (~CAN_STATUS_TXOK_Msk);
<> 144:ef7eb2e8f9f7 192
<> 144:ef7eb2e8f9f7 193 tCAN->IF[0].CMASK = CAN_IF_CMASK_WRRD_Msk;
<> 144:ef7eb2e8f9f7 194
<> 144:ef7eb2e8f9f7 195 if (pCanMsg->IdType == CAN_STD_ID) {
<> 144:ef7eb2e8f9f7 196 /* standard ID*/
<> 144:ef7eb2e8f9f7 197 tCAN->IF[0].ARB1 = 0;
<> 144:ef7eb2e8f9f7 198 tCAN->IF[0].ARB2 = (((pCanMsg->Id)&0x7FF)<<2) ;
<> 144:ef7eb2e8f9f7 199 } else {
<> 144:ef7eb2e8f9f7 200 /* extended ID*/
<> 144:ef7eb2e8f9f7 201 tCAN->IF[0].ARB1 = (pCanMsg->Id)&0xFFFF;
<> 144:ef7eb2e8f9f7 202 tCAN->IF[0].ARB2 = ((pCanMsg->Id)&0x1FFF0000)>>16 | CAN_IF_ARB2_XTD_Msk;
<> 144:ef7eb2e8f9f7 203
<> 144:ef7eb2e8f9f7 204 }
<> 144:ef7eb2e8f9f7 205
<> 144:ef7eb2e8f9f7 206 if(pCanMsg->FrameType)
<> 144:ef7eb2e8f9f7 207 tCAN->IF[0].ARB2 |= CAN_IF_ARB2_DIR_Msk;
<> 144:ef7eb2e8f9f7 208 else
<> 144:ef7eb2e8f9f7 209 tCAN->IF[0].ARB2 &= (~CAN_IF_ARB2_DIR_Msk);
<> 144:ef7eb2e8f9f7 210
<> 144:ef7eb2e8f9f7 211 tCAN->IF[0].MCON = (tCAN->IF[0].MCON & (~CAN_IF_MCON_DLC_Msk)) | pCanMsg->DLC;
<> 144:ef7eb2e8f9f7 212 tCAN->IF[0].DAT_A1 = ((uint16_t)pCanMsg->Data[1]<<8) | pCanMsg->Data[0];
<> 144:ef7eb2e8f9f7 213 tCAN->IF[0].DAT_A2 = ((uint16_t)pCanMsg->Data[3]<<8) | pCanMsg->Data[2];
<> 144:ef7eb2e8f9f7 214 tCAN->IF[0].DAT_B1 = ((uint16_t)pCanMsg->Data[5]<<8) | pCanMsg->Data[4];
<> 144:ef7eb2e8f9f7 215 tCAN->IF[0].DAT_B2 = ((uint16_t)pCanMsg->Data[7]<<8) | pCanMsg->Data[6];
<> 144:ef7eb2e8f9f7 216
<> 144:ef7eb2e8f9f7 217 /* request transmission*/
<> 144:ef7eb2e8f9f7 218 tCAN->IF[0].CREQ &= (~CAN_IF_CREQ_BUSY_Msk);
<> 144:ef7eb2e8f9f7 219 if(tCAN->IF[0].CREQ & CAN_IF_CREQ_BUSY_Msk) {
<> 144:ef7eb2e8f9f7 220 DEBUG_PRINTF("Cannot clear busy for sending ...\n");
<> 144:ef7eb2e8f9f7 221 return FALSE;
<> 144:ef7eb2e8f9f7 222 }
<> 144:ef7eb2e8f9f7 223
<> 144:ef7eb2e8f9f7 224 tCAN->IF[0].CREQ |= CAN_IF_CREQ_BUSY_Msk; // sending
<> 144:ef7eb2e8f9f7 225
<> 144:ef7eb2e8f9f7 226 for ( i=0; i<0xFFFFF; i++) {
<> 144:ef7eb2e8f9f7 227 if((tCAN->IF[0].CREQ & CAN_IF_CREQ_BUSY_Msk) == 0) break;
<> 144:ef7eb2e8f9f7 228 }
<> 144:ef7eb2e8f9f7 229
<> 144:ef7eb2e8f9f7 230 if ( i >= 0xFFFFF ) {
<> 144:ef7eb2e8f9f7 231 DEBUG_PRINTF("Cannot send out...\n");
<> 144:ef7eb2e8f9f7 232 return FALSE;
<> 144:ef7eb2e8f9f7 233 }
<> 144:ef7eb2e8f9f7 234
<> 144:ef7eb2e8f9f7 235 return TRUE;
<> 144:ef7eb2e8f9f7 236 }
<> 144:ef7eb2e8f9f7 237
<> 144:ef7eb2e8f9f7 238
<> 144:ef7eb2e8f9f7 239 /**
<> 144:ef7eb2e8f9f7 240 * @brief Get a message information in BASIC mode.
<> 144:ef7eb2e8f9f7 241 *
<> 144:ef7eb2e8f9f7 242 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 243 * @param[out] pCanMsg Pointer to the message structure where received data is copied.
<> 144:ef7eb2e8f9f7 244 *
<> 144:ef7eb2e8f9f7 245 * @return FALSE No any message received. \n
<> 144:ef7eb2e8f9f7 246 * TRUE Receive a message success.
<> 144:ef7eb2e8f9f7 247 *
<> 144:ef7eb2e8f9f7 248 */
<> 144:ef7eb2e8f9f7 249 int32_t CAN_BasicReceiveMsg(CAN_T *tCAN, STR_CANMSG_T* pCanMsg)
<> 144:ef7eb2e8f9f7 250 {
<> 144:ef7eb2e8f9f7 251 if((tCAN->IF[1].MCON & CAN_IF_MCON_NEWDAT_Msk) == 0) { /* In basic mode, receive data always save in IF2 */
<> 144:ef7eb2e8f9f7 252 return FALSE;
<> 144:ef7eb2e8f9f7 253 }
<> 144:ef7eb2e8f9f7 254
<> 144:ef7eb2e8f9f7 255 tCAN->STATUS &= (~CAN_STATUS_RXOK_Msk);
<> 144:ef7eb2e8f9f7 256
<> 144:ef7eb2e8f9f7 257 tCAN->IF[1].CMASK = CAN_IF_CMASK_ARB_Msk
<> 144:ef7eb2e8f9f7 258 | CAN_IF_CMASK_CONTROL_Msk
<> 144:ef7eb2e8f9f7 259 | CAN_IF_CMASK_DATAA_Msk
<> 144:ef7eb2e8f9f7 260 | CAN_IF_CMASK_DATAB_Msk;
<> 144:ef7eb2e8f9f7 261
<> 144:ef7eb2e8f9f7 262 if((tCAN->IF[1].ARB2 & CAN_IF_ARB2_XTD_Msk) == 0) {
<> 144:ef7eb2e8f9f7 263 /* standard ID*/
<> 144:ef7eb2e8f9f7 264 pCanMsg->IdType = CAN_STD_ID;
<> 144:ef7eb2e8f9f7 265 pCanMsg->Id = (tCAN->IF[1].ARB2 >> 2) & 0x07FF;
<> 144:ef7eb2e8f9f7 266
<> 144:ef7eb2e8f9f7 267 } else {
<> 144:ef7eb2e8f9f7 268 /* extended ID*/
<> 144:ef7eb2e8f9f7 269 pCanMsg->IdType = CAN_EXT_ID;
<> 144:ef7eb2e8f9f7 270 pCanMsg->Id = (tCAN->IF[1].ARB2 & 0x1FFF)<<16;
<> 144:ef7eb2e8f9f7 271 pCanMsg->Id |= (uint32_t)tCAN->IF[1].ARB1;
<> 144:ef7eb2e8f9f7 272 }
<> 144:ef7eb2e8f9f7 273
<> 144:ef7eb2e8f9f7 274 pCanMsg->FrameType = !((tCAN->IF[1].ARB2 & CAN_IF_ARB2_DIR_Msk) >> CAN_IF_ARB2_DIR_Pos);
<> 144:ef7eb2e8f9f7 275
<> 144:ef7eb2e8f9f7 276 pCanMsg->DLC = tCAN->IF[1].MCON & CAN_IF_MCON_DLC_Msk;
<> 144:ef7eb2e8f9f7 277 pCanMsg->Data[0] = tCAN->IF[1].DAT_A1 & CAN_IF_DAT_A1_DATA0_Msk;
<> 144:ef7eb2e8f9f7 278 pCanMsg->Data[1] = (tCAN->IF[1].DAT_A1 & CAN_IF_DAT_A1_DATA1_Msk) >> CAN_IF_DAT_A1_DATA1_Pos;
<> 144:ef7eb2e8f9f7 279 pCanMsg->Data[2] = tCAN->IF[1].DAT_A2 & CAN_IF_DAT_A2_DATA2_Msk;
<> 144:ef7eb2e8f9f7 280 pCanMsg->Data[3] = (tCAN->IF[1].DAT_A2 & CAN_IF_DAT_A2_DATA3_Msk) >> CAN_IF_DAT_A2_DATA3_Pos;
<> 144:ef7eb2e8f9f7 281 pCanMsg->Data[4] = tCAN->IF[1].DAT_B1 & CAN_IF_DAT_B1_DATA4_Msk;
<> 144:ef7eb2e8f9f7 282 pCanMsg->Data[5] = (tCAN->IF[1].DAT_B1 & CAN_IF_DAT_B1_DATA5_Msk) >> CAN_IF_DAT_B1_DATA5_Pos;
<> 144:ef7eb2e8f9f7 283 pCanMsg->Data[6] = tCAN->IF[1].DAT_B2 & CAN_IF_DAT_B2_DATA6_Msk;
<> 144:ef7eb2e8f9f7 284 pCanMsg->Data[7] = (tCAN->IF[1].DAT_B2 & CAN_IF_DAT_B2_DATA7_Msk) >> CAN_IF_DAT_B2_DATA7_Pos;
<> 144:ef7eb2e8f9f7 285
<> 144:ef7eb2e8f9f7 286 return TRUE;
<> 144:ef7eb2e8f9f7 287 }
<> 144:ef7eb2e8f9f7 288
<> 144:ef7eb2e8f9f7 289 /**
<> 144:ef7eb2e8f9f7 290 * @brief Set Rx message object
<> 144:ef7eb2e8f9f7 291 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 292 * @param[in] u8MsgObj Specifies the Message object number, from 0 to 31.
<> 144:ef7eb2e8f9f7 293 * @param[in] u8idType Specifies the identifier type of the frames that will be transmitted
<> 144:ef7eb2e8f9f7 294 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 295 * CAN_STD_ID (standard ID, 11-bit)
<> 144:ef7eb2e8f9f7 296 * CAN_EXT_ID (extended ID, 29-bit)
<> 144:ef7eb2e8f9f7 297 * @param[in] u32id Specifies the identifier used for acceptance filtering.
<> 144:ef7eb2e8f9f7 298 * @param[in] u8singleOrFifoLast Specifies the end-of-buffer indicator.
<> 144:ef7eb2e8f9f7 299 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 300 * TRUE: for a single receive object or a FIFO receive object that is the last one of the FIFO.
<> 144:ef7eb2e8f9f7 301 * FALSE: for a FIFO receive object that is not the last one.
<> 144:ef7eb2e8f9f7 302 * @retval TRUE SUCCESS
<> 144:ef7eb2e8f9f7 303 * @retval FALSE No useful interface
<> 144:ef7eb2e8f9f7 304 * @details The function is used to configure a receive message object.
<> 144:ef7eb2e8f9f7 305 */
<> 144:ef7eb2e8f9f7 306 int32_t CAN_SetRxMsgObj(CAN_T *tCAN, uint8_t u8MsgObj, uint8_t u8idType, uint32_t u32id, uint8_t u8singleOrFifoLast)
<> 144:ef7eb2e8f9f7 307 {
<> 144:ef7eb2e8f9f7 308 uint8_t u8MsgIfNum=0;
<> 144:ef7eb2e8f9f7 309
<> 144:ef7eb2e8f9f7 310 if ((u8MsgIfNum = GetFreeIF(tCAN)) == 2) { /* Check Free Interface for configure */
<> 144:ef7eb2e8f9f7 311 return FALSE;
<> 144:ef7eb2e8f9f7 312 }
<> 144:ef7eb2e8f9f7 313 /* Command Setting */
<> 144:ef7eb2e8f9f7 314 tCAN->IF[u8MsgIfNum].CMASK = CAN_IF_CMASK_WRRD_Msk | CAN_IF_CMASK_MASK_Msk | CAN_IF_CMASK_ARB_Msk |
<> 144:ef7eb2e8f9f7 315 CAN_IF_CMASK_CONTROL_Msk | CAN_IF_CMASK_DATAA_Msk | CAN_IF_CMASK_DATAB_Msk;
<> 144:ef7eb2e8f9f7 316
<> 144:ef7eb2e8f9f7 317 if (u8idType == CAN_STD_ID) { /* According STD/EXT ID format,Configure Mask and Arbitration register */
<> 144:ef7eb2e8f9f7 318 tCAN->IF[u8MsgIfNum].ARB1 = 0;
<> 144:ef7eb2e8f9f7 319 tCAN->IF[u8MsgIfNum].ARB2 = CAN_IF_ARB2_MSGVAL_Msk | (u32id & 0x7FF)<< 2;
<> 144:ef7eb2e8f9f7 320 } else {
<> 144:ef7eb2e8f9f7 321 tCAN->IF[u8MsgIfNum].ARB1 = u32id & 0xFFFF;
<> 144:ef7eb2e8f9f7 322 tCAN->IF[u8MsgIfNum].ARB2 = CAN_IF_ARB2_MSGVAL_Msk | CAN_IF_ARB2_XTD_Msk | (u32id & 0x1FFF0000)>>16;
<> 144:ef7eb2e8f9f7 323 }
<> 144:ef7eb2e8f9f7 324
<> 144:ef7eb2e8f9f7 325 tCAN->IF[u8MsgIfNum].MCON |= CAN_IF_MCON_UMASK_Msk | CAN_IF_MCON_RXIE_Msk;
<> 144:ef7eb2e8f9f7 326 if(u8singleOrFifoLast)
<> 144:ef7eb2e8f9f7 327 tCAN->IF[u8MsgIfNum].MCON |= CAN_IF_MCON_EOB_Msk;
<> 144:ef7eb2e8f9f7 328 else
<> 144:ef7eb2e8f9f7 329 tCAN->IF[u8MsgIfNum].MCON &= (~CAN_IF_MCON_EOB_Msk);
<> 144:ef7eb2e8f9f7 330
<> 144:ef7eb2e8f9f7 331 tCAN->IF[u8MsgIfNum].DAT_A1 = 0;
<> 144:ef7eb2e8f9f7 332 tCAN->IF[u8MsgIfNum].DAT_A2 = 0;
<> 144:ef7eb2e8f9f7 333 tCAN->IF[u8MsgIfNum].DAT_B1 = 0;
<> 144:ef7eb2e8f9f7 334 tCAN->IF[u8MsgIfNum].DAT_B2 = 0;
<> 144:ef7eb2e8f9f7 335
<> 144:ef7eb2e8f9f7 336 tCAN->IF[u8MsgIfNum].CREQ = 1 + u8MsgObj;
<> 144:ef7eb2e8f9f7 337
<> 144:ef7eb2e8f9f7 338 return TRUE;
<> 144:ef7eb2e8f9f7 339 }
<> 144:ef7eb2e8f9f7 340
<> 144:ef7eb2e8f9f7 341
<> 144:ef7eb2e8f9f7 342 /**
<> 144:ef7eb2e8f9f7 343 * @brief Gets the message
<> 144:ef7eb2e8f9f7 344 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 345 * @param[in] u8MsgObj Specifies the Message object number, from 0 to 31.
<> 144:ef7eb2e8f9f7 346 * @param[in] u8Release Specifies the message release indicator.
<> 144:ef7eb2e8f9f7 347 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 348 * TRUE: the message object is released when getting the data.
<> 144:ef7eb2e8f9f7 349 * FALSE:the message object is not released.
<> 144:ef7eb2e8f9f7 350 * @param[out] pCanMsg Pointer to the message structure where received data is copied.
<> 144:ef7eb2e8f9f7 351 * @retval TRUE Success
<> 144:ef7eb2e8f9f7 352 * @retval FALSE No any message received
<> 144:ef7eb2e8f9f7 353 * @details Gets the message, if received.
<> 144:ef7eb2e8f9f7 354 */
<> 144:ef7eb2e8f9f7 355 int32_t CAN_ReadMsgObj(CAN_T *tCAN, uint8_t u8MsgObj, uint8_t u8Release, STR_CANMSG_T* pCanMsg)
<> 144:ef7eb2e8f9f7 356 {
<> 144:ef7eb2e8f9f7 357 if (!CAN_IsNewDataReceived(tCAN, u8MsgObj)) {
<> 144:ef7eb2e8f9f7 358 return FALSE;
<> 144:ef7eb2e8f9f7 359 }
<> 144:ef7eb2e8f9f7 360
<> 144:ef7eb2e8f9f7 361 tCAN->STATUS &= (~CAN_STATUS_RXOK_Msk);
<> 144:ef7eb2e8f9f7 362
<> 144:ef7eb2e8f9f7 363 /* read the message contents*/
<> 144:ef7eb2e8f9f7 364 tCAN->IF[1].CMASK = CAN_IF_CMASK_MASK_Msk
<> 144:ef7eb2e8f9f7 365 | CAN_IF_CMASK_ARB_Msk
<> 144:ef7eb2e8f9f7 366 | CAN_IF_CMASK_CONTROL_Msk
<> 144:ef7eb2e8f9f7 367 | CAN_IF_CMASK_CLRINTPND_Msk
<> 144:ef7eb2e8f9f7 368 | (u8Release ? CAN_IF_CMASK_TXRQSTNEWDAT_Msk : 0)
<> 144:ef7eb2e8f9f7 369 | CAN_IF_CMASK_DATAA_Msk
<> 144:ef7eb2e8f9f7 370 | CAN_IF_CMASK_DATAB_Msk;
<> 144:ef7eb2e8f9f7 371
<> 144:ef7eb2e8f9f7 372 tCAN->IF[1].CREQ = 1 + u8MsgObj;
<> 144:ef7eb2e8f9f7 373
<> 144:ef7eb2e8f9f7 374 while (tCAN->IF[1].CREQ & CAN_IF_CREQ_BUSY_Msk) {
<> 144:ef7eb2e8f9f7 375 /*Wait*/
<> 144:ef7eb2e8f9f7 376 }
<> 144:ef7eb2e8f9f7 377
<> 144:ef7eb2e8f9f7 378 if ((tCAN->IF[1].ARB2 & CAN_IF_ARB2_XTD_Msk) == 0) {
<> 144:ef7eb2e8f9f7 379 /* standard ID*/
<> 144:ef7eb2e8f9f7 380 pCanMsg->IdType = CAN_STD_ID;
<> 144:ef7eb2e8f9f7 381 pCanMsg->Id = (tCAN->IF[1].ARB2 & CAN_IF_ARB2_ID_Msk) >> 2;
<> 144:ef7eb2e8f9f7 382 } else {
<> 144:ef7eb2e8f9f7 383 /* extended ID*/
<> 144:ef7eb2e8f9f7 384 pCanMsg->IdType = CAN_EXT_ID;
<> 144:ef7eb2e8f9f7 385 pCanMsg->Id = (((tCAN->IF[1].ARB2) & 0x1FFF)<<16) | tCAN->IF[1].ARB1;
<> 144:ef7eb2e8f9f7 386 }
<> 144:ef7eb2e8f9f7 387
<> 144:ef7eb2e8f9f7 388 pCanMsg->DLC = tCAN->IF[1].MCON & CAN_IF_MCON_DLC_Msk;
<> 144:ef7eb2e8f9f7 389 pCanMsg->Data[0] = tCAN->IF[1].DAT_A1 & CAN_IF_DAT_A1_DATA0_Msk;
<> 144:ef7eb2e8f9f7 390 pCanMsg->Data[1] = (tCAN->IF[1].DAT_A1 & CAN_IF_DAT_A1_DATA1_Msk) >> CAN_IF_DAT_A1_DATA1_Pos;
<> 144:ef7eb2e8f9f7 391 pCanMsg->Data[2] = tCAN->IF[1].DAT_A2 & CAN_IF_DAT_A2_DATA2_Msk;
<> 144:ef7eb2e8f9f7 392 pCanMsg->Data[3] = (tCAN->IF[1].DAT_A2 & CAN_IF_DAT_A2_DATA3_Msk) >> CAN_IF_DAT_A2_DATA3_Pos;
<> 144:ef7eb2e8f9f7 393 pCanMsg->Data[4] = tCAN->IF[1].DAT_B1 & CAN_IF_DAT_B1_DATA4_Msk;
<> 144:ef7eb2e8f9f7 394 pCanMsg->Data[5] = (tCAN->IF[1].DAT_B1 & CAN_IF_DAT_B1_DATA5_Msk) >> CAN_IF_DAT_B1_DATA5_Pos;
<> 144:ef7eb2e8f9f7 395 pCanMsg->Data[6] = tCAN->IF[1].DAT_B2 & CAN_IF_DAT_B2_DATA6_Msk;
<> 144:ef7eb2e8f9f7 396 pCanMsg->Data[7] = (tCAN->IF[1].DAT_B2 & CAN_IF_DAT_B2_DATA7_Msk) >> CAN_IF_DAT_B2_DATA7_Pos;
<> 144:ef7eb2e8f9f7 397
<> 144:ef7eb2e8f9f7 398 return TRUE;
<> 144:ef7eb2e8f9f7 399 }
<> 144:ef7eb2e8f9f7 400
<> 144:ef7eb2e8f9f7 401 /// @endcond HIDDEN_SYMBOLS
<> 144:ef7eb2e8f9f7 402
<> 144:ef7eb2e8f9f7 403
<> 144:ef7eb2e8f9f7 404 /**
<> 144:ef7eb2e8f9f7 405 * @brief The function is used to set bus timing parameter according current clock and target baud-rate.
<> 144:ef7eb2e8f9f7 406 *
<> 144:ef7eb2e8f9f7 407 * @param[in] tCAN The base address of can module
<> 144:ef7eb2e8f9f7 408 * @param[in] u32BaudRate The target CAN baud-rate. The range of u32BaudRate is 1~1000KHz
<> 144:ef7eb2e8f9f7 409 *
<> 144:ef7eb2e8f9f7 410 * @return u32CurrentBitRate Real baud-rate value
<> 144:ef7eb2e8f9f7 411 */
<> 144:ef7eb2e8f9f7 412 uint32_t CAN_SetBaudRate(CAN_T *tCAN, uint32_t u32BaudRate)
<> 144:ef7eb2e8f9f7 413 {
<> 144:ef7eb2e8f9f7 414 uint8_t u8Tseg1,u8Tseg2;
<> 144:ef7eb2e8f9f7 415 uint32_t u32Brp;
<> 144:ef7eb2e8f9f7 416 uint32_t u32Value;
<> 144:ef7eb2e8f9f7 417
<> 144:ef7eb2e8f9f7 418 CAN_EnterInitMode(tCAN);
<> 144:ef7eb2e8f9f7 419
<> 144:ef7eb2e8f9f7 420 SystemCoreClockUpdate();
<> 144:ef7eb2e8f9f7 421
<> 150:02e0a0aed4ec 422 #if 0 // original implementation got 5% inaccuracy.
<> 144:ef7eb2e8f9f7 423 u32Value = SystemCoreClock;
<> 144:ef7eb2e8f9f7 424
<> 144:ef7eb2e8f9f7 425 if(u32BaudRate * 8 < (u32Value/2)) {
<> 144:ef7eb2e8f9f7 426 u8Tseg1 = 2;
<> 144:ef7eb2e8f9f7 427 u8Tseg2 = 3;
<> 144:ef7eb2e8f9f7 428 } else {
<> 144:ef7eb2e8f9f7 429 u8Tseg1 = 2;
<> 144:ef7eb2e8f9f7 430 u8Tseg2 = 1;
<> 144:ef7eb2e8f9f7 431 }
<> 150:02e0a0aed4ec 432 #else
<> 150:02e0a0aed4ec 433 u32Value = SystemCoreClock / u32BaudRate;
<> 150:02e0a0aed4ec 434 /* Fix for most standard baud rates, include 125K */
<> 144:ef7eb2e8f9f7 435
<> 150:02e0a0aed4ec 436 u8Tseg1 = 3;
<> 150:02e0a0aed4ec 437 u8Tseg2 = 2;
<> 150:02e0a0aed4ec 438 while(1)
<> 150:02e0a0aed4ec 439 {
<> 150:02e0a0aed4ec 440 if(((u32Value % (u8Tseg1 + u8Tseg2 + 3)) == 0) | (u8Tseg1 >= 15))
<> 150:02e0a0aed4ec 441 break;
<> 150:02e0a0aed4ec 442
<> 150:02e0a0aed4ec 443 u8Tseg1++;
<> 150:02e0a0aed4ec 444
<> 150:02e0a0aed4ec 445 if((u32Value % (u8Tseg1 + u8Tseg2 + 3)) == 0)
<> 150:02e0a0aed4ec 446 break;
<> 150:02e0a0aed4ec 447
<> 150:02e0a0aed4ec 448 if(u8Tseg2 < 7)
<> 150:02e0a0aed4ec 449 u8Tseg2++;
<> 150:02e0a0aed4ec 450 }
<> 150:02e0a0aed4ec 451 #endif
<> 144:ef7eb2e8f9f7 452 u32Brp = SystemCoreClock/(u32BaudRate) / (u8Tseg1 + u8Tseg2 + 3) -1;
<> 144:ef7eb2e8f9f7 453
<> 144:ef7eb2e8f9f7 454 u32Value = ((uint32_t)u8Tseg2 << CAN_BTIME_TSEG2_Pos) | ((uint32_t)u8Tseg1 << CAN_BTIME_TSEG1_Pos) |
<> 144:ef7eb2e8f9f7 455 (u32Brp & CAN_BTIME_BRP_Msk) | (tCAN->BTIME & CAN_BTIME_SJW_Msk);
<> 144:ef7eb2e8f9f7 456 tCAN->BTIME = u32Value;
<> 144:ef7eb2e8f9f7 457 tCAN->BRPE = (u32Brp >> 6) & 0x0F;
<> 144:ef7eb2e8f9f7 458
<> 144:ef7eb2e8f9f7 459 CAN_LeaveInitMode(tCAN);
<> 144:ef7eb2e8f9f7 460
<> 144:ef7eb2e8f9f7 461 return (CAN_GetCANBitRate(tCAN));
<> 144:ef7eb2e8f9f7 462
<> 144:ef7eb2e8f9f7 463 }
<> 144:ef7eb2e8f9f7 464
<> 144:ef7eb2e8f9f7 465 /**
<> 144:ef7eb2e8f9f7 466 * @brief The function is used to disable all CAN interrupt.
<> 144:ef7eb2e8f9f7 467 *
<> 144:ef7eb2e8f9f7 468 * @param[in] tCAN The base address of can module
<> 144:ef7eb2e8f9f7 469 *
<> 144:ef7eb2e8f9f7 470 * @return None
<> 144:ef7eb2e8f9f7 471 */
<> 144:ef7eb2e8f9f7 472 void CAN_Close(CAN_T *tCAN)
<> 144:ef7eb2e8f9f7 473 {
<> 144:ef7eb2e8f9f7 474 CAN_DisableInt(tCAN, (CAN_CON_IE_Msk|CAN_CON_SIE_Msk|CAN_CON_EIE_Msk));
<> 144:ef7eb2e8f9f7 475 }
<> 144:ef7eb2e8f9f7 476
<> 144:ef7eb2e8f9f7 477 /**
<> 144:ef7eb2e8f9f7 478 * @brief The function is sets bus timing parameter according current clock and target baud-rate. And set CAN operation mode.
<> 144:ef7eb2e8f9f7 479 *
<> 144:ef7eb2e8f9f7 480 * @param[in] tCAN The base address of can module
<> 144:ef7eb2e8f9f7 481 * @param[in] u32BaudRate The target CAN baud-rate. The range of u32BaudRate is 1~1000KHz
<> 144:ef7eb2e8f9f7 482 * @param[in] u32Mode The CAN operation mode. ( \ref CAN_NORMAL_MODE / \ref CAN_BASIC_MODE)
<> 144:ef7eb2e8f9f7 483 *
<> 144:ef7eb2e8f9f7 484 * @return u32CurrentBitRate Real baud-rate value
<> 144:ef7eb2e8f9f7 485 */
<> 144:ef7eb2e8f9f7 486 uint32_t CAN_Open(CAN_T *tCAN, uint32_t u32BaudRate, uint32_t u32Mode)
<> 144:ef7eb2e8f9f7 487 {
<> 144:ef7eb2e8f9f7 488 uint32_t u32CurrentBitRate;
<> 144:ef7eb2e8f9f7 489
<> 144:ef7eb2e8f9f7 490 u32CurrentBitRate = CAN_SetBaudRate(tCAN, u32BaudRate);
<> 144:ef7eb2e8f9f7 491
<> 144:ef7eb2e8f9f7 492 if(u32Mode == CAN_BASIC_MODE)
<> 144:ef7eb2e8f9f7 493 CAN_EnterTestMode(tCAN, CAN_TEST_BASIC_Msk);
<> 144:ef7eb2e8f9f7 494
<> 144:ef7eb2e8f9f7 495 return u32CurrentBitRate;
<> 144:ef7eb2e8f9f7 496 }
<> 144:ef7eb2e8f9f7 497
<> 144:ef7eb2e8f9f7 498 /**
<> 144:ef7eb2e8f9f7 499 * @brief The function is used to configure a transmit object.
<> 144:ef7eb2e8f9f7 500 *
<> 144:ef7eb2e8f9f7 501 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 502 * @param[in] u32MsgNum Specifies the Message object number, from 0 to 31
<> 144:ef7eb2e8f9f7 503 * @param[in] pCanMsg Pointer to the message structure where received data is copied.
<> 144:ef7eb2e8f9f7 504 *
<> 144:ef7eb2e8f9f7 505 * @return FALSE: No useful interface. \n
<> 144:ef7eb2e8f9f7 506 * TRUE : Config message object success.
<> 144:ef7eb2e8f9f7 507 *
<> 144:ef7eb2e8f9f7 508 */
<> 144:ef7eb2e8f9f7 509 int32_t CAN_SetTxMsg(CAN_T *tCAN, uint32_t u32MsgNum , STR_CANMSG_T* pCanMsg)
<> 144:ef7eb2e8f9f7 510 {
<> 144:ef7eb2e8f9f7 511 uint8_t u8MsgIfNum=0;
<> 144:ef7eb2e8f9f7 512 uint32_t i=0;
<> 144:ef7eb2e8f9f7 513
<> 144:ef7eb2e8f9f7 514 while((u8MsgIfNum = GetFreeIF(tCAN)) == 2) {
<> 144:ef7eb2e8f9f7 515 i++;
<> 144:ef7eb2e8f9f7 516 if(i > 0x10000000)
<> 144:ef7eb2e8f9f7 517 return FALSE;
<> 144:ef7eb2e8f9f7 518 }
<> 144:ef7eb2e8f9f7 519
<> 144:ef7eb2e8f9f7 520 /* update the contents needed for transmission*/
<> 144:ef7eb2e8f9f7 521 tCAN->IF[u8MsgIfNum].CMASK = 0xF3; /*CAN_CMASK_WRRD_Msk | CAN_CMASK_MASK_Msk | CAN_CMASK_ARB_Msk
<> 144:ef7eb2e8f9f7 522 | CAN_CMASK_CONTROL_Msk | CAN_CMASK_DATAA_Msk | CAN_CMASK_DATAB_Msk ; */
<> 144:ef7eb2e8f9f7 523
<> 144:ef7eb2e8f9f7 524 if (pCanMsg->IdType == CAN_STD_ID) {
<> 144:ef7eb2e8f9f7 525 /* standard ID*/
<> 144:ef7eb2e8f9f7 526 tCAN->IF[u8MsgIfNum].ARB1 = 0;
<> 144:ef7eb2e8f9f7 527 tCAN->IF[u8MsgIfNum].ARB2 = (((pCanMsg->Id)&0x7FF)<<2) | CAN_IF_ARB2_DIR_Msk | CAN_IF_ARB2_MSGVAL_Msk;
<> 144:ef7eb2e8f9f7 528 } else {
<> 144:ef7eb2e8f9f7 529 /* extended ID*/
<> 144:ef7eb2e8f9f7 530 tCAN->IF[u8MsgIfNum].ARB1 = (pCanMsg->Id)&0xFFFF;
<> 144:ef7eb2e8f9f7 531 tCAN->IF[u8MsgIfNum].ARB2 = ((pCanMsg->Id)&0x1FFF0000)>>16 | CAN_IF_ARB2_DIR_Msk
<> 144:ef7eb2e8f9f7 532 | CAN_IF_ARB2_XTD_Msk | CAN_IF_ARB2_MSGVAL_Msk;
<> 144:ef7eb2e8f9f7 533 }
<> 144:ef7eb2e8f9f7 534
<> 144:ef7eb2e8f9f7 535 if(pCanMsg->FrameType)
<> 144:ef7eb2e8f9f7 536 tCAN->IF[u8MsgIfNum].ARB2 |= CAN_IF_ARB2_DIR_Msk;
<> 144:ef7eb2e8f9f7 537 else
<> 144:ef7eb2e8f9f7 538 tCAN->IF[u8MsgIfNum].ARB2 &= (~CAN_IF_ARB2_DIR_Msk);
<> 144:ef7eb2e8f9f7 539
<> 144:ef7eb2e8f9f7 540 tCAN->IF[u8MsgIfNum].DAT_A1 = ((uint16_t)pCanMsg->Data[1]<<8) | pCanMsg->Data[0];
<> 144:ef7eb2e8f9f7 541 tCAN->IF[u8MsgIfNum].DAT_A2 = ((uint16_t)pCanMsg->Data[3]<<8) | pCanMsg->Data[2];
<> 144:ef7eb2e8f9f7 542 tCAN->IF[u8MsgIfNum].DAT_B1 = ((uint16_t)pCanMsg->Data[5]<<8) | pCanMsg->Data[4];
<> 144:ef7eb2e8f9f7 543 tCAN->IF[u8MsgIfNum].DAT_B2 = ((uint16_t)pCanMsg->Data[7]<<8) | pCanMsg->Data[6];
<> 144:ef7eb2e8f9f7 544
<> 144:ef7eb2e8f9f7 545 tCAN->IF[u8MsgIfNum].MCON = CAN_IF_MCON_NEWDAT_Msk | pCanMsg->DLC |CAN_IF_MCON_TXIE_Msk | CAN_IF_MCON_EOB_Msk;
<> 144:ef7eb2e8f9f7 546 tCAN->IF[u8MsgIfNum].CREQ = 1 + u32MsgNum;
<> 144:ef7eb2e8f9f7 547
<> 144:ef7eb2e8f9f7 548 return TRUE;
<> 144:ef7eb2e8f9f7 549 }
<> 144:ef7eb2e8f9f7 550
<> 144:ef7eb2e8f9f7 551 /**
<> 144:ef7eb2e8f9f7 552 * @brief Set transmit request bit
<> 144:ef7eb2e8f9f7 553 *
<> 144:ef7eb2e8f9f7 554 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 555 * @param[in] u32MsgNum Specifies the Message object number, from 0 to 31.
<> 144:ef7eb2e8f9f7 556 *
<> 144:ef7eb2e8f9f7 557 * @return TRUE: Start transmit message.
<> 144:ef7eb2e8f9f7 558 */
<> 144:ef7eb2e8f9f7 559 int32_t CAN_TriggerTxMsg(CAN_T *tCAN, uint32_t u32MsgNum)
<> 144:ef7eb2e8f9f7 560 {
<> 144:ef7eb2e8f9f7 561 STR_CANMSG_T rMsg;
<> 144:ef7eb2e8f9f7 562 CAN_ReadMsgObj(tCAN, u32MsgNum,TRUE, &rMsg);
<> 144:ef7eb2e8f9f7 563 tCAN->IF[0].CMASK = CAN_IF_CMASK_WRRD_Msk |CAN_IF_CMASK_TXRQSTNEWDAT_Msk;
<> 144:ef7eb2e8f9f7 564 tCAN->IF[0].CREQ = 1 + u32MsgNum;
<> 144:ef7eb2e8f9f7 565
<> 144:ef7eb2e8f9f7 566 return TRUE;
<> 144:ef7eb2e8f9f7 567 }
<> 144:ef7eb2e8f9f7 568
<> 144:ef7eb2e8f9f7 569 /**
<> 144:ef7eb2e8f9f7 570 * @brief Enable CAN interrupt
<> 144:ef7eb2e8f9f7 571 *
<> 144:ef7eb2e8f9f7 572 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 573 * @param[in] u32Mask Interrupt Mask. ( \ref CAN_CON_IE_Msk / \ref CAN_CON_SIE_Msk / \ref CAN_CON_EIE_Msk)
<> 144:ef7eb2e8f9f7 574 *
<> 144:ef7eb2e8f9f7 575 * @return None
<> 144:ef7eb2e8f9f7 576 */
<> 144:ef7eb2e8f9f7 577 void CAN_EnableInt(CAN_T *tCAN, uint32_t u32Mask)
<> 144:ef7eb2e8f9f7 578 {
<> 144:ef7eb2e8f9f7 579 CAN_EnterInitMode(tCAN);
<> 144:ef7eb2e8f9f7 580
<> 144:ef7eb2e8f9f7 581 tCAN->CON = (tCAN->CON & 0xF1) | ((u32Mask & CAN_CON_IE_Msk )? CAN_CON_IE_Msk :0)
<> 144:ef7eb2e8f9f7 582 | ((u32Mask & CAN_CON_SIE_Msk )? CAN_CON_SIE_Msk:0)
<> 144:ef7eb2e8f9f7 583 | ((u32Mask & CAN_CON_EIE_Msk )? CAN_CON_EIE_Msk:0);
<> 144:ef7eb2e8f9f7 584
<> 144:ef7eb2e8f9f7 585
<> 144:ef7eb2e8f9f7 586 CAN_LeaveInitMode(tCAN);
<> 144:ef7eb2e8f9f7 587 }
<> 144:ef7eb2e8f9f7 588
<> 144:ef7eb2e8f9f7 589 /**
<> 144:ef7eb2e8f9f7 590 * @brief Disable CAN interrupt
<> 144:ef7eb2e8f9f7 591 *
<> 144:ef7eb2e8f9f7 592 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 593 * @param[in] u32Mask Interrupt Mask. ( \ref CAN_CON_IE_Msk / \ref CAN_CON_SIE_Msk / \ref CAN_CON_EIE_Msk)
<> 144:ef7eb2e8f9f7 594 *
<> 144:ef7eb2e8f9f7 595 * @return None
<> 144:ef7eb2e8f9f7 596 */
<> 144:ef7eb2e8f9f7 597 void CAN_DisableInt(CAN_T *tCAN, uint32_t u32Mask)
<> 144:ef7eb2e8f9f7 598 {
<> 144:ef7eb2e8f9f7 599 CAN_EnterInitMode(tCAN);
<> 144:ef7eb2e8f9f7 600
<> 144:ef7eb2e8f9f7 601 tCAN->CON = tCAN->CON & ~(CAN_CON_IE_Msk | ((u32Mask & CAN_CON_SIE_Msk)?CAN_CON_SIE_Msk:0)
<> 144:ef7eb2e8f9f7 602 | ((u32Mask & CAN_CON_EIE_Msk)?CAN_CON_EIE_Msk:0));
<> 144:ef7eb2e8f9f7 603
<> 144:ef7eb2e8f9f7 604 CAN_LeaveInitMode(tCAN);
<> 144:ef7eb2e8f9f7 605 }
<> 144:ef7eb2e8f9f7 606
<> 144:ef7eb2e8f9f7 607
<> 144:ef7eb2e8f9f7 608 /**
<> 144:ef7eb2e8f9f7 609 * @brief The function is used to configure a receive message object
<> 144:ef7eb2e8f9f7 610 *
<> 144:ef7eb2e8f9f7 611 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 612 * @param[in] u32MsgNum Specifies the Message object number, from 0 to 31
<> 144:ef7eb2e8f9f7 613 * @param[in] u32IDType Specifies the identifier type of the frames that will be transmitted. ( \ref CAN_STD_ID / \ref CAN_EXT_ID)
<> 144:ef7eb2e8f9f7 614 * @param[in] u32ID Specifies the identifier used for acceptance filtering.
<> 144:ef7eb2e8f9f7 615 *
<> 144:ef7eb2e8f9f7 616 * @return FALSE: No useful interface \n
<> 144:ef7eb2e8f9f7 617 * TRUE : Configure a receive message object success.
<> 144:ef7eb2e8f9f7 618 *
<> 144:ef7eb2e8f9f7 619 */
<> 144:ef7eb2e8f9f7 620 int32_t CAN_SetRxMsg(CAN_T *tCAN, uint32_t u32MsgNum , uint32_t u32IDType, uint32_t u32ID)
<> 144:ef7eb2e8f9f7 621 {
<> 144:ef7eb2e8f9f7 622 uint32_t u32TimeOutCount = 0;
<> 144:ef7eb2e8f9f7 623
<> 144:ef7eb2e8f9f7 624 while(CAN_SetRxMsgObj(tCAN, u32MsgNum, u32IDType, u32ID, TRUE) == FALSE) {
<> 144:ef7eb2e8f9f7 625 u32TimeOutCount++;
<> 144:ef7eb2e8f9f7 626
<> 144:ef7eb2e8f9f7 627 if(u32TimeOutCount >= 0x10000000) return FALSE;
<> 144:ef7eb2e8f9f7 628 }
<> 144:ef7eb2e8f9f7 629
<> 144:ef7eb2e8f9f7 630 return TRUE;
<> 144:ef7eb2e8f9f7 631 }
<> 144:ef7eb2e8f9f7 632
<> 144:ef7eb2e8f9f7 633 /**
<> 144:ef7eb2e8f9f7 634 * @brief The function is used to configure several receive message objects
<> 144:ef7eb2e8f9f7 635 *
<> 144:ef7eb2e8f9f7 636 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 637 * @param[in] u32MsgNum The starting MSG RAM number. (0 ~ 31)
<> 144:ef7eb2e8f9f7 638 * @param[in] u32MsgCount the number of MSG RAM of the FIFO.
<> 144:ef7eb2e8f9f7 639 * @param[in] u32IDType Specifies the identifier type of the frames that will be transmitted. ( \ref CAN_STD_ID / \ref CAN_EXT_ID)
<> 144:ef7eb2e8f9f7 640 * @param[in] u32ID Specifies the identifier used for acceptance filtering.
<> 144:ef7eb2e8f9f7 641 *
<> 144:ef7eb2e8f9f7 642 * @return FALSE: No useful interface \n
<> 144:ef7eb2e8f9f7 643 * TRUE : Configure receive message objects success.
<> 144:ef7eb2e8f9f7 644 *
<> 144:ef7eb2e8f9f7 645 */
<> 144:ef7eb2e8f9f7 646 int32_t CAN_SetMultiRxMsg(CAN_T *tCAN, uint32_t u32MsgNum , uint32_t u32MsgCount, uint32_t u32IDType, uint32_t u32ID)
<> 144:ef7eb2e8f9f7 647 {
<> 144:ef7eb2e8f9f7 648 uint32_t i = 0;
<> 144:ef7eb2e8f9f7 649 uint32_t u32TimeOutCount;
<> 144:ef7eb2e8f9f7 650 uint32_t u32EOB_Flag = 0;
<> 144:ef7eb2e8f9f7 651
<> 144:ef7eb2e8f9f7 652 for(i= 1; i < u32MsgCount; i++) {
<> 144:ef7eb2e8f9f7 653 u32TimeOutCount = 0;
<> 144:ef7eb2e8f9f7 654
<> 144:ef7eb2e8f9f7 655 u32MsgNum += (i - 1);
<> 144:ef7eb2e8f9f7 656
<> 144:ef7eb2e8f9f7 657 if(i == u32MsgCount) u32EOB_Flag = 1;
<> 144:ef7eb2e8f9f7 658
<> 144:ef7eb2e8f9f7 659 while(CAN_SetRxMsgObj(tCAN, u32MsgNum, u32IDType, u32ID, u32EOB_Flag) == FALSE) {
<> 144:ef7eb2e8f9f7 660 u32TimeOutCount++;
<> 144:ef7eb2e8f9f7 661
<> 144:ef7eb2e8f9f7 662 if(u32TimeOutCount >= 0x10000000) return FALSE;
<> 144:ef7eb2e8f9f7 663 }
<> 144:ef7eb2e8f9f7 664 }
<> 144:ef7eb2e8f9f7 665
<> 144:ef7eb2e8f9f7 666 return TRUE;
<> 144:ef7eb2e8f9f7 667 }
<> 144:ef7eb2e8f9f7 668
<> 144:ef7eb2e8f9f7 669
<> 144:ef7eb2e8f9f7 670 /**
<> 144:ef7eb2e8f9f7 671 * @brief Send CAN message.
<> 144:ef7eb2e8f9f7 672 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 673 * @param[in] u32MsgNum Specifies the Message object number, from 0 to 31
<> 144:ef7eb2e8f9f7 674 * @param[in] pCanMsg Pointer to the message structure where received data is copied.
<> 144:ef7eb2e8f9f7 675 *
<> 144:ef7eb2e8f9f7 676 * @return FALSE: When operation in basic mode: Transmit message time out, or when operation in normal mode: No useful interface. \n
<> 144:ef7eb2e8f9f7 677 * TRUE : Transmit Message success.
<> 144:ef7eb2e8f9f7 678 */
<> 144:ef7eb2e8f9f7 679 int32_t CAN_Transmit(CAN_T *tCAN, uint32_t u32MsgNum , STR_CANMSG_T* pCanMsg)
<> 144:ef7eb2e8f9f7 680 {
<> 144:ef7eb2e8f9f7 681 if((tCAN->CON & CAN_CON_TEST_Msk) && (tCAN->TEST & CAN_TEST_BASIC_Msk)) {
<> 144:ef7eb2e8f9f7 682 return (CAN_BasicSendMsg(tCAN, pCanMsg));
<> 144:ef7eb2e8f9f7 683 } else {
<> 144:ef7eb2e8f9f7 684 if(CAN_SetTxMsg(tCAN, u32MsgNum, pCanMsg) == FALSE)
<> 144:ef7eb2e8f9f7 685 return FALSE;
<> 144:ef7eb2e8f9f7 686 CAN_TriggerTxMsg(tCAN, u32MsgNum);
<> 144:ef7eb2e8f9f7 687 }
<> 144:ef7eb2e8f9f7 688
<> 144:ef7eb2e8f9f7 689 return TRUE;
<> 144:ef7eb2e8f9f7 690 }
<> 144:ef7eb2e8f9f7 691
<> 144:ef7eb2e8f9f7 692
<> 144:ef7eb2e8f9f7 693 /**
<> 144:ef7eb2e8f9f7 694 * @brief Gets the message, if received.
<> 144:ef7eb2e8f9f7 695 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 696 * @param[in] u32MsgNum Specifies the Message object number, from 0 to 31
<> 144:ef7eb2e8f9f7 697 * @param[out] pCanMsg Pointer to the message structure where received data is copied.
<> 144:ef7eb2e8f9f7 698 *
<> 144:ef7eb2e8f9f7 699 * @return FALSE: No any message received. \n
<> 144:ef7eb2e8f9f7 700 * TRUE : Receive Message success.
<> 144:ef7eb2e8f9f7 701 */
<> 144:ef7eb2e8f9f7 702 int32_t CAN_Receive(CAN_T *tCAN, uint32_t u32MsgNum , STR_CANMSG_T* pCanMsg)
<> 144:ef7eb2e8f9f7 703 {
<> 144:ef7eb2e8f9f7 704 if((tCAN->CON & CAN_CON_TEST_Msk) && (tCAN->TEST & CAN_TEST_BASIC_Msk)) {
<> 144:ef7eb2e8f9f7 705 return (CAN_BasicReceiveMsg(tCAN, pCanMsg));
<> 144:ef7eb2e8f9f7 706 } else {
<> 144:ef7eb2e8f9f7 707 return CAN_ReadMsgObj(tCAN, u32MsgNum, TRUE, pCanMsg);
<> 144:ef7eb2e8f9f7 708 }
<> 144:ef7eb2e8f9f7 709 }
<> 144:ef7eb2e8f9f7 710
<> 144:ef7eb2e8f9f7 711 /**
<> 144:ef7eb2e8f9f7 712 * @brief Clear interrupt pending bit.
<> 144:ef7eb2e8f9f7 713 * @param[in] tCAN The base address of can module.
<> 144:ef7eb2e8f9f7 714 * @param[in] u32MsgNum Specifies the Message object number, from 0 to 31
<> 144:ef7eb2e8f9f7 715 *
<> 144:ef7eb2e8f9f7 716 * @return None
<> 144:ef7eb2e8f9f7 717 *
<> 144:ef7eb2e8f9f7 718 */
<> 144:ef7eb2e8f9f7 719 void CAN_CLR_INT_PENDING_BIT(CAN_T *tCAN, uint8_t u32MsgNum)
<> 144:ef7eb2e8f9f7 720 {
<> 144:ef7eb2e8f9f7 721 uint32_t u32MsgIfNum = 0;
<> 144:ef7eb2e8f9f7 722 uint32_t u32IFBusyCount = 0;
<> 144:ef7eb2e8f9f7 723
<> 144:ef7eb2e8f9f7 724 while(u32IFBusyCount < 0x10000000) {
<> 144:ef7eb2e8f9f7 725 if((tCAN->IF[0].CREQ & CAN_IF_CREQ_BUSY_Msk) == 0) {
<> 144:ef7eb2e8f9f7 726 u32MsgIfNum = 0;
<> 144:ef7eb2e8f9f7 727 break;
<> 144:ef7eb2e8f9f7 728 } else if((tCAN->IF[1].CREQ & CAN_IF_CREQ_BUSY_Msk) == 0) {
<> 144:ef7eb2e8f9f7 729 u32MsgIfNum = 1;
<> 144:ef7eb2e8f9f7 730 break;
<> 144:ef7eb2e8f9f7 731 }
<> 144:ef7eb2e8f9f7 732
<> 144:ef7eb2e8f9f7 733 u32IFBusyCount++;
<> 144:ef7eb2e8f9f7 734 }
<> 144:ef7eb2e8f9f7 735
<> 144:ef7eb2e8f9f7 736 tCAN->IF[u32MsgIfNum].CMASK = CAN_IF_CMASK_CLRINTPND_Msk | CAN_IF_CMASK_TXRQSTNEWDAT_Msk;
<> 144:ef7eb2e8f9f7 737 tCAN->IF[u32MsgIfNum].CREQ = 1 + u32MsgNum;
<> 144:ef7eb2e8f9f7 738
<> 144:ef7eb2e8f9f7 739 }
<> 144:ef7eb2e8f9f7 740
<> 144:ef7eb2e8f9f7 741
<> 144:ef7eb2e8f9f7 742 /*@}*/ /* end of group NUC472_442_CAN_EXPORTED_FUNCTIONS */
<> 144:ef7eb2e8f9f7 743
<> 144:ef7eb2e8f9f7 744 /*@}*/ /* end of group NUC472_442_CAN_Driver */
<> 144:ef7eb2e8f9f7 745
<> 144:ef7eb2e8f9f7 746 /*@}*/ /* end of group NUC472_442_Device_Driver */
<> 144:ef7eb2e8f9f7 747
<> 144:ef7eb2e8f9f7 748 /*** (C) COPYRIGHT 2013 Nuvoton Technology Corp. ***/
<> 144:ef7eb2e8f9f7 749
<> 144:ef7eb2e8f9f7 750