Files
Last update 6 years 10 months
by
JackyYuen
stm8s_can.c/** ****************************************************************************** * @file stm8s_can.c * @author MCD Application Team * @version V2.2.0 * @date 30-September-2014 * @brief This file contains all the functions for the CAN peripheral. ****************************************************************************** * @attention * * <h2><center>© COPYRIGHT 2014 STMicroelectronics</center></h2> * * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); * You may not use this file except in compliance with the License. * You may obtain a copy of the License at: * * http://www.st.com/software_license_agreement_liberty_v2 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * ****************************************************************************** */ /* Includes ------------------------------------------------------------------*/ #include "stm8s_can.h" /** @addtogroup STM8S_StdPeriph_Driver * @{ */ /* Private typedef -----------------------------------------------------------*/ /* Private define ------------------------------------------------------------*/ #define CAN_IDLIST_IDMASK_MASK ((uint8_t) 0x55) #define CAN_IDMASK_IDLIST_MASK ((uint8_t) 0xAA) #define CAN_MODE_MASK ((uint8_t) 0x03) #define CAN_ACKNOWLEDGE_TIMEOUT ((uint16_t)0xFFFF) /* Private macro -------------------------------------------------------------*/ /* Private variables ---------------------------------------------------------*/ __IO uint32_t _Id = 0; __IO uint8_t _IDE = 0; __IO uint8_t _RTR = 0; __IO uint8_t _DLC = 0; __IO uint8_t _Data[8] = {0}; __IO uint8_t _FMI = 0; /* Private function prototypes -----------------------------------------------*/ static ITStatus CheckITStatus(uint8_t CAN_Reg, uint8_t It_Bit); /* Private functions ---------------------------------------------------------*/ /** * @addtogroup CAN_Public_Functions * @{ */ /** * @brief Deinitializes the CAN peripheral registers to their default reset values. * @param None * @retval None */ void CAN_DeInit(void) { /* Request initialisation */ CAN->MCR = CAN_MCR_INRQ; CAN->PSR = CAN_Page_Config; CAN_OperatingModeRequest(CAN_OperatingMode_Initialization); CAN->Page.Config.ESR = CAN_ESR_RESET_VALUE; CAN->Page.Config.EIER = CAN_EIER_RESET_VALUE; CAN->Page.Config.BTR1 = CAN_BTR1_RESET_VALUE; CAN->Page.Config.BTR2 = CAN_BTR2_RESET_VALUE; CAN->Page.Config.FMR1 = CAN_FMR1_RESET_VALUE; CAN->Page.Config.FMR2 = CAN_FMR2_RESET_VALUE; CAN->Page.Config.FCR1 = CAN_FCR_RESET_VALUE; CAN->Page.Config.FCR2 = CAN_FCR_RESET_VALUE; CAN->Page.Config.FCR3 = CAN_FCR_RESET_VALUE; CAN_OperatingModeRequest(CAN_OperatingMode_Normal); CAN->PSR = CAN_Page_RxFifo; CAN->Page.RxFIFO.MDLCR = CAN_MDLC_RESET_VALUE; CAN->PSR = CAN_Page_TxMailBox0; CAN->Page.TxMailbox.MDLCR = CAN_MDLC_RESET_VALUE; CAN->PSR = CAN_Page_TxMailBox1; CAN->Page.TxMailbox.MDLCR = CAN_MDLC_RESET_VALUE; CAN->PSR = CAN_Page_TxMailBox2; CAN->Page.TxMailbox.MDLCR = CAN_MDLC_RESET_VALUE; CAN->MCR = CAN_MCR_RESET_VALUE; CAN->MSR = (uint8_t)(~CAN_MSR_RESET_VALUE);/* rc_w1 */ CAN->TSR = (uint8_t)(~CAN_TSR_RESET_VALUE);/* rc_w1 */ CAN->RFR = (uint8_t)(~CAN_RFR_RESET_VALUE);/* rc_w1 */ CAN->IER = CAN_IER_RESET_VALUE; CAN->DGR = CAN_DGR_RESET_VALUE; CAN->PSR = CAN_PSR_RESET_VALUE; } /** * @brief Initializes the CAN peripheral according to the specified parameters. * @param CAN_MasterCtrl : Master control option, can be one or a combination of @ref CAN_MasterCtrl_TypeDef. * @param CAN_Mode : CAN mode , can be one of @ref CAN_Mode_TypeDef. * @param CAN_SynJumpWidth : CAN Synchronisation Jump Width , can be one of @ref CAN_SynJumpWidth_TypeDef. * @param CAN_BitSeg1 : CAN bit segment 1 , can be one of @ref CAN_BitSeg1_TypeDef. * @param CAN_BitSeg2 : CAN bit segment 2 , can be one of @ref CAN_BitSeg2_TypeDef. * @param CAN_Prescaler : CAN Baud Rate Prescaler , can be a value from 0x01 to 0xFF. * @retval Indicates if initialization is succeed. it can be one of @ref CAN_InitStatus_TypeDef enumeration. */ CAN_InitStatus_TypeDef CAN_Init(CAN_MasterCtrl_TypeDef CAN_MasterCtrl, CAN_Mode_TypeDef CAN_Mode, CAN_SynJumpWidth_TypeDef CAN_SynJumpWidth, CAN_BitSeg1_TypeDef CAN_BitSeg1, CAN_BitSeg2_TypeDef CAN_BitSeg2, uint8_t CAN_Prescaler) { CAN_InitStatus_TypeDef InitStatus = CAN_InitStatus_Failed; uint16_t timeout = CAN_ACKNOWLEDGE_TIMEOUT; CAN_Page_TypeDef can_page = CAN_GetSelectedPage(); /* Check the parameters */ assert_param(IS_CAN_MASTERCTRL_OK(CAN_MasterCtrl)); assert_param(IS_CAN_MODE_OK(CAN_Mode)); assert_param(IS_CAN_SYNJUMPWIDTH_OK(CAN_SynJumpWidth)); assert_param(IS_CAN_BITSEG1_OK(CAN_BitSeg1)); assert_param(IS_CAN_BITSEG2_OK(CAN_BitSeg2)); assert_param(IS_CAN_PRESCALER_OK(CAN_Prescaler)); /* Request initialisation */ CAN->MCR = CAN_MCR_INRQ; /* Wait the acknowledge */ while (((uint8_t)(CAN->MSR & CAN_MSR_INAK) != 0x01) && ((uint16_t)timeout != 0)) { timeout--; } /* Check acknowledged */ if ((CAN->MSR & CAN_MSR_INAK) != CAN_MSR_INAK) { InitStatus = CAN_InitStatus_Failed; } else { /* Set the time triggered communication mode & Set the automatic bus-off management & Set the automatic wake-up mode & Set the no automatic retransmission & Set the receive FIFO locked mode & Set the transmit FIFO priority */ CAN->MCR |= (uint8_t)CAN_MasterCtrl; /* Set the bit timing register */ CAN->DGR |= (uint8_t)CAN_Mode ; CAN->PSR = CAN_Page_Config; CAN->Page.Config.BTR1 = (uint8_t)((uint8_t)(CAN_Prescaler - (uint8_t)1) | CAN_SynJumpWidth); CAN->Page.Config.BTR2 = (uint8_t)(CAN_BitSeg1 | (uint8_t)CAN_BitSeg2); /* Request leave initialisation */ CAN->MCR &= (uint8_t)(~CAN_MCR_INRQ); /* Wait the acknowledge */ timeout = 0xFFFF; while ((((uint8_t)(CAN->MSR & CAN_MSR_INAK) == 0x01))&&(timeout != 0)) { timeout--; } /* Check acknowledged */ if ((CAN->MSR & CAN_MSR_INAK) == CAN_MSR_INAK) { InitStatus = CAN_InitStatus_Failed; } else { InitStatus = CAN_InitStatus_Success; } } /*Restore Last Page*/ CAN_SelectPage(can_page); /* Return the status of initialization */ return (CAN_InitStatus_TypeDef)InitStatus; } /** * @brief Initializes the CAN peripheral Filter according to the specified parameters. * @param CAN_FilterNumber : CAN Filter number , can be one of @ref CAN_FilterNumber_TypeDef * @param CAN_FilterActivation : CAN Filter Activation state , can be one of @ref FunctionalState * @param CAN_FilterMode : CAN Filter Mode , can be one of @ref CAN_FilterMode_TypeDef * @param CAN_FilterScale : CAN Filter Scale , can be one of @ref CAN_FilterScale_TypeDef * @param CAN_FilterID1 : CAN Filter ID 1 , can be a value from 0x00 to 0xFF * @param CAN_FilterID2 : CAN Filter ID 2 , can be a value from 0x00 to 0xFF * @param CAN_FilterID3 : CAN Filter ID 3 , can be a value from 0x00 to 0xFF * @param CAN_FilterID4 : CAN Filter ID 4 , can be a value from 0x00 to 0xFF * @param CAN_FilterIDMask1 : CAN Filter ID 1/ Mask 1 , can be a value from 0x00 to 0xFF depending of CAN_FilterMode parameter * @param CAN_FilterIDMask2 : CAN Filter ID 2/ Mask 2 , can be a value from 0x00 to 0xFF depending of CAN_FilterMode parameter * @param CAN_FilterIDMask3 : CAN Filter ID 3/ Mask 3 , can be a value from 0x00 to 0xFF depending of CAN_FilterMode parameter * @param CAN_FilterIDMask4 : CAN Filter ID 4/ Mask 4 , can be a value from 0x00 to 0xFF depending of CAN_FilterMode parameter * @retval None */ void CAN_FilterInit(CAN_FilterNumber_TypeDef CAN_FilterNumber, FunctionalState CAN_FilterActivation, CAN_FilterMode_TypeDef CAN_FilterMode, CAN_FilterScale_TypeDef CAN_FilterScale, uint8_t CAN_FilterID1, uint8_t CAN_FilterID2, uint8_t CAN_FilterID3, uint8_t CAN_FilterID4, uint8_t CAN_FilterIDMask1, uint8_t CAN_FilterIDMask2, uint8_t CAN_FilterIDMask3, uint8_t CAN_FilterIDMask4) { uint8_t fact = 0; uint8_t fsc = 0; uint8_t fmhl = 0; CAN_Page_TypeDef can_page_filter = CAN_Page_Filter01; CAN_Page_TypeDef can_page = CAN_GetSelectedPage(); /* Check the parameters */ assert_param(IS_CAN_FILTER_NUMBER_OK(CAN_FilterNumber)); assert_param(IS_FUNCTIONALSTATE_OK(CAN_FilterActivation)); assert_param(IS_CAN_FILTER_MODE_OK(CAN_FilterMode)); assert_param(IS_CAN_FILTER_SCALE_OK(CAN_FilterScale)); if (CAN_FilterNumber == CAN_FilterNumber_0) { fact = 0x01; fsc = 0x00; fmhl = 0x03; can_page_filter = CAN_Page_Filter01; } else if (CAN_FilterNumber == CAN_FilterNumber_1) { fact = 0x10; fsc = 0x04; fmhl = 0x0C; can_page_filter = CAN_Page_Filter01; } else if (CAN_FilterNumber == CAN_FilterNumber_2) { fact = 0x01; fsc = 0x00; fmhl = 0x30; can_page_filter = CAN_Page_Filter23; } else if (CAN_FilterNumber == CAN_FilterNumber_3) { fact = 0x10; fsc = 0x04; fmhl = 0xC0; can_page_filter = CAN_Page_Filter23; } else if (CAN_FilterNumber == CAN_FilterNumber_4) { fact = 0x01; fsc = 0x00; fmhl = 0x03; can_page_filter = CAN_Page_Filter45; } else /*if (CAN_FilterNumber == CAN_FilterNumber_5)*/ { fact = 0x10; fsc = 0x04; fmhl = 0x0C; can_page_filter = CAN_Page_Filter45; } CAN_OperatingModeRequest(CAN_OperatingMode_Initialization); CAN->PSR = CAN_Page_Config; /*---------------------------------------------------------*/ /*Configuration of Filter Scale */ /*---------------------------------------------------------*/ if (can_page_filter == CAN_Page_Filter01) /* FCR1 */ { /* Filter Deactivation & Reset the Filter Scale */ CAN->Page.Config.FCR1 &= (uint8_t)(~(uint8_t)(fact | (uint8_t)((uint8_t)(CAN_FCR1_FSC00|CAN_FCR1_FSC01) << fsc ))); /* Set the new Filter Scale */ CAN->Page.Config.FCR1 |= (uint8_t)(CAN_FilterScale << fsc); } else if (can_page_filter == CAN_Page_Filter23) /* FCR2*/ { /* Filter Deactivation & Reset the Filter Scale */ CAN->Page.Config.FCR2 &= (uint8_t)~(uint8_t)( fact | (uint8_t)((uint8_t)(CAN_FCR1_FSC00|CAN_FCR1_FSC01) << fsc )); /* Set the new Filter Scale */ CAN->Page.Config.FCR2 |= (uint8_t)(CAN_FilterScale << fsc); } else /*if(can_page_filter == CAN_Page_Filter45)*/ /* FCR3*/ { /* Filter Deactivation & Reset the Filter Scale */ CAN->Page.Config.FCR3 &= (uint8_t)~(uint8_t)( fact | (uint8_t)((uint8_t)(CAN_FCR1_FSC00|CAN_FCR1_FSC01) << fsc )); /* Set the new Filter Scale */ CAN->Page.Config.FCR3 |= (uint8_t)(CAN_FilterScale << fsc); } /*---------------------------------------------------------*/ /*Configuration of Filter Mode */ /*---------------------------------------------------------*/ if (can_page_filter != CAN_Page_Filter45) /* FMR1*/ { /* Filter Mode */ if (CAN_FilterMode == CAN_FilterMode_IdMask) { /*Id/Mask mode for the filter*/ CAN->Page.Config.FMR1 &= (uint8_t)~(fmhl); } else if ( CAN_FilterMode == CAN_FilterMode_IdList) { /*Identifier list mode for the filter*/ CAN->Page.Config.FMR1 |= (uint8_t)(fmhl); } else if ( CAN_FilterMode == CAN_FilterMode_IdList_IdMask) { /*Identifier list mode is first for the filter*/ CAN->Page.Config.FMR1 |= (uint8_t)(fmhl & CAN_IDLIST_IDMASK_MASK); } else /* ( CAN_FilterMode == CAN_FilterMode_IdMask_IdList)*/ { /*Id Mask mode is first for the filter*/ CAN->Page.Config.FMR1 |= (uint8_t)(fmhl & CAN_IDMASK_IDLIST_MASK); } } else /* FMR2 */ { /* Filter Mode */ if (CAN_FilterMode == CAN_FilterMode_IdMask) { /*Id/Mask mode for the filter*/ CAN->Page.Config.FMR2 &= (uint8_t)~(fmhl); } else if ( CAN_FilterMode == CAN_FilterMode_IdList) { /*Identifier list mode for the filter*/ CAN->Page.Config.FMR2 |= (uint8_t)(fmhl); } else if ( CAN_FilterMode == CAN_FilterMode_IdList_IdMask) { /*Identifier list mode is first for the filter*/ CAN->Page.Config.FMR2 |= (uint8_t)(fmhl & CAN_IDLIST_IDMASK_MASK); } else /* ( CAN_FilterMode == CAN_FilterMode_IdMask_IdList)*/ { /*Id Mask mode is first for the filter*/ CAN->Page.Config.FMR2 |= (uint8_t)(fmhl & CAN_IDMASK_IDLIST_MASK); } } /*---------------------------------------------------------*/ /*Configuration of Filter IDs */ /*---------------------------------------------------------*/ CAN->PSR = (uint8_t)can_page_filter; if (fsc != 0) { /* Filter Scale */ if (CAN_FilterScale == CAN_FilterScale_8Bit) { CAN->Page.Filter.FR09 = CAN_FilterID1; CAN->Page.Filter.FR10 = CAN_FilterIDMask1; CAN->Page.Filter.FR11 = CAN_FilterID2; CAN->Page.Filter.FR12 = CAN_FilterIDMask2; CAN->Page.Filter.FR13 = CAN_FilterID3; CAN->Page.Filter.FR14 = CAN_FilterIDMask3; CAN->Page.Filter.FR15 = CAN_FilterID4; CAN->Page.Filter.FR16 = CAN_FilterIDMask4; } else if (CAN_FilterScale == CAN_FilterScale_16_8Bit) { CAN->Page.Filter.FR09 = CAN_FilterID1; CAN->Page.Filter.FR10 = CAN_FilterID2; CAN->Page.Filter.FR11 = CAN_FilterIDMask1; CAN->Page.Filter.FR12 = CAN_FilterIDMask2; CAN->Page.Filter.FR13 = CAN_FilterID3; CAN->Page.Filter.FR14 = CAN_FilterIDMask3; CAN->Page.Filter.FR15 = CAN_FilterID4; CAN->Page.Filter.FR16 = CAN_FilterIDMask4; } else if (CAN_FilterScale == CAN_FilterScale_16Bit) { CAN->Page.Filter.FR09 = CAN_FilterID1; CAN->Page.Filter.FR10 = CAN_FilterID2; CAN->Page.Filter.FR11 = CAN_FilterIDMask1; CAN->Page.Filter.FR12 = CAN_FilterIDMask2; CAN->Page.Filter.FR13 = CAN_FilterID3; CAN->Page.Filter.FR14 = CAN_FilterID4; CAN->Page.Filter.FR15 = CAN_FilterIDMask3; CAN->Page.Filter.FR16 = CAN_FilterIDMask4; } else if (CAN_FilterScale == CAN_FilterScale_32Bit) { CAN->Page.Filter.FR09 = CAN_FilterID1; CAN->Page.Filter.FR10 = CAN_FilterID2; CAN->Page.Filter.FR11 = CAN_FilterID3; CAN->Page.Filter.FR12 = CAN_FilterID4; CAN->Page.Filter.FR13 = CAN_FilterIDMask1; CAN->Page.Filter.FR14 = CAN_FilterIDMask2; CAN->Page.Filter.FR15 = CAN_FilterIDMask3; CAN->Page.Filter.FR16 = CAN_FilterIDMask4; } } else { /* Filter Scale */ if (CAN_FilterScale == CAN_FilterScale_8Bit) { CAN->Page.Filter.FR01 = CAN_FilterID1; CAN->Page.Filter.FR02 = CAN_FilterIDMask1; CAN->Page.Filter.FR03 = CAN_FilterID2; CAN->Page.Filter.FR04 = CAN_FilterIDMask2; CAN->Page.Filter.FR05 = CAN_FilterID3; CAN->Page.Filter.FR06 = CAN_FilterIDMask3; CAN->Page.Filter.FR07 = CAN_FilterID4; CAN->Page.Filter.FR08 = CAN_FilterIDMask4; } else if (CAN_FilterScale == CAN_FilterScale_16_8Bit) { CAN->Page.Filter.FR01 = CAN_FilterID1; CAN->Page.Filter.FR02 = CAN_FilterID2; CAN->Page.Filter.FR03 = CAN_FilterIDMask1; CAN->Page.Filter.FR04 = CAN_FilterIDMask2; CAN->Page.Filter.FR05 = CAN_FilterID3; CAN->Page.Filter.FR06 = CAN_FilterIDMask3; CAN->Page.Filter.FR07 = CAN_FilterID4; CAN->Page.Filter.FR08 = CAN_FilterIDMask4; } else if (CAN_FilterScale == CAN_FilterScale_16Bit) { CAN->Page.Filter.FR01 = CAN_FilterID1; CAN->Page.Filter.FR02 = CAN_FilterID2; CAN->Page.Filter.FR03 = CAN_FilterIDMask1; CAN->Page.Filter.FR04 = CAN_FilterIDMask2; CAN->Page.Filter.FR05 = CAN_FilterID3; CAN->Page.Filter.FR06 = CAN_FilterID4; CAN->Page.Filter.FR07 = CAN_FilterIDMask3; CAN->Page.Filter.FR08 = CAN_FilterIDMask4; } else if (CAN_FilterScale == CAN_FilterScale_32Bit) { CAN->Page.Filter.FR01 = CAN_FilterID1; CAN->Page.Filter.FR02 = CAN_FilterID2; CAN->Page.Filter.FR03 = CAN_FilterID3; CAN->Page.Filter.FR04 = CAN_FilterID4; CAN->Page.Filter.FR05 = CAN_FilterIDMask1; CAN->Page.Filter.FR06 = CAN_FilterIDMask2; CAN->Page.Filter.FR07 = CAN_FilterIDMask3; CAN->Page.Filter.FR08 = CAN_FilterIDMask4; } } /*---------------------------------------------------------*/ /*Configuration of Filter Activation */ /*---------------------------------------------------------*/ /* Filter activation */ CAN->PSR = CAN_Page_Config; if (CAN_FilterActivation != DISABLE) { if ((CAN_FilterNumber & 0x06) == 0x00) /* FCR1*/ { CAN->Page.Config.FCR1 |= (uint8_t)fact; } else if ((CAN_FilterNumber & 0x06) == 0x02) /*FCR2*/ { CAN->Page.Config.FCR2 |= (uint8_t)fact; } else /*if((CAN_FilterNumber & 0x06) == 0x04)*/ /*FCR3*/ { CAN->Page.Config.FCR3 |= (uint8_t)fact; } } CAN_OperatingModeRequest(CAN_OperatingMode_Normal); /*Restore Last Page*/ CAN_SelectPage(can_page); } /** * @brief Enables or disables the specified CAN interrupts. * @param CAN_IT: specifies the CAN interrupt sources to be enabled or disabled. * @param NewState : CAN_IT new state , can be one of @ref FunctionalState * @retval None */ void CAN_ITConfig(CAN_IT_TypeDef CAN_IT, FunctionalState NewState) { uint8_t tmperrorinterrupt = 0; CAN_Page_TypeDef can_page = CAN_GetSelectedPage(); /* Check the parameters */ assert_param(IS_CAN_IT_CONFIG_OK(CAN_IT)); assert_param(IS_FUNCTIONALSTATE_OK(NewState)); tmperrorinterrupt = (uint8_t)(((uint16_t)CAN_IT) >>7); tmperrorinterrupt = (uint8_t)((uint8_t)((uint16_t)tmperrorinterrupt & 0xF0) | (uint8_t)((uint8_t)((uint16_t)tmperrorinterrupt & 0x0F) >>1)); CAN->PSR = CAN_Page_Config; if (NewState != DISABLE) { /* Enable the selected CAN interrupt */ CAN->IER |= (uint8_t)(CAN_IT); CAN->Page.Config.EIER |= (uint8_t)(tmperrorinterrupt); } else { /* Disable the selected CAN interrupt */ CAN->IER &= (uint8_t)~(uint8_t)((uint16_t)CAN_IT); CAN->Page.Config.EIER &= (uint8_t)~(tmperrorinterrupt); } /*Restore Last Page*/ CAN_SelectPage(can_page); } /** * @brief Enables or Disables the ST7 CAN Compatibility. * if the ST7 compatibility is Enabled, CAN provides only 2 mailboxes. * if the ST7 compatibility is Disabled, CAN provides 3 mailboxes. * @param CAN_ST7Compatibility : CAN ST7 Compatibility , this parameter can be one of @ref CAN_ST7Compatibility_TypeDef enumeration. * @retval None */ void CAN_ST7CompatibilityCmd(CAN_ST7Compatibility_TypeDef CAN_ST7Compatibility) { /* Check the parameters */ assert_param(IS_CAN_ST7_COMPATIBILITY_OK(CAN_ST7Compatibility)); /*Reset the old configuration of TXM2E */ CAN->DGR &= (uint8_t)(~CAN_DGR_TXM2E); /*Set the old configuration of TXM2E */ CAN->DGR |= (uint8_t)CAN_ST7Compatibility; } /** * @brief Enables or disables the CAN Time TriggerOperation communication mode. * @param NewState : Mode new state , can be one of @ref FunctionalState * @retval None */ void CAN_TTComModeCmd(FunctionalState NewState) { CAN_Page_TypeDef can_page = CAN_GetSelectedPage(); /* Check the parameters */ assert_param(IS_FUNCTIONALSTATE_OK(NewState)); if (NewState != DISABLE) { /*Enable the TTCM mode */ CAN->MCR |= CAN_MCR_TTCM; /*Set TGT bits setting in Tx and FIFO pages*/ CAN->PSR = CAN_Page_TxMailBox0; CAN->Page.TxMailbox.MDLCR |= CAN_MDLCR_TGT; CAN->PSR = CAN_Page_TxMailBox1; CAN->Page.TxMailbox.MDLCR |= CAN_MDLCR_TGT; CAN->PSR = CAN_Page_TxMailBox2; CAN->Page.TxMailbox.MDLCR |= CAN_MDLCR_TGT; CAN->PSR = CAN_Page_RxFifo; CAN->Page.RxFIFO.MDLCR |= CAN_MDLCR_TGT; } else { /*Disable the TTCM mode */ CAN->MCR &= ((uint8_t)~CAN_MCR_TTCM); /*Reset TGT bits setting in Tx and FIFO pages*/ CAN->PSR = CAN_Page_TxMailBox0; CAN->Page.TxMailbox.MDLCR &= ((uint8_t)~CAN_MDLCR_TGT); CAN->PSR = CAN_Page_TxMailBox1; CAN->Page.TxMailbox.MDLCR &= ((uint8_t)~CAN_MDLCR_TGT); CAN->PSR = CAN_Page_TxMailBox2; CAN->Page.TxMailbox.MDLCR &= ((uint8_t)~CAN_MDLCR_TGT); CAN->PSR = CAN_Page_RxFifo; CAN->Page.RxFIFO.MDLCR &= ((uint8_t)~CAN_MDLCR_TGT); } /*Restore Last Page*/ CAN_SelectPage(can_page); } /** * @brief Initiates the transmission of a message. * @param CAN_Id the ID number of the message, its size depends on @ref CAN_IDE value. * @param[in] CAN_IDE the ID type of the message, this parameter can be one of the @ref CAN_Id_TypeDef enumeration. * @param[in] CAN_RTR the message type, this parameter can be one of the @ref CAN_RTR_TypeDef enumeration. * @param[in] CAN_DLC the number of data in the message type, this parameter can be a value between 0 to 7. * @param[in] CAN_Data pointer to a the @ref uint8_t table which contains data to sent. * @retval Transmit Status, this returned value can be one of the @ref CAN_TxStatus_TypeDef enumeration. */ CAN_TxStatus_TypeDef CAN_Transmit(uint32_t CAN_Id, CAN_Id_TypeDef CAN_IDE, CAN_RTR_TypeDef CAN_RTR, uint8_t CAN_DLC, uint8_t *CAN_Data) { CAN_TxStatus_TypeDef CAN_TxStatus = CAN_TxStatus_NoMailBox; CAN_Page_TypeDef can_page = CAN_GetSelectedPage(); /* Check the parameters */ assert_param(IS_CAN_IDTYPE_OK(CAN_IDE)); if (CAN_IDE != CAN_Id_Standard) { assert_param(IS_CAN_EXTID_OK(CAN_Id)); } else { assert_param(IS_CAN_STDID_OK(CAN_Id)); } assert_param(IS_CAN_RTR_OK(CAN_RTR)); assert_param(IS_CAN_DLC_OK(CAN_DLC)); /* Select one empty transmit mailbox */ if ((CAN->TPR & CAN_TPR_TME0) == CAN_TPR_TME0) { CAN_TxStatus = CAN_TxStatus_MailBox0Ok; } else if ((CAN->TPR & CAN_TPR_TME1) == CAN_TPR_TME1) { CAN_TxStatus = CAN_TxStatus_MailBox1Ok; } else if ((CAN->TPR & CAN_TPR_TME2) == CAN_TPR_TME2) { CAN_TxStatus = CAN_TxStatus_MailBox2Ok; } else { CAN_TxStatus = CAN_TxStatus_NoMailBox; } if (CAN_TxStatus != CAN_TxStatus_NoMailBox) { CAN->PSR = (uint8_t)CAN_TxStatus; /* Set up the Id */ if (CAN_IDE != CAN_Id_Standard) { CAN_Id &= (uint32_t)CAN_EXTID_SIZE; CAN->Page.TxMailbox.MIDR4 = (uint8_t)(CAN_Id); CAN_Id = CAN_Id>>8; CAN->Page.TxMailbox.MIDR3 = (uint8_t)(CAN_Id); CAN_Id = CAN_Id>>8; CAN->Page.TxMailbox.MIDR2 = (uint8_t)(CAN_Id); CAN_Id = CAN_Id>>8; CAN->Page.TxMailbox.MIDR1 = (uint8_t)(CAN_Id |CAN_IDE | CAN_RTR); } else { CAN_Id &= (uint16_t)CAN_STDID_SIZE; CAN->Page.TxMailbox.MIDR1 = (uint8_t)((CAN_Id>>6) | (CAN_RTR)) ; CAN->Page.TxMailbox.MIDR2 = (uint8_t)(CAN_Id<<2); } /* Set up the DLC */ /*clear old DLC value*/ CAN->Page.TxMailbox.MDLCR &= (uint8_t)0xF0; /*set the new value of DLC*/ CAN->Page.TxMailbox.MDLCR |= CAN_DLC; /* Set up the data field */ CAN->Page.TxMailbox.MDAR1 = CAN_Data[0]; CAN->Page.TxMailbox.MDAR2 = CAN_Data[1]; CAN->Page.TxMailbox.MDAR3 = CAN_Data[2]; CAN->Page.TxMailbox.MDAR4 = CAN_Data[3]; CAN->Page.TxMailbox.MDAR5 = CAN_Data[4]; CAN->Page.TxMailbox.MDAR6 = CAN_Data[5]; CAN->Page.TxMailbox.MDAR7 = CAN_Data[6]; CAN->Page.TxMailbox.MDAR8 = CAN_Data[7]; /* Request transmission */ CAN->Page.TxMailbox.MCSR |= CAN_MCSR_TXRQ; } /*Restore Last Page*/ CAN_SelectPage(can_page); return (CAN_TxStatus_TypeDef)CAN_TxStatus; } /** * @brief Checks the transmission of a message. * @param TransmitMailbox: the number of the mailbox that is used for transmission, can be on of @ref CAN_TransmitMailBox_TypeDef. * @retval CAN_TxStatus_Ok if the CAN driver transmits the message, CAN_TxStatus_Failed in an other case. */ CAN_TxStatus_TypeDef CAN_TransmitStatus(CAN_TransmitMailBox_TypeDef CAN_TransmitMailbox) { /* RQCP, TXOK and TME bits */ CAN_TxStatus_TypeDef tstate = CAN_TxStatus_Failed; uint8_t tmpstate=0; /* Check the parameters */ assert_param(IS_CAN_TRANSMITMAILBOX_OK(CAN_TransmitMailbox)); switch (CAN_TransmitMailbox) { case (CAN_TransmitMailBox_0): tmpstate = (uint8_t)((CAN->TSR & (uint8_t)(CAN_TSR_RQCP0|CAN_TSR_TXOK0))); tmpstate |= (uint8_t)((CAN->TPR & CAN_TPR_TME0)); break; case (CAN_TransmitMailBox_1): tmpstate = (uint8_t)((uint8_t)(CAN->TSR & (uint8_t)(CAN_TSR_RQCP1|CAN_TSR_TXOK1))>>1); tmpstate |= (uint8_t)((uint8_t)(CAN->TPR & CAN_TPR_TME1) >> 1); break; case (CAN_TransmitMailBox_2): tmpstate = (uint8_t)((uint8_t)(CAN->TSR & (uint8_t)(CAN_TSR_RQCP2|CAN_TSR_TXOK2))>>2); tmpstate |= (uint8_t)((uint8_t)(CAN->TPR & CAN_TPR_TME2) >> 2); break; default: tstate = CAN_TxStatus_Failed; break; } switch (tmpstate) { /*transmit pending */ case (0x00): tstate = CAN_TxStatus_Pending; break; /* transmit failed */ case (0x05): tstate = CAN_TxStatus_Failed; break; /* transmit succeeded */ case (0x15): tstate = CAN_TxStatus_Ok; break; /* transmit mailbox is empty : no activity on this TX mail box */ case (0x04): tstate = CAN_TxStatus_MailBoxEmpty; break; default: tstate = CAN_TxStatus_Failed; break; } return (CAN_TxStatus_TypeDef)tstate; } /** * @brief Cancels a transmit request. * @param TransmitMailbox : the Transmission mailbox, can be one of CAN_TransmitMailBox_TypeDef * @retval None */ void CAN_CancelTransmit(CAN_TransmitMailBox_TypeDef CAN_TransmitMailbox) { CAN_Page_TypeDef can_page = CAN_GetSelectedPage(); /* Check the parameters */ assert_param(IS_CAN_TRANSMITMAILBOX_OK(CAN_TransmitMailbox)); /*switch to the specific page */ CAN->PSR = (uint8_t)CAN_TransmitMailbox; /* abort transmission */ CAN->Page.TxMailbox.MCSR |= CAN_MCSR_ABRQ; /*Restore Last Page*/ CAN_SelectPage(can_page); } /** * @brief Releases the CAN FIFO. * @param None * @retval None */ void CAN_FIFORelease(void) { /* Release FIFO*/ CAN->RFR = CAN_RFR_RFOM; /*rc-w1*/ } /** * @brief Returns the number of pending messages. * @retval Number of pending messages. */ CAN_NbrPendingMessage_TypeDef CAN_MessagePending(void) { CAN_NbrPendingMessage_TypeDef msgpending = CAN_NbrPendingMessage_0; msgpending = (CAN_NbrPendingMessage_TypeDef)(CAN->RFR & CAN_RFR_FMP01); return (CAN_NbrPendingMessage_TypeDef)msgpending; } /** * @brief Receives a message which contains CAN Id, IDE, RTR * DLC, data and FMI number. * In order to get these data, use CAN_GetReceivedId(), CAN_GetReceivedIDE(), CAN_GetReceivedRTR(), * CAN_GetReceivedDLC(), CAN_GetReceivedFMI() and CAN_GetReceivedData() functions. * @param None * @retval None */ void CAN_Receive(void) { CAN_Page_TypeDef can_page = CAN_GetSelectedPage(); uint32_t temp1 = 0, temp2 = 0, temp3 = 0; /* select Fifo page*/ CAN->PSR = CAN_Page_RxFifo; /* Get the Id */ _IDE = (uint8_t)(CAN->Page.RxFIFO.MIDR1 & CAN_Id_Extended); if (_IDE != CAN_Id_Standard) { temp1 = ((uint32_t)((uint32_t)CAN->Page.RxFIFO.MIDR3) << 8); temp2 = ((uint32_t)((uint32_t)CAN->Page.RxFIFO.MIDR2) << 16); temp3 = ((uint32_t)((uint32_t)CAN->Page.RxFIFO.MIDR1 & 0x1F) << 24); _Id = (uint32_t)CAN_EXTID_SIZE & ((CAN->Page.RxFIFO.MIDR4) | temp1 | temp2 | temp3 ); } else { temp1 = (uint16_t)((uint16_t)((uint16_t)((uint16_t)CAN->Page.RxFIFO.MIDR1 & 0x1F) << 6)); temp2 = (uint16_t)((uint16_t)((uint16_t)CAN->Page.RxFIFO.MIDR2 >> 2)&0x3F); _Id = (uint16_t)CAN_STDID_SIZE & (temp1 | temp2 ); } _RTR = (uint8_t)((uint8_t)0x20 & CAN->Page.RxFIFO.MIDR1); /* Get the DLC */ _DLC = (uint8_t)(CAN->Page.RxFIFO.MDLCR & (uint8_t)0x0F); /* Get the FMI */ _FMI = CAN->Page.RxFIFO.MFMI; /* Get the data field */ _Data[0] = CAN->Page.RxFIFO.MDAR1; _Data[1] = CAN->Page.RxFIFO.MDAR2; _Data[2] = CAN->Page.RxFIFO.MDAR3; _Data[3] = CAN->Page.RxFIFO.MDAR4; _Data[4] = CAN->Page.RxFIFO.MDAR5; _Data[5] = CAN->Page.RxFIFO.MDAR6; _Data[6] = CAN->Page.RxFIFO.MDAR7; _Data[7] = CAN->Page.RxFIFO.MDAR8; /* Release the FIFO */ CAN_FIFORelease(); /*Restore Last Page*/ CAN_SelectPage(can_page); } /** * @brief Gets the CAN Id of the received message. * @param None * @retval the received CAN message Id. * @par Required preconditions: * This function is used to get data loaded by CAN_Receive function. * Before using this function, CAN_Receive function must be called. */ uint32_t CAN_GetReceivedId(void) { return (_Id); } /** * @brief Gets the CAN IDE of the received message. * @param None * @retval the received CAN message IDE. * @par Required preconditions: * This function is used to get data loaded by CAN_Receive function. * Before using this function, CAN_Receive function must be called. */ CAN_Id_TypeDef CAN_GetReceivedIDE(void) { return (CAN_Id_TypeDef)(_IDE); } /** * @brief Gets the CAN RTR of the received message. * @param None * @retval the received CAN message RTR. * @par Required preconditions: * This function is used to get data loaded by CAN_Receive function. * Before using this function, CAN_Receive function must be called. */ CAN_RTR_TypeDef CAN_GetReceivedRTR(void) { return (CAN_RTR_TypeDef)(_RTR); } /** * @brief Gets the CAN DLC of the received message. * @param None * @retval the received CAN message DLC. * @par Required preconditions: * This function is used to get data loaded by CAN_Receive function. * Before using this function, CAN_Receive function must be called. */ uint8_t CAN_GetReceivedDLC(void) { return (_DLC); } /** * @brief Gets the CAN Data of the received message. * @param CAN_DataIndexe : number of the received Data, it can * be an integer between 0 to 7. * @retval the received CAN message ith Data. * @par Required preconditions: * This function is used to get data loaded by CAN_Receive function. * Before using this function, CAN_Receive function must be called. */ uint8_t CAN_GetReceivedData(uint8_t CAN_DataIndex) { assert_param(IS_CAN_DLC_OK(CAN_DataIndex)); return (_Data[CAN_DataIndex]); } /** * @brief Gets the CAN FMI of the received message. * @param None * @retval the received CAN message FMI. * @par Required preconditions: * This function is used to get data loaded by CAN_Receive function. * Before using this function, CAN_Receive function must be called. */ uint8_t CAN_GetReceivedFMI(void) { return (_FMI); } /** * @brief Returns the Received time stamp. * @param None * @retval uint16_t the received time stamp. */ uint16_t CAN_GetMessageTimeStamp(void) { uint16_t timestamp = 0; CAN_Page_TypeDef can_page = CAN_GetSelectedPage(); /*switch to the specific page */ CAN->PSR = CAN_Page_RxFifo; /* Get the Received Time stamp */ timestamp = CAN->Page.RxFIFO.MTSRL; timestamp |= (uint16_t)(((uint16_t)CAN->Page.RxFIFO.MTSRH)<<8); /*Restore Last Page*/ CAN_SelectPage(can_page); return (uint16_t)(timestamp); } /** * @brief Enters the Sleep low power mode. * @param None * @retval CAN_Sleep_Ok if sleep entered, CAN_Sleep_Failed in an other case. */ CAN_Sleep_TypeDef CAN_Sleep(void) { CAN_Sleep_TypeDef sleepstatus = CAN_Sleep_Failed; /* Request Sleep mode */ CAN->MCR = (uint8_t)((uint8_t)(CAN->MCR & (uint8_t)(~CAN_MCR_INRQ)) | CAN_MCR_SLEEP); /* Sleep mode status */ if ((CAN->MSR & (CAN_MSR_SLAK|CAN_MSR_INAK)) == CAN_MSR_SLAK) { /* Sleep mode not entered */ sleepstatus = CAN_Sleep_Ok; } /* At this step, sleep mode status */ return (CAN_Sleep_TypeDef) sleepstatus; } /** * @brief Wakes the CAN up. * @param None * @retval CAN_WakeUp_Ok if sleep mode left, CAN_WakeUp_Failed in an other case. */ CAN_WakeUp_TypeDef CAN_WakeUp(void) { CAN_WakeUp_TypeDef wakeupstatus = CAN_WakeUp_Failed; /* Wake up request */ CAN->MCR &= (uint8_t)(~CAN_MCR_SLEEP); /* Sleep mode status */ if ((CAN->MSR & CAN_MSR_SLAK) != CAN_MSR_SLAK) { /* Sleep mode exited */ wakeupstatus = CAN_WakeUp_Ok; } /* At this step, sleep mode status */ return (CAN_WakeUp_TypeDef)wakeupstatus; } /** * @brief Select the CAN Operation mode. * @param CAN_OperatingMode CAN Operating Mode , * this parameter can be one of @ref CAN_OperatingMode_TypeDef enumeration. * @retval the status of the requested mode which can be * - CAN_ModeStatus_Failed CAN failed entering the specific mode * - CAN_ModeStatus_Success CAN Succeed entering the specific mode */ CAN_ModeStatus_TypeDef CAN_OperatingModeRequest(CAN_OperatingMode_TypeDef CAN_OperatingMode) { uint16_t timeout = CAN_ACKNOWLEDGE_TIMEOUT; uint8_t modestatus = 0; assert_param(IS_CAN_OPERATINGMODE_OK(CAN_OperatingMode)); if (CAN_OperatingMode == CAN_OperatingMode_Initialization) { /* Request initialisation */ CAN->MCR = (uint8_t)((uint8_t)(CAN->MCR & (uint8_t)(~CAN_MCR_SLEEP)) | CAN_MCR_INRQ); /* Wait the acknowledge */ while (((CAN->MSR & CAN_MODE_MASK) != CAN_MSR_INAK) && (timeout != 0)) { timeout--; } if ((CAN->MSR & CAN_MODE_MASK) != CAN_MSR_INAK) { modestatus = CAN_ModeStatus_Failed; } else { modestatus = CAN_ModeStatus_Success; } } else if (CAN_OperatingMode == CAN_OperatingMode_Normal) { /* Request leave initialisation and sleep mode and enter Normal mode */ CAN->MCR &= (uint8_t)(~(CAN_MCR_SLEEP|CAN_MCR_INRQ)); /* Wait the acknowledge */ while (((CAN->MSR & CAN_MODE_MASK) != 0) && (timeout!=0)) { timeout--; } if ((CAN->MSR & CAN_MODE_MASK) != 0) { modestatus = CAN_ModeStatus_Failed; } else { modestatus = CAN_ModeStatus_Success; } } else if (CAN_OperatingMode == CAN_OperatingMode_Sleep) { /* Request Sleep mode */ CAN->MCR = (uint8_t)((uint8_t)(CAN->MCR & (uint8_t)(~CAN_MCR_INRQ)) | CAN_MCR_SLEEP); /* Wait the acknowledge */ while (((CAN->MSR & CAN_MODE_MASK) != CAN_MSR_SLAK) && (timeout!=0)) { timeout--; } if ((CAN->MSR & CAN_MODE_MASK) != CAN_MSR_SLAK) { modestatus = CAN_ModeStatus_Failed; } else { modestatus = CAN_ModeStatus_Success; } } else { modestatus = CAN_ModeStatus_Failed; } return (CAN_ModeStatus_TypeDef)(modestatus); } /** * @brief Gets the Last Error Code. * @param None * @retval Error Code. */ CAN_ErrorCode_TypeDef CAN_GetLastErrorCode(void) { CAN_ErrorCode_TypeDef errcode = CAN_ErrorCode_NoErr; CAN_Page_TypeDef can_page = CAN_GetSelectedPage(); CAN->PSR = CAN_Page_Config; errcode = (CAN_ErrorCode_TypeDef)((CAN->Page.Config.ESR) & (CAN_ESR_LEC)); /*Restore Last Page*/ CAN_SelectPage(can_page); return (CAN_ErrorCode_TypeDef)(errcode); } /** * @brief Clears the CAN's pending flags. * @param CAN_FLAG : Flag to be cleared, can be one of the following parameters: * CAN_FLAG_RQCP0 Request MailBox0 Flag * CAN_FLAG_RQCP1 Request MailBox1 Flag * CAN_FLAG_RQCP2 Request MailBox2 Flag * CAN_FLAG_FF FIFO Full Flag * CAN_FLAG_FOV FIFO Overrun Flag * CAN_FLAG_WKU wake up Flag * CAN_FLAG_LEC Last error code Flag * @retval None */ void CAN_ClearFlag(CAN_FLAG_TypeDef CAN_Flag) { CAN_Page_TypeDef can_page = (CAN_Page_TypeDef)0; /* Check the parameters */ assert_param(IS_CAN_FLAG_CLEAR_OK(CAN_Flag)); if (((uint16_t)CAN_Flag & 0x0700)!= RESET) { if (((uint16_t)CAN_Flag & 0x020B)!= RESET) { /*Receive Flags*/ CAN->RFR = (uint8_t)(CAN_Flag); } else if (((uint16_t)CAN_Flag & 0x0403)!= RESET) { /*Transmit Flags*/ CAN->TSR = (uint8_t)(CAN_Flag); } else /*if((CAN_Flag & 0x0108)!=(uint16_t)RESET)*/ { /*wake up Flags*/ CAN->MSR = (uint8_t)(CAN_Flag); } } else { /*Error Flags*/ can_page = CAN_GetSelectedPage(); /* Clear the selected CAN flags */ CAN->PSR = CAN_Page_Config; CAN->Page.Config.ESR = (uint8_t)RESET; /*Restore Last Page*/ CAN_SelectPage(can_page); } } /** * @brief Checks whether the specified CAN flag is set or not. * @param CAN_FLAG: specifies the flag to check, can be one of @ref CAN_FLAG_TypeDef enumeration. * @retval The new state of CAN_FLAG which can be one of @ref FlagStatus. */ FlagStatus CAN_GetFlagStatus(CAN_FLAG_TypeDef CAN_Flag) { FlagStatus bitstatus = RESET; CAN_Page_TypeDef can_page = (CAN_Page_TypeDef)0; /* Check the parameters */ assert_param(IS_CAN_FLAG_STATUS_OK(CAN_Flag)); if (((uint16_t)CAN_Flag & 0x0700)!= RESET) { if (((uint16_t)CAN_Flag & 0x020B)!= RESET) { /*Receive Flags*/ if ((CAN->RFR & (uint16_t)CAN_Flag )!= RESET) { /* CAN_FLAG is set */ bitstatus = SET; } else { /* CAN_FLAG is reset */ bitstatus = RESET; } } else if (((uint16_t)CAN_Flag & 0x0403)!= RESET) { /*Transmit Flags*/ if ((CAN->TSR & (uint16_t)CAN_Flag )!= RESET) { /* CAN_FLAG is set */ bitstatus = SET; } else { /* CAN_FLAG is reset */ bitstatus = RESET; } } else /*if((CAN_Flag & 0x0108)!=(uint16_t)RESET)*/ { /*wake up Flags*/ if ((CAN->MSR & (uint16_t)CAN_Flag )!= RESET) { /* CAN_FLAG is set */ bitstatus = SET; } else { /* CAN_FLAG is reset */ bitstatus = RESET; } } } else { /*Error Flags*/ can_page = CAN_GetSelectedPage(); CAN->PSR = CAN_Page_Config; if ((CAN->Page.Config.ESR & (uint16_t)CAN_Flag) != RESET) { /* CAN_FLAG is set */ bitstatus = SET; } else { /* CAN_FLAG is reset */ bitstatus = RESET; } /*Restore Last Page*/ CAN_SelectPage(can_page); } /* Return the CAN_FLAG status */ return (FlagStatus)bitstatus; } /** * @brief Checks whether the specified CAN interrupt has occurred or not. * @param CAN_IT: specifies the CAN interrupt source to check, can be one of @ref CAN_IT_TypeDef. * @retval The new state of CAN_IT, which can be one of @ref ITStatus. */ ITStatus CAN_GetITStatus(CAN_IT_TypeDef CAN_IT) { ITStatus pendingbitstatus = RESET; CAN_Page_TypeDef can_page = CAN_GetSelectedPage(); /* Check the parameters */ assert_param(IS_CAN_IT_STATUS_OK(CAN_IT)); switch (CAN_IT) { case CAN_IT_TME: if ((CAN->IER & CAN_IER_TMEIE) !=RESET) { pendingbitstatus = CheckITStatus(CAN->TSR, CAN_TSR_RQCP012); } else { pendingbitstatus = RESET; } break; case CAN_IT_FMP: if ((CAN->IER & CAN_IER_FMPIE) !=RESET) { pendingbitstatus = CheckITStatus(CAN->RFR, CAN_RFR_FMP01); } else { pendingbitstatus = RESET; } break; case CAN_IT_FF: if ((CAN->IER & CAN_IER_FFIE) !=RESET) { pendingbitstatus = CheckITStatus(CAN->RFR, CAN_RFR_FULL); } else { pendingbitstatus = RESET; } break; case CAN_IT_FOV: if ((CAN->IER & CAN_IER_FOVIE) !=RESET) { pendingbitstatus = CheckITStatus(CAN->RFR, CAN_RFR_FOVR); } else { pendingbitstatus = RESET; } break; case CAN_IT_WKU: if ((CAN->IER & CAN_IER_WKUIE) !=RESET) { pendingbitstatus = CheckITStatus(CAN->MSR, CAN_MSR_WKUI); } else { pendingbitstatus = RESET; } break; case CAN_IT_ERR: CAN->PSR = CAN_Page_Config; if ((CAN->Page.Config.EIER & CAN_EIER_ERRIE) !=RESET) { pendingbitstatus = CheckITStatus(CAN->Page.Config.ESR, CAN_ESR_EWGF|CAN_ESR_EPVF|CAN_ESR_BOFF|CAN_ESR_LEC); } else { pendingbitstatus = RESET; } break; case CAN_IT_EWG: CAN->PSR = CAN_Page_Config; if ((CAN->Page.Config.EIER & CAN_EIER_EWGIE) !=RESET) { pendingbitstatus = CheckITStatus(CAN->Page.Config.ESR, CAN_ESR_EWGF); } else { pendingbitstatus = RESET; } break; case CAN_IT_EPV: CAN->PSR = CAN_Page_Config; if ((CAN->Page.Config.EIER & CAN_EIER_EPVIE) !=RESET) { pendingbitstatus = CheckITStatus(CAN->Page.Config.ESR, CAN_ESR_EPVF); } else { pendingbitstatus = RESET; } break; case CAN_IT_BOF: CAN->PSR = CAN_Page_Config; if ((CAN->Page.Config.EIER & CAN_EIER_BOFIE) !=RESET) { pendingbitstatus = CheckITStatus(CAN->Page.Config.ESR, CAN_ESR_BOFF); } else { pendingbitstatus = RESET; } break; case CAN_IT_LEC: CAN->PSR = CAN_Page_Config; if ((CAN->Page.Config.EIER & CAN_EIER_LECIE) !=RESET) { pendingbitstatus = CheckITStatus(CAN->Page.Config.ESR, CAN_ESR_LEC); } else { pendingbitstatus = RESET; } break; default : pendingbitstatus = RESET; break; } /*Restore Last Page*/ CAN_SelectPage(can_page); /* Return the CAN_IT status */ return (ITStatus)pendingbitstatus; } /** * @brief Clears the CANs interrupt pending bits. * @param CAN_IT: specifies the interrupt pending bit to clear, * can be one of the following parameters: * CAN_IT_TME = Transmit mailbox empty interrupt * CAN_IT_FF =FIFO full interrupt * CAN_IT_FOV =FIFO overrun interrupt * CAN_IT_WKU =Wake-up interrupt * CAN_IT_ERR =General Error interrupt * CAN_IT_EWG =Error warning interrupt * CAN_IT_EPV =Error passive interrupt * CAN_IT_BOF = Bus-off interrupt * CAN_IT_LEC =Last error code interrupt * @retval None */ void CAN_ClearITPendingBit(CAN_IT_TypeDef CAN_IT) { CAN_Page_TypeDef can_page = CAN_GetSelectedPage(); /* Check the parameters */ assert_param(IS_CAN_IT_PENDING_BIT_OK(CAN_IT)); switch (CAN_IT) { case CAN_IT_TME: CAN->TSR = CAN_TSR_RQCP012;/* rc_w1*/ break; case CAN_IT_FF: CAN->RFR = CAN_RFR_FULL; /* rc_w1*/ break; case CAN_IT_FOV: CAN->RFR = CAN_RFR_FOVR; /* rc_w1*/ break; case CAN_IT_WKU: CAN->MSR = CAN_MSR_WKUI; /* rc_w1*/ break; case CAN_IT_ERR: CAN->PSR = CAN_Page_Config; CAN->Page.Config.ESR = (uint8_t)CAN_ESR_RESET_VALUE; CAN->MSR = CAN_MSR_ERRI; break; case CAN_IT_EWG: CAN->MSR = CAN_MSR_ERRI; break; case CAN_IT_EPV: CAN->MSR = CAN_MSR_ERRI; break; case CAN_IT_BOF: CAN->MSR = CAN_MSR_ERRI; break; case CAN_IT_LEC: CAN->PSR = CAN_Page_Config; CAN->Page.Config.ESR = (uint8_t)CAN_ESR_RESET_VALUE; break; default : break; } /*Restore Last Page*/ CAN_SelectPage(can_page); } /** * @brief Gets the selected registers page. * @param None * @retval the selected page which can be one of the @ref CAN_Page_TypeDef. */ CAN_Page_TypeDef CAN_GetSelectedPage(void) { return (CAN_Page_TypeDef)(CAN->PSR); } /** * @brief Sets the registers page to be selected. * @param the selected page which can be one of the @ref CAN_Page_TypeDef. * @retval None */ void CAN_SelectPage(CAN_Page_TypeDef CAN_Page) { CAN->PSR = (uint8_t)CAN_Page; } /** * @brief Checks whether the CAN interrupt has occurred or not. * @param CAN_Reg: specifies the CAN interrupt register to check. * @param It_Bit: specifies the interrupt source bit to check. * @retval The new state of the CAN Interrupt, which can be one of ITStatus. */ static ITStatus CheckITStatus(uint8_t CAN_Reg, uint8_t It_Bit) { ITStatus pendingbitstatus = RESET; if ((CAN_Reg & It_Bit) != (uint8_t)RESET) { /* CAN_IT is set */ pendingbitstatus = SET; } else { /* CAN_IT is reset */ pendingbitstatus = RESET; } return (ITStatus)pendingbitstatus; } /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/